gecko/browser/components/tabview/storagePolicy.js

209 lines
7.2 KiB
JavaScript
Raw Normal View History

/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is storagePolicy.js.
*
* The Initial Developer of the Original Code is
* the Mozilla Foundation.
* Portions created by the Initial Developer are Copyright (C) 2011
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
* Tim Taubert <ttaubert@mozilla.com>
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
// **********
// Title: storagePolicy.js
// ##########
// Class: StoragePolicy
// Singleton for implementing a storage policy for sensitive data.
let StoragePolicy = {
// Pref that controls whether we can store SSL content on disk
PREF_DISK_CACHE_SSL: "browser.cache.disk_cache_ssl",
// Used to keep track of disk_cache_ssl preference
_enablePersistentHttpsCaching: null,
// Used to keep track of browsers whose data we shouldn't store permanently
_deniedBrowsers: [],
// ----------
// Function: toString
// Prints [StoragePolicy] for debug use.
toString: function StoragePolicy_toString() {
return "[StoragePolicy]";
},
// ----------
// Function: init
// Initializes the StoragePolicy object.
init: function StoragePolicy_init() {
// store the preference value
this._enablePersistentHttpsCaching =
Services.prefs.getBoolPref(this.PREF_DISK_CACHE_SSL);
Services.prefs.addObserver(this.PREF_DISK_CACHE_SSL, this, false);
// tabs are already loaded before UI is initialized so cache-control
// values are unknown. We add browsers with https to the list for now.
if (!this._enablePersistentHttpsCaching)
Array.forEach(gBrowser.browsers, this._initializeBrowser.bind(this));
// make sure to remove tab browsers when tabs get closed
this._onTabClose = this._onTabClose.bind(this);
gBrowser.tabContainer.addEventListener("TabClose", this._onTabClose, false);
let mm = gWindow.messageManager;
// add message listeners for storage granted
this._onGranted = this._onGranted.bind(this);
mm.addMessageListener("Panorama:StoragePolicy:granted", this._onGranted);
// add message listeners for storage denied
this._onDenied = this._onDenied.bind(this);
mm.addMessageListener("Panorama:StoragePolicy:denied", this._onDenied);
},
// ----------
// Function: _initializeBrowser
// Initializes the given browser and checks if we need to add it to our
// internal exclusion list.
_initializeBrowser: function StoragePolicy__initializeBrowser(browser) {
let self = this;
function checkExclusion() {
if (browser.currentURI.schemeIs("https"))
self._deniedBrowsers.push(browser);
}
function waitForDocumentLoad() {
let mm = browser.messageManager;
mm.addMessageListener("Panorama:DOMContentLoaded", function onLoad(cx) {
mm.removeMessageListener(cx.name, onLoad);
checkExclusion(browser);
});
}
this._isDocumentLoaded(browser, function (isLoaded) {
if (isLoaded)
checkExclusion();
else
waitForDocumentLoad();
});
},
// ----------
// Function: _isDocumentLoaded
// Check if the given browser's document is loaded.
_isDocumentLoaded: function StoragePolicy__isDocumentLoaded(browser, callback) {
let mm = browser.messageManager;
let message = "Panorama:isDocumentLoaded";
mm.addMessageListener(message, function onMessage(cx) {
mm.removeMessageListener(cx.name, onMessage);
callback(cx.json.isLoaded);
});
mm.sendAsyncMessage(message);
},
// ----------
// Function: uninit
// Is called by UI.init() when the browser windows is closed.
uninit: function StoragePolicy_uninit() {
Services.prefs.removeObserver(this.PREF_DISK_CACHE_SSL, this);
gBrowser.removeTabsProgressListener(this);
gBrowser.tabContainer.removeEventListener("TabClose", this._onTabClose, false);
let mm = gWindow.messageManager;
// remove message listeners
mm.removeMessageListener("Panorama:StoragePolicy:granted", this._onGranted);
mm.removeMessageListener("Panorama:StoragePolicy:denied", this._onDenied);
},
// ----------
// Function: _onGranted
// Handle the 'granted' message and remove the given browser from the list
// of denied browsers.
_onGranted: function StoragePolicy__onGranted(cx) {
let index = this._deniedBrowsers.indexOf(cx.target);
if (index > -1)
this._deniedBrowsers.splice(index, 1);
},
// ----------
// Function: _onDenied
// Handle the 'denied' message and add the given browser to the list of denied
// browsers.
_onDenied: function StoragePolicy__onDenied(cx) {
// exclusion is optional because cache-control is not no-store or public and
// the protocol is https. don't exclude when persistent https caching is
// enabled.
if ("https" == cx.json.reason && this._enablePersistentHttpsCaching)
return;
let browser = cx.target;
if (this._deniedBrowsers.indexOf(browser) == -1)
this._deniedBrowsers.push(browser);
},
// ----------
// Function: _onTabClose
// Remove the browser from our internal exclusion list when a tab gets closed.
_onTabClose: function StoragePolicy__onTabClose(event) {
let browser = event.target.linkedBrowser;
let index = this._deniedBrowsers.indexOf(browser);
if (index > -1)
this._deniedBrowsers.splice(index, 1);
},
// ----------
// Function: canStoreThumbnailForTab
// Returns whether we're allowed to store the thumbnail of the given tab.
canStoreThumbnailForTab: function StoragePolicy_canStoreThumbnailForTab(tab) {
// deny saving thumbnails in private browsing mode
if (gPrivateBrowsing.privateBrowsingEnabled &&
UI._privateBrowsing.transitionMode != "enter")
return false;
return (this._deniedBrowsers.indexOf(tab.linkedBrowser) == -1);
},
// ----------
// Function: observe
// Observe pref changes.
observe: function StoragePolicy_observe(subject, topic, data) {
this._enablePersistentHttpsCaching =
Services.prefs.getBoolPref(this.PREF_DISK_CACHE_SSL);
}
};