The Tor Browser: browser/metro/base/content/sanitize.js@b8a032363ba2 (annotated)

browser/metro/base/content/sanitize.js@b8a032363ba2 (annotated)

browser/metro/base/content/sanitize.js

Thu, 22 Jan 2015 13:21:57 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 22 Jan 2015 13:21:57 +0100
branch: TOR_BUG_9701
changeset 15: b8a032363ba2
permissions: -rw-r--r--

Incorporate requested changes from Mozilla in review:
https://bugzilla.mozilla.org/show_bug.cgi?id=1123480#c6

 // -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 XPCOMUtils.defineLazyModuleGetter(this, "LoadContextInfo",
                                   "resource://gre/modules/LoadContextInfo.jsm");
 function Sanitizer() {}
 Sanitizer.prototype = {
   // warning to the caller: this one may raise an exception (e.g. bug #265028)
   clearItem: function (aItemName)
   {
     if (this.items[aItemName].canClear)
       this.items[aItemName].clear();
   },
   canClearItem: function (aItemName, aCallback, aArg)
   {
     let canClear = this.items[aItemName].canClear;
     if (typeof canClear == "function"){
       canClear(aCallback, aArg);
     } else {
       aCallback(aItemName, canClear, aArg);
     }
   },
   _prefDomain: "privacy.item.",
   getNameFromPreference: function (aPreferenceName)
   {
     return aPreferenceName.substr(this._prefDomain.length);
   },
   /**
    * Deletes privacy sensitive data in a batch, according to user preferences
    *
    * @returns  null if everything's fine;  an object in the form
    *           { itemName: error, ... } on (partial) failure
    */
   sanitize: function ()
   {
     var branch = Services.prefs.getBranch(this._prefDomain);
     var errors = null;
     for (var itemName in this.items) {
       if ("clear" in item && branch.getBoolPref(itemName)) {
         // Some of these clear() may raise exceptions (see bug #265028)
         // to sanitize as much as possible, we catch and store them,
         // rather than fail fast.
         // Callers should check returned errors and give user feedback
         // about items that could not be sanitized
         let clearCallback = (itemName, aCanClear) => {
           let item = this.items[itemName];
           try{
             if (aCanClear){
               item.clear();
             }
           } catch(er){
             if (!errors){
               errors = {};
             }
             errors[itemName] = er;
             dump("Error sanitizing " + itemName + ":" + er + "\n");
           }
         }
         this.canClearItem(itemName, clearCallback);
       }
     }
     return errors;
   },
   items: {
     // Clear Sync account before passwords so that Sync still has access to the
     // credentials to clean up device-specific records on the server. Also
     // disable it before wiping history so we don't accidentally sync that.
     syncAccount: {
       clear: function ()
       {
         Sync.disconnect();
       },
       get canClear()
       {
         return (Weave.Status.checkSetup() != Weave.CLIENT_NOT_CONFIGURED);
       }
     },
     cache: {
       clear: function ()
       {
         var cache = Cc["@mozilla.org/netwerk/cache-storage-service;1"].getService(Ci.nsICacheStorageService);
         try {
           cache.clear();
         } catch(er) {}
         let imageCache = Cc["@mozilla.org/image/cache;1"].getService(Ci.imgICache);
         try {
           imageCache.clearCache(false); // true=chrome, false=content
         } catch(er) {}
       },
       get canClear()
       {
         return true;
       }
     },
     cookies: {
       clear: function ()
       {
         var cookieMgr = Cc["@mozilla.org/cookiemanager;1"].getService(Ci.nsICookieManager);
         cookieMgr.removeAll();
       },
       get canClear()
       {
         return true;
       }
     },
     siteSettings: {
       clear: function ()
       {
         // Clear site-specific permissions like "Allow this site to open popups"
         Services.perms.removeAll();
         // Clear site-specific settings like page-zoom level
         var cps = Cc["@mozilla.org/content-pref/service;1"].getService(Ci.nsIContentPrefService2);
         cps.removeAllDomains(null);
         // Clear "Never remember passwords for this site", which is not handled by
         // the permission manager
         var pwmgr = Cc["@mozilla.org/login-manager;1"].getService(Ci.nsILoginManager);
         var hosts = pwmgr.getAllDisabledHosts({})
         for each (var host in hosts) {
           pwmgr.setLoginSavingEnabled(host, true);
         }
       },
       get canClear()
       {
         return true;
       }
     },
     offlineApps: {
       clear: function ()
       {
         var cacheService = Cc["@mozilla.org/netwerk/cache-storage-service;1"].getService(Ci.nsICacheStorageService);
         var appCacheStorage = cacheService.appCacheStorage(LoadContextInfo.default, null);
         try {
           appCacheStorage.asyncEvictStorage(null);
         } catch(er) {}
       },
       get canClear()
       {
           return true;
       }
     },
     history: {
       clear: function ()
       {
         try {
           Services.obs.notifyObservers(null, "browser:purge-session-history", "");
         }
         catch (e) {
           Components.utils.reportError("Failed to notify observers of "
                                      + "browser:purge-session-history: "
                                      + e);
         }
       },
       get canClear()
       {
         // bug 347231: Always allow clearing history due to dependencies on
         // the browser:purge-session-history notification. (like error console)
         return true;
       }
     },
     formdata: {
       clear: function ()
       {
         //Clear undo history of all searchBars
         var windows = Services.wm.getEnumerator("navigator:browser");
         while (windows.hasMoreElements()) {
           var searchBar = windows.getNext().document.getElementById("searchbar");
           if (searchBar) {
             searchBar.value = "";
             searchBar.textbox.editor.transactionManager.clear();
           }
         }
         FormHistory.update({op : "remove"});
       },
       canClear : function(aCallback, aArg)
       {
         let count = 0;
         let countDone = {
           handleResult : function(aResult) { count = aResult; },
           handleError : function(aError) { Components.utils.reportError(aError); },
           handleCompletion : function(aReason) { aCallback("formdata", aReason == 0 && count > 0, aArg); }
         };
         FormHistory.count({}, countDone);
       }
     },
     downloads: {
       clear: function ()
       {
         var dlMgr = Cc["@mozilla.org/download-manager;1"].getService(Ci.nsIDownloadManager);
         dlMgr.cleanUp();
       },
       get canClear()
       {
         var dlMgr = Cc["@mozilla.org/download-manager;1"].getService(Ci.nsIDownloadManager);
         return dlMgr.canCleanUp;
       }
     },
     passwords: {
       clear: function ()
       {
         var pwmgr = Cc["@mozilla.org/login-manager;1"].getService(Ci.nsILoginManager);
         pwmgr.removeAllLogins();
       },
       get canClear()
       {
         var pwmgr = Cc["@mozilla.org/login-manager;1"].getService(Ci.nsILoginManager);
         var count = pwmgr.countLogins("", "", ""); // count all logins
         return (count > 0);
       }
     },
     sessions: {
       clear: function ()
       {
         // clear all auth tokens
         var sdr = Cc["@mozilla.org/security/sdr;1"].getService(Ci.nsISecretDecoderRing);
         sdr.logoutAndTeardown();
         // clear plain HTTP auth sessions
         var authMgr = Cc['@mozilla.org/network/http-auth-manager;1'].getService(Ci.nsIHttpAuthManager);
         authMgr.clearAll();
       },
       get canClear()
       {
         return true;
       }
     }
   }
 };
 // "Static" members
 Sanitizer.prefDomain          = "privacy.sanitize.";
 Sanitizer.prefShutdown        = "sanitizeOnShutdown";
 Sanitizer.prefDidShutdown     = "didShutdownSanitize";
 Sanitizer._prefs = null;
 Sanitizer.__defineGetter__("prefs", function()
 {
   return Sanitizer._prefs ? Sanitizer._prefs
     : Sanitizer._prefs = Cc["@mozilla.org/preferences-service;1"]
                          .getService(Ci.nsIPrefService)
                          .getBranch(Sanitizer.prefDomain);
 });
 /**
  * Deletes privacy sensitive data in a batch, optionally showing the
  * sanitize UI, according to user preferences
  *
  * @returns  null if everything's fine
  *           an object in the form { itemName: error, ... } on (partial) failure
  */
 Sanitizer.sanitize = function()
 {
   return new Sanitizer().sanitize();
 };
 Sanitizer.onStartup = function()
 {
   // we check for unclean exit with pending sanitization
   Sanitizer._checkAndSanitize();
 };
 Sanitizer.onShutdown = function()
 {
   // we check if sanitization is needed and perform it
   Sanitizer._checkAndSanitize();
 };
 // this is called on startup and shutdown, to perform pending sanitizations
 Sanitizer._checkAndSanitize = function()
 {
   const prefs = Sanitizer.prefs;
   if (prefs.getBoolPref(Sanitizer.prefShutdown) &&
       !prefs.prefHasUserValue(Sanitizer.prefDidShutdown)) {
     // this is a shutdown or a startup after an unclean exit
     Sanitizer.sanitize() || // sanitize() returns null on full success
       prefs.setBoolPref(Sanitizer.prefDidShutdown, true);
   }
 };