The Tor Browser: toolkit/mozapps/update/nsUpdateService.js@129ffea94266 (annotated)

toolkit/mozapps/update/nsUpdateService.js@129ffea94266 (annotated)

toolkit/mozapps/update/nsUpdateService.js

Sat, 03 Jan 2015 20:18:00 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Sat, 03 Jan 2015 20:18:00 +0100
branch: TOR_BUG_3246
changeset 7: 129ffea94266
permissions: -rw-r--r--

Conditionally enable double key logic according to:
private browsing mode or privacy.thirdparty.isolate preference and
implement in GetCookieStringCommon and FindCookie where it counts...
With some reservations of how to convince FindCookie users to test
condition and pass a nullptr when disabling double key logic.

 #filter substitution
 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /*
 # 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/.
 */
 Components.utils.import("resource://gre/modules/XPCOMUtils.jsm");
 Components.utils.import("resource://gre/modules/FileUtils.jsm");
 Components.utils.import("resource://gre/modules/AddonManager.jsm");
 Components.utils.import("resource://gre/modules/Services.jsm");
 #ifdef BUILD_CTYPES
 #ifdef XP_WIN
 Components.utils.import("resource://gre/modules/ctypes.jsm");
 #endif
 #endif
 const Cc = Components.classes;
 const Ci = Components.interfaces;
 const Cr = Components.results;
 const Cu = Components.utils;
 const UPDATESERVICE_CID = Components.ID("{B3C290A6-3943-4B89-8BBE-C01EB7B3B311}");
 const UPDATESERVICE_CONTRACTID = "@mozilla.org/updates/update-service;1";
 const PREF_APP_UPDATE_ALTWINDOWTYPE       = "app.update.altwindowtype";
 const PREF_APP_UPDATE_AUTO                = "app.update.auto";
 const PREF_APP_UPDATE_BACKGROUND_INTERVAL = "app.update.download.backgroundInterval";
 const PREF_APP_UPDATE_BACKGROUNDERRORS    = "app.update.backgroundErrors";
 const PREF_APP_UPDATE_BACKGROUNDMAXERRORS = "app.update.backgroundMaxErrors";
 const PREF_APP_UPDATE_CERTS_BRANCH        = "app.update.certs.";
 const PREF_APP_UPDATE_CERT_CHECKATTRS     = "app.update.cert.checkAttributes";
 const PREF_APP_UPDATE_CERT_ERRORS         = "app.update.cert.errors";
 const PREF_APP_UPDATE_CERT_MAXERRORS      = "app.update.cert.maxErrors";
 const PREF_APP_UPDATE_CERT_REQUIREBUILTIN = "app.update.cert.requireBuiltIn";
 const PREF_APP_UPDATE_CUSTOM              = "app.update.custom";
 const PREF_APP_UPDATE_ENABLED             = "app.update.enabled";
 const PREF_APP_UPDATE_METRO_ENABLED       = "app.update.metro.enabled";
 const PREF_APP_UPDATE_IDLETIME            = "app.update.idletime";
 const PREF_APP_UPDATE_INCOMPATIBLE_MODE   = "app.update.incompatible.mode";
 const PREF_APP_UPDATE_INTERVAL            = "app.update.interval";
 const PREF_APP_UPDATE_LASTUPDATETIME      = "app.update.lastUpdateTime.background-update-timer";
 const PREF_APP_UPDATE_LOG                 = "app.update.log";
 const PREF_APP_UPDATE_MODE                = "app.update.mode";
 const PREF_APP_UPDATE_NEVER_BRANCH        = "app.update.never.";
 const PREF_APP_UPDATE_NOTIFIEDUNSUPPORTED = "app.update.notifiedUnsupported";
 const PREF_APP_UPDATE_POSTUPDATE          = "app.update.postupdate";
 const PREF_APP_UPDATE_PROMPTWAITTIME      = "app.update.promptWaitTime";
 const PREF_APP_UPDATE_SHOW_INSTALLED_UI   = "app.update.showInstalledUI";
 const PREF_APP_UPDATE_SILENT              = "app.update.silent";
 const PREF_APP_UPDATE_STAGING_ENABLED     = "app.update.staging.enabled";
 const PREF_APP_UPDATE_URL                 = "app.update.url";
 const PREF_APP_UPDATE_URL_DETAILS         = "app.update.url.details";
 const PREF_APP_UPDATE_URL_OVERRIDE        = "app.update.url.override";
 const PREF_APP_UPDATE_SERVICE_ENABLED     = "app.update.service.enabled";
 const PREF_APP_UPDATE_SERVICE_ERRORS      = "app.update.service.errors";
 const PREF_APP_UPDATE_SERVICE_MAX_ERRORS  = "app.update.service.maxErrors";
 const PREF_APP_UPDATE_SOCKET_ERRORS       = "app.update.socket.maxErrors";
 const PREF_APP_UPDATE_RETRY_TIMEOUT       = "app.update.socket.retryTimeout";
 const PREF_APP_DISTRIBUTION               = "distribution.id";
 const PREF_APP_DISTRIBUTION_VERSION       = "distribution.version";
 const PREF_APP_B2G_VERSION                = "b2g.version";
 const PREF_EM_HOTFIX_ID                   = "extensions.hotfix.id";
 const URI_UPDATE_PROMPT_DIALOG  = "chrome://mozapps/content/update/updates.xul";
 const URI_UPDATE_HISTORY_DIALOG = "chrome://mozapps/content/update/history.xul";
 const URI_BRAND_PROPERTIES      = "chrome://branding/locale/brand.properties";
 const URI_UPDATES_PROPERTIES    = "chrome://mozapps/locale/update/updates.properties";
 const URI_UPDATE_NS             = "http://www.mozilla.org/2005/app-update";
 const CATEGORY_UPDATE_TIMER               = "update-timer";
 const KEY_GRED            = "GreD";
 const KEY_UPDROOT         = "UpdRootD";
 const KEY_EXECUTABLE      = "XREExeF";
 #ifdef TOR_BROWSER_VERSION
 #expand const TOR_BROWSER_VERSION = __TOR_BROWSER_VERSION__;
 #endif
 #ifdef MOZ_WIDGET_GONK
 #define USE_UPDATE_ARCHIVE_DIR
 #endif
 #ifdef USE_UPDATE_ARCHIVE_DIR
 const KEY_UPDATE_ARCHIVE_DIR = "UpdArchD"
 #endif
 #ifdef XP_WIN
 #define CHECK_CAN_USE_SERVICE
 #elifdef MOZ_WIDGET_GONK
 // In Gonk, the updater will remount the /system partition to move staged files
 // into place, so we skip the test here to keep things isolated.
 #define CHECK_CAN_USE_SERVICE
 #endif
 const DIR_UPDATES         = "updates";
 #ifdef XP_MACOSX
 const UPDATED_DIR         = "Updated.app";
 #else
 const UPDATED_DIR         = "updated";
 #endif
 const FILE_UPDATE_STATUS  = "update.status";
 const FILE_UPDATE_VERSION = "update.version";
 #ifdef MOZ_WIDGET_ANDROID
 const FILE_UPDATE_ARCHIVE = "update.apk";
 #else
 const FILE_UPDATE_ARCHIVE = "update.mar";
 #endif
 const FILE_UPDATE_LINK    = "update.link";
 const FILE_UPDATE_LOG     = "update.log";
 const FILE_UPDATES_DB     = "updates.xml";
 const FILE_UPDATE_ACTIVE  = "active-update.xml";
 const FILE_PERMS_TEST     = "update.test";
 const FILE_LAST_LOG       = "last-update.log";
 const FILE_BACKUP_LOG     = "backup-update.log";
 const FILE_UPDATE_LOCALE  = "update.locale";
 const STATE_NONE            = "null";
 const STATE_DOWNLOADING     = "downloading";
 const STATE_PENDING         = "pending";
 const STATE_PENDING_SVC     = "pending-service";
 const STATE_APPLYING        = "applying";
 const STATE_APPLIED         = "applied";
 const STATE_APPLIED_OS      = "applied-os";
 const STATE_APPLIED_SVC     = "applied-service";
 const STATE_SUCCEEDED       = "succeeded";
 const STATE_DOWNLOAD_FAILED = "download-failed";
 const STATE_FAILED          = "failed";
 // From updater/errors.h:
 const WRITE_ERROR        = 7;
 // const UNEXPECTED_ERROR   = 8; // Replaced with errors 38-42
 const ELEVATION_CANCELED = 9;
 // Windows service specific errors
 const SERVICE_UPDATER_COULD_NOT_BE_STARTED = 24;
 const SERVICE_NOT_ENOUGH_COMMAND_LINE_ARGS = 25;
 const SERVICE_UPDATER_SIGN_ERROR           = 26;
 const SERVICE_UPDATER_COMPARE_ERROR        = 27;
 const SERVICE_UPDATER_IDENTITY_ERROR       = 28;
 const SERVICE_STILL_APPLYING_ON_SUCCESS    = 29;
 const SERVICE_STILL_APPLYING_ON_FAILURE    = 30;
 const SERVICE_UPDATER_NOT_FIXED_DRIVE      = 31;
 const SERVICE_COULD_NOT_LOCK_UPDATER       = 32;
 const SERVICE_INSTALLDIR_ERROR             = 33;
 const SERVICE_COULD_NOT_COPY_UPDATER       = 49;
 const WRITE_ERROR_ACCESS_DENIED                     = 35;
 // const WRITE_ERROR_SHARING_VIOLATION                 = 36; // Replaced with errors 46-48
 const WRITE_ERROR_CALLBACK_APP                      = 37;
 const INVALID_UPDATER_STATUS_CODE                   = 38;
 const UNEXPECTED_BZIP_ERROR                         = 39;
 const UNEXPECTED_MAR_ERROR                          = 40;
 const UNEXPECTED_BSPATCH_ERROR                      = 41;
 const UNEXPECTED_FILE_OPERATION_ERROR               = 42;
 const FILESYSTEM_MOUNT_READWRITE_ERROR              = 43;
 const FOTA_GENERAL_ERROR                            = 44;
 const FOTA_UNKNOWN_ERROR                            = 45;
 const WRITE_ERROR_SHARING_VIOLATION_SIGNALED        = 46;
 const WRITE_ERROR_SHARING_VIOLATION_NOPROCESSFORPID = 47;
 const WRITE_ERROR_SHARING_VIOLATION_NOPID           = 48;
 const FOTA_FILE_OPERATION_ERROR                     = 49;
 const FOTA_RECOVERY_ERROR                           = 50;
 const CERT_ATTR_CHECK_FAILED_NO_UPDATE  = 100;
 const CERT_ATTR_CHECK_FAILED_HAS_UPDATE = 101;
 const BACKGROUNDCHECK_MULTIPLE_FAILURES = 110;
 const NETWORK_ERROR_OFFLINE             = 111;
 const FILE_ERROR_TOO_BIG                = 112;
 // Error codes should be < 1000. Errors above 1000 represent http status codes
 const HTTP_ERROR_OFFSET                 = 1000;
 const DOWNLOAD_CHUNK_SIZE           = 300000; // bytes
 const DOWNLOAD_BACKGROUND_INTERVAL  = 600;    // seconds
 const DOWNLOAD_FOREGROUND_INTERVAL  = 0;
 const UPDATE_WINDOW_NAME      = "Update:Wizard";
 // The number of consecutive failures when updating using the service before
 // setting the app.update.service.enabled preference to false.
 const DEFAULT_SERVICE_MAX_ERRORS = 10;
 // The number of consecutive socket errors to allow before falling back to
 // downloading a different MAR file or failing if already downloading the full.
 const DEFAULT_SOCKET_MAX_ERRORS = 10;
 // The number of milliseconds to wait before retrying a connection error.
 const DEFAULT_UPDATE_RETRY_TIMEOUT = 2000;
 // A background download is in progress (no notification)
 const PING_BGUC_IS_DOWNLOADING               = 0;
 // An update is staged (no notification)
 const PING_BGUC_IS_STAGED                    = 1;
 // Invalid url for app.update.url default preference (no notification)
 const PING_BGUC_INVALID_DEFAULT_URL          = 2;
 // Invalid url for app.update.url user preference (no notification)
 const PING_BGUC_INVALID_CUSTOM_URL           = 3;
 // Invalid url for app.update.url.override user preference (no notification)
 const PING_BGUC_INVALID_OVERRIDE_URL         = 4;
 // Unable to check for updates per gCanCheckForUpdates and hasUpdateMutex()
 // (no notification)
 const PING_BGUC_UNABLE_TO_CHECK              = 5;
 // Already has an active update in progress (no notification)
 const PING_BGUC_HAS_ACTIVEUPDATE             = 6;
 // Background checks disabled by preference (no notification)
 const PING_BGUC_PREF_DISABLED                = 7;
 // Background checks disabled for the current session (no notification)
 const PING_BGUC_DISABLED_FOR_SESSION         = 8;
 // Background checks disabled in Metro (no notification)
 const PING_BGUC_METRO_DISABLED               = 9;
 // Unable to perform a background check while offline (no notification)
 const PING_BGUC_OFFLINE                      = 10;
 // No update found certificate check failed and threshold reached
 // (possible mitm attack notification)
 const PING_BGUC_CERT_ATTR_NO_UPDATE_NOTIFY   = 11;
 // No update found certificate check failed and threshold not reached
 // (no notification)
 const PING_BGUC_CERT_ATTR_NO_UPDATE_SILENT   = 12;
 // Update found certificate check failed and threshold reached
 // (possible mitm attack notification)
 const PING_BGUC_CERT_ATTR_WITH_UPDATE_NOTIFY = 13;
 // Update found certificate check failed and threshold not reached
 // (no notification)
 const PING_BGUC_CERT_ATTR_WITH_UPDATE_SILENT = 14;
 // General update check failure and threshold reached
 // (check failure notification)
 const PING_BGUC_GENERAL_ERROR_NOTIFY         = 15;
 // General update check failure and threshold not reached
 // (no notification)
 const PING_BGUC_GENERAL_ERROR_SILENT         = 16;
 // No update found (no notification)
 const PING_BGUC_NO_UPDATE_FOUND              = 17;
 // No compatible update found though there were updates (no notification)
 const PING_BGUC_NO_COMPAT_UPDATE_FOUND       = 18;
 // Update found for a previous version (no notification)
 const PING_BGUC_UPDATE_PREVIOUS_VERSION      = 19;
 // Update found for a version with the never preference set (no notification)
 const PING_BGUC_UPDATE_NEVER_PREF            = 20;
 // Update found without a type attribute (no notification)
 const PING_BGUC_UPDATE_INVALID_TYPE          = 21;
 // The system is no longer supported (system unsupported notification)
 const PING_BGUC_UNSUPPORTED                  = 22;
 // Unable to apply updates (manual install to update notification)
 const PING_BGUC_UNABLE_TO_APPLY              = 23;
 // Showing prompt due to the update.xml specifying showPrompt
 // (update notification)
 const PING_BGUC_SHOWPROMPT_SNIPPET           = 24;
 // Showing prompt due to preference (update notification)
 const PING_BGUC_SHOWPROMPT_PREF              = 25;
 // Incompatible add-on check disabled by preference (background download)
 const PING_BGUC_ADDON_PREF_DISABLED          = 26;
 // Incompatible add-on not checked not performed due to same update version and
 // app version (background download)
 const PING_BGUC_ADDON_SAME_APP_VER           = 27;
 // No incompatible add-ons found during incompatible check (background download)
 const PING_BGUC_CHECK_NO_INCOMPAT            = 28;
 // Incompatible add-ons found and all of them have updates (background download)
 const PING_BGUC_ADDON_UPDATES_FOR_INCOMPAT   = 29;
 // Incompatible add-ons found (update notification)
 const PING_BGUC_ADDON_HAVE_INCOMPAT          = 30;
 var gLocale = null;
 var gUpdateMutexHandle = null;
 #ifdef MOZ_WIDGET_GONK
 var gSDCardMountLock = null;
 XPCOMUtils.defineLazyGetter(this, "gExtStorage", function aus_gExtStorage() {
     return Services.env.get("EXTERNAL_STORAGE");
 });
 #endif
 XPCOMUtils.defineLazyModuleGetter(this, "UpdateChannel",
                                   "resource://gre/modules/UpdateChannel.jsm");
 XPCOMUtils.defineLazyGetter(this, "gLogEnabled", function aus_gLogEnabled() {
   return getPref("getBoolPref", PREF_APP_UPDATE_LOG, false);
 });
 XPCOMUtils.defineLazyGetter(this, "gUpdateBundle", function aus_gUpdateBundle() {
   return Services.strings.createBundle(URI_UPDATES_PROPERTIES);
 });
 // shared code for suppressing bad cert dialogs
 XPCOMUtils.defineLazyGetter(this, "gCertUtils", function aus_gCertUtils() {
   let temp = { };
   Cu.import("resource://gre/modules/CertUtils.jsm", temp);
   return temp;
 });
 XPCOMUtils.defineLazyGetter(this, "gABI", function aus_gABI() {
   let abi = null;
   try {
     abi = Services.appinfo.XPCOMABI;
   }
   catch (e) {
     LOG("gABI - XPCOM ABI unknown: updates are not possible.");
   }
 #ifdef XP_MACOSX
   // Mac universal build should report a different ABI than either macppc
   // or mactel.
   let macutils = Cc["@mozilla.org/xpcom/mac-utils;1"].
                  getService(Ci.nsIMacUtils);
   if (macutils.isUniversalBinary)
     abi += "-u-" + macutils.architecturesInBinary;
 #ifdef MOZ_SHARK
   // Disambiguate optimised and shark nightlies
   abi += "-shark"
 #endif
 #endif
   return abi;
 });
 #ifdef MOZ_WIDGET_GONK
 XPCOMUtils.defineLazyGetter(this, "gProductModel", function aus_gProductModel() {
   Cu.import("resource://gre/modules/systemlibs.js");
   return libcutils.property_get("ro.product.model");
 });
 #endif
 XPCOMUtils.defineLazyGetter(this, "gOSVersion", function aus_gOSVersion() {
   let osVersion;
   let sysInfo = Cc["@mozilla.org/system-info;1"].
                 getService(Ci.nsIPropertyBag2);
   try {
     osVersion = sysInfo.getProperty("name") + " " + sysInfo.getProperty("version");
   }
   catch (e) {
     LOG("gOSVersion - OS Version unknown: updates are not possible.");
   }
   if (osVersion) {
 #ifdef BUILD_CTYPES
 #ifdef XP_WIN
     const BYTE = ctypes.uint8_t;
     const WORD = ctypes.uint16_t;
     const DWORD = ctypes.uint32_t;
     const WCHAR = ctypes.jschar;
     const BOOL = ctypes.int;
     // This structure is described at:
     // http://msdn.microsoft.com/en-us/library/ms724833%28v=vs.85%29.aspx
     const SZCSDVERSIONLENGTH = 128;
     const OSVERSIONINFOEXW = new ctypes.StructType('OSVERSIONINFOEXW',
         [
         {dwOSVersionInfoSize: DWORD},
         {dwMajorVersion: DWORD},
         {dwMinorVersion: DWORD},
         {dwBuildNumber: DWORD},
         {dwPlatformId: DWORD},
         {szCSDVersion: ctypes.ArrayType(WCHAR, SZCSDVERSIONLENGTH)},
         {wServicePackMajor: WORD},
         {wServicePackMinor: WORD},
         {wSuiteMask: WORD},
         {wProductType: BYTE},
         {wReserved: BYTE}
         ]);
     // This structure is described at:
     // http://msdn.microsoft.com/en-us/library/ms724958%28v=vs.85%29.aspx
     const SYSTEM_INFO = new ctypes.StructType('SYSTEM_INFO',
         [
         {wProcessorArchitecture: WORD},
         {wReserved: WORD},
         {dwPageSize: DWORD},
         {lpMinimumApplicationAddress: ctypes.voidptr_t},
         {lpMaximumApplicationAddress: ctypes.voidptr_t},
         {dwActiveProcessorMask: DWORD.ptr},
         {dwNumberOfProcessors: DWORD},
         {dwProcessorType: DWORD},
         {dwAllocationGranularity: DWORD},
         {wProcessorLevel: WORD},
         {wProcessorRevision: WORD}
         ]);
     let kernel32 = false;
     try {
       kernel32 = ctypes.open("Kernel32");
     } catch (e) {
       LOG("gOSVersion - Unable to open kernel32! " + e);
       osVersion += ".unknown (unknown)";
     }
     if(kernel32) {
       try {
         // Get Service pack info
         try {
           let GetVersionEx = kernel32.declare("GetVersionExW",
                                               ctypes.default_abi,
                                               BOOL,
                                               OSVERSIONINFOEXW.ptr);
           let winVer = OSVERSIONINFOEXW();
           winVer.dwOSVersionInfoSize = OSVERSIONINFOEXW.size;
           if(0 !== GetVersionEx(winVer.address())) {
             osVersion += "." + winVer.wServicePackMajor
                       +  "." + winVer.wServicePackMinor;
           } else {
             LOG("gOSVersion - Unknown failure in GetVersionEX (returned 0)");
             osVersion += ".unknown";
           }
         } catch (e) {
           LOG("gOSVersion - error getting service pack information. Exception: " + e);
           osVersion += ".unknown";
         }
         // Get processor architecture
         let arch = "unknown";
         try {
           let GetNativeSystemInfo = kernel32.declare("GetNativeSystemInfo",
                                                      ctypes.default_abi,
                                                      ctypes.void_t,
                                                      SYSTEM_INFO.ptr);
           let sysInfo = SYSTEM_INFO();
           // Default to unknown
           sysInfo.wProcessorArchitecture = 0xffff;
           GetNativeSystemInfo(sysInfo.address());
           switch(sysInfo.wProcessorArchitecture) {
             case 9:
               arch = "x64";
               break;
             case 6:
               arch = "IA64";
               break;
             case 0:
               arch = "x86";
               break;
           }
         } catch (e) {
           LOG("gOSVersion - error getting processor architecture.  Exception: " + e);
         } finally {
           osVersion += " (" + arch + ")";
         }
       } finally {
         kernel32.close();
       }
     }
 #endif
 #endif
     try {
       osVersion += " (" + sysInfo.getProperty("secondaryLibrary") + ")";
     }
     catch (e) {
       // Not all platforms have a secondary widget library, so an error is nothing to worry about.
     }
     osVersion = encodeURIComponent(osVersion);
   }
   return osVersion;
 });
 /**
  * Tests to make sure that we can write to a given directory.
  *
  * @param updateTestFile a test file in the directory that needs to be tested.
  * @param createDirectory whether a test directory should be created.
  * @throws if we don't have right access to the directory.
  */
 function testWriteAccess(updateTestFile, createDirectory) {
   const NORMAL_FILE_TYPE = Ci.nsILocalFile.NORMAL_FILE_TYPE;
   const DIRECTORY_TYPE = Ci.nsILocalFile.DIRECTORY_TYPE;
   if (updateTestFile.exists())
     updateTestFile.remove(false);
   updateTestFile.create(createDirectory ? DIRECTORY_TYPE : NORMAL_FILE_TYPE,
                         createDirectory ? FileUtils.PERMS_DIRECTORY : FileUtils.PERMS_FILE);
   updateTestFile.remove(false);
 }
 #ifdef XP_WIN
 /**
  * Closes a Win32 handle
  *
  * @param handle The handle to close
  */
 function closeHandle(handle) {
   var lib = ctypes.open("kernel32.dll");
   var CloseHandle = lib.declare("CloseHandle",
                                 ctypes.winapi_abi,
                                 ctypes.int32_t, /* success */
                                 ctypes.void_t.ptr); /* handle */
   CloseHandle(handle);
   lib.close();
 }
 /**
  * Creates a mutex.
  *
  * @param  aName
  *         The name for the mutex.
  * @param  aAllowExisting
  *         If false the function will close the handle and return null.
  * @return The Win32 handle to the mutex.
  */
 function createMutex(aName, aAllowExisting) {
   if (aAllowExisting === undefined) {
     aAllowExisting = true;
   }
   const INITIAL_OWN = 1;
   const ERROR_ALREADY_EXISTS = 0xB7;
   var lib = ctypes.open("kernel32.dll");
   var CreateMutexW = lib.declare("CreateMutexW",
                                  ctypes.winapi_abi,
                                  ctypes.void_t.ptr, /* return handle */
                                  ctypes.void_t.ptr, /* security attributes */
                                  ctypes.int32_t, /* initial owner */
                                  ctypes.jschar.ptr); /* name */
   var handle = CreateMutexW(null, INITIAL_OWN, aName);
   var alreadyExists = ctypes.winLastError == ERROR_ALREADY_EXISTS;
   if (handle && !handle.isNull() && !aAllowExisting && alreadyExists) {
     closeHandle(handle);
     handle = null;
   }
   lib.close();
   if (handle && handle.isNull())
     handle = null;
   return handle;
 }
 /**
  * Determines a unique mutex name for the installation
  *
  * @param aGlobal true if the function should return a global mutex. A global
  *                mutex is valid across different sessions
  * @return Global mutex path
  */
 function getPerInstallationMutexName(aGlobal) {
   if (aGlobal === undefined) {
     aGobal = true;
   }
   let hasher = Cc["@mozilla.org/security/hash;1"].
                createInstance(Ci.nsICryptoHash);
   hasher.init(hasher.SHA1);
   var exeFile = Services.dirsvc.get(KEY_EXECUTABLE, Ci.nsILocalFile);
   let converter = Cc["@mozilla.org/intl/scriptableunicodeconverter"].
                   createInstance(Ci.nsIScriptableUnicodeConverter);
   converter.charset = "UTF-8";
   var data = converter.convertToByteArray(exeFile.path.toLowerCase());
   hasher.update(data, data.length);
   return (aGlobal ? "Global\\" : "") + "MozillaUpdateMutex-" + hasher.finish(true);
 }
 #endif // XP_WIN
 /**
  * Whether or not the current instance has the update mutex. The update mutex
  * gives protection against 2 applications from the same installation updating:
  * 1) Running multiple profiles from the same installation path
  * 2) Running a Metro and Desktop application at the same time from the same
  *    path
  * 3) 2 applications running in 2 different user sessions from the same path
  *
  * @return true if this instance holds the update mutex
  */
 function hasUpdateMutex() {
 #ifdef XP_WIN
   if (!gUpdateMutexHandle) {
     gUpdateMutexHandle = createMutex(getPerInstallationMutexName(true), false);
   }
   return !!gUpdateMutexHandle;
 #else
   return true;
 #endif // XP_WIN
 }
 XPCOMUtils.defineLazyGetter(this, "gCanApplyUpdates", function aus_gCanApplyUpdates() {
   function submitHasPermissionsTelemetryPing(val) {
     try {
       let h = Services.telemetry.getHistogramById("UPDATER_HAS_PERMISSIONS");
       h.add(+val);
     } catch(e) {
       // Don't allow any exception to be propagated.
       Components.utils.reportError(e);
     }
   }
   let useService = false;
   if (shouldUseService() && isServiceInstalled()) {
     // No need to perform directory write checks, the maintenance service will
     // be able to write to all directories.
     LOG("gCanApplyUpdates - bypass the write checks because we'll use the service");
     useService = true;
   }
   if (!useService) {
     try {
       var updateTestFile = getUpdateFile([FILE_PERMS_TEST]);
       LOG("gCanApplyUpdates - testing write access " + updateTestFile.path);
       testWriteAccess(updateTestFile, false);
 #ifdef XP_WIN
       var sysInfo = Cc["@mozilla.org/system-info;1"].
                     getService(Ci.nsIPropertyBag2);
       // Example windowsVersion:  Windows XP == 5.1
       var windowsVersion = sysInfo.getProperty("version");
       LOG("gCanApplyUpdates - windowsVersion = " + windowsVersion);
     /**
   #    For Vista, updates can be performed to a location requiring admin
   #    privileges by requesting elevation via the UAC prompt when launching
   #    updater.exe if the appDir is under the Program Files directory
   #    (e.g. C:\Program Files\) and UAC is turned on and  we can elevate
   #    (e.g. user has a split token).
   #
   #    Note: this does note attempt to handle the case where UAC is turned on
   #    and the installation directory is in a restricted location that
   #    requires admin privileges to update other than Program Files.
      */
       var userCanElevate = false;
       if (parseFloat(windowsVersion) >= 6) {
         try {
           var fileLocator = Cc["@mozilla.org/file/directory_service;1"].
                             getService(Ci.nsIProperties);
           // KEY_UPDROOT will fail and throw an exception if
           // appDir is not under the Program Files, so we rely on that
           var dir = fileLocator.get(KEY_UPDROOT, Ci.nsIFile);
           // appDir is under Program Files, so check if the user can elevate
           userCanElevate = Services.appinfo.QueryInterface(Ci.nsIWinAppHelper).
                            userCanElevate;
           LOG("gCanApplyUpdates - on Vista, userCanElevate: " + userCanElevate);
         }
         catch (ex) {
           // When the installation directory is not under Program Files,
           // fall through to checking if write access to the
           // installation directory is available.
           LOG("gCanApplyUpdates - on Vista, appDir is not under Program Files");
         }
       }
       /**
 #      On Windows, we no longer store the update under the app dir.
 #
 #      If we are on Windows (including Vista, if we can't elevate) we need to
 #      to check that we can create and remove files from the actual app
 #      directory (like C:\Program Files\Mozilla Firefox).  If we can't
 #      (because this user is not an adminstrator, for example) canUpdate()
 #      should return false.
 #
 #      For Vista, we perform this check to enable updating the  application
 #      when the user has write access to the installation directory under the
 #      following scenarios:
 #      1) the installation directory is not under Program Files
 #         (e.g. C:\Program Files)
 #      2) UAC is turned off
 #      3) UAC is turned on and the user is not an admin
 #         (e.g. the user does not have a split token)
 #      4) UAC is turned on and the user is already elevated, so they can't be
 #         elevated again
        */
       if (!userCanElevate) {
         // if we're unable to create the test file this will throw an exception.
         var appDirTestFile = getAppBaseDir();
         appDirTestFile.append(FILE_PERMS_TEST);
         LOG("gCanApplyUpdates - testing write access " + appDirTestFile.path);
         if (appDirTestFile.exists())
           appDirTestFile.remove(false)
         appDirTestFile.create(Ci.nsILocalFile.NORMAL_FILE_TYPE, FileUtils.PERMS_FILE);
         appDirTestFile.remove(false);
       }
 #endif //XP_WIN
     }
     catch (e) {
        LOG("gCanApplyUpdates - unable to apply updates. Exception: " + e);
       // No write privileges to install directory
       submitHasPermissionsTelemetryPing(false);
       return false;
     }
   } // if (!useService)
   LOG("gCanApplyUpdates - able to apply updates");
   submitHasPermissionsTelemetryPing(true);
   return true;
 });
 /**
  * Whether or not the application can stage an update.
  *
  * @return true if updates can be staged.
  */
 function getCanStageUpdates() {
   // If background updates are disabled, then just bail out!
   if (!getPref("getBoolPref", PREF_APP_UPDATE_STAGING_ENABLED, false)) {
     LOG("getCanStageUpdates - staging updates is disabled by preference " +
         PREF_APP_UPDATE_STAGING_ENABLED);
     return false;
   }
 #ifdef CHECK_CAN_USE_SERVICE
   if (getPref("getBoolPref", PREF_APP_UPDATE_SERVICE_ENABLED, false)) {
     // No need to perform directory write checks, the maintenance service will
     // be able to write to all directories.
     LOG("getCanStageUpdates - able to stage updates because we'll use the service");
     return true;
   }
 #endif
   if (!hasUpdateMutex()) {
     LOG("getCanStageUpdates - unable to apply updates because another " +
         "instance of the application is already handling updates for this " +
         "installation.");
     return false;
   }
   /**
    * Whether or not the application can stage an update for the current session.
    * These checks are only performed once per session due to using a lazy getter.
    *
    * @return true if updates can be staged for this session.
    */
   XPCOMUtils.defineLazyGetter(this, "canStageUpdatesSession", function canStageUpdatesSession() {
     try {
       var updateTestFile = getInstallDirRoot();
       updateTestFile.append(FILE_PERMS_TEST);
       LOG("canStageUpdatesSession - testing write access " +
           updateTestFile.path);
       testWriteAccess(updateTestFile, true);
 #ifndef XP_MACOSX
       // On all platforms except Mac, we need to test the parent directory as
       // well, as we need to be able to move files in that directory during the
       // replacing step.
       updateTestFile = getInstallDirRoot().parent;
       updateTestFile.append(FILE_PERMS_TEST);
       LOG("canStageUpdatesSession - testing write access " +
           updateTestFile.path);
       updateTestFile.createUnique(Ci.nsILocalFile.DIRECTORY_TYPE,
                                   FileUtils.PERMS_DIRECTORY);
       updateTestFile.remove(false);
 #endif
     }
     catch (e) {
        LOG("canStageUpdatesSession - unable to stage updates. Exception: " +
            e);
       // No write privileges
       return false;
     }
     LOG("canStageUpdatesSession - able to stage updates");
     return true;
   });
   return canStageUpdatesSession;
 }
 XPCOMUtils.defineLazyGetter(this, "gMetroUpdatesEnabled", function aus_gMetroUpdatesEnabled() {
 #ifdef XP_WIN
 #ifdef MOZ_METRO
   if (Services.metro && Services.metro.immersive) {
     let metroUpdate = getPref("getBoolPref", PREF_APP_UPDATE_METRO_ENABLED, true);
     if (!metroUpdate) {
       LOG("gMetroUpdatesEnabled - unable to automatically check for metro " +
           "updates, disabled by pref");
       return false;
     }
   }
 #endif
 #endif
   return true;
 });
 XPCOMUtils.defineLazyGetter(this, "gCanCheckForUpdates", function aus_gCanCheckForUpdates() {
   // If the administrator has disabled app update and locked the preference so
   // users can't check for updates. This preference check is ok in this lazy
   // getter since locked prefs don't change until the application is restarted.
   var enabled = getPref("getBoolPref", PREF_APP_UPDATE_ENABLED, true);
   if (!enabled && Services.prefs.prefIsLocked(PREF_APP_UPDATE_ENABLED)) {
     LOG("gCanCheckForUpdates - unable to automatically check for updates, " +
         "the preference is disabled and admistratively locked.");
     return false;
   }
   if (!gMetroUpdatesEnabled) {
     return false;
   }
   // If we don't know the binary platform we're updating, we can't update.
   if (!gABI) {
     LOG("gCanCheckForUpdates - unable to check for updates, unknown ABI");
     return false;
   }
   // If we don't know the OS version we're updating, we can't update.
   if (!gOSVersion) {
     LOG("gCanCheckForUpdates - unable to check for updates, unknown OS " +
         "version");
     return false;
   }
   LOG("gCanCheckForUpdates - able to check for updates");
   return true;
 });
 /**
  * Logs a string to the error console.
  * @param   string
  *          The string to write to the error console.
  */
 function LOG(string) {
   if (gLogEnabled) {
     dump("*** AUS:SVC " + string + "\n");
     Services.console.logStringMessage("AUS:SVC " + string);
   }
 }
 /**
 #  Gets a preference value, handling the case where there is no default.
 #  @param   func
 #           The name of the preference function to call, on nsIPrefBranch
 #  @param   preference
 #           The name of the preference
 #  @param   defaultValue
 #           The default value to return in the event the preference has
 #           no setting
 #  @return  The value of the preference, or undefined if there was no
 #           user or default value.
  */
 function getPref(func, preference, defaultValue) {
   try {
     return Services.prefs[func](preference);
   }
   catch (e) {
   }
   return defaultValue;
 }
 /**
  * Convert a string containing binary values to hex.
  */
 function binaryToHex(input) {
   var result = "";
   for (var i = 0; i < input.length; ++i) {
     var hex = input.charCodeAt(i).toString(16);
     if (hex.length == 1)
       hex = "0" + hex;
     result += hex;
   }
   return result;
 }
 /**
 #  Gets the specified directory at the specified hierarchy under the
 #  update root directory and creates it if it doesn't exist.
 #  @param   pathArray
 #           An array of path components to locate beneath the directory
 #           specified by |key|
 #  @return  nsIFile object for the location specified.
  */
 function getUpdateDirCreate(pathArray) {
   return FileUtils.getDir(KEY_UPDROOT, pathArray, true);
 }
 /**
 #  Gets the specified directory at the specified hierarchy under the
 #  update root directory and without creating it if it doesn't exist.
 #  @param   pathArray
 #           An array of path components to locate beneath the directory
 #           specified by |key|
 #  @return  nsIFile object for the location specified.
  */
 function getUpdateDirNoCreate(pathArray) {
   return FileUtils.getDir(KEY_UPDROOT, pathArray, false);
 }
 /**
  * Gets the application base directory.
  *
  * @return  nsIFile object for the application base directory.
  */
 function getAppBaseDir() {
   return Services.dirsvc.get(KEY_EXECUTABLE, Ci.nsIFile).parent;
 }
 /**
  * Gets the root of the installation directory which is the application
  * bundle directory on Mac OS X and the location of the application binary
  * on all other platforms.
  *
  * @return nsIFile object for the directory
  */
 function getInstallDirRoot() {
   var dir = getAppBaseDir();
 #ifdef XP_MACOSX
   // On Mac, we store the Updated.app directory inside the bundle directory.
   dir = dir.parent.parent;
 #endif
   return dir;
 }
 /**
  * Gets the file at the specified hierarchy under the update root directory.
  * @param   pathArray
  *          An array of path components to locate beneath the directory
  *          specified by |key|. The last item in this array must be the
  *          leaf name of a file.
  * @return  nsIFile object for the file specified. The file is NOT created
  *          if it does not exist, however all required directories along
  *          the way are.
  */
 function getUpdateFile(pathArray) {
   var file = getUpdateDirCreate(pathArray.slice(0, -1));
   file.append(pathArray[pathArray.length - 1]);
   return file;
 }
 /**
  * Returns human readable status text from the updates.properties bundle
  * based on an error code
  * @param   code
  *          The error code to look up human readable status text for
  * @param   defaultCode
  *          The default code to look up should human readable status text
  *          not exist for |code|
  * @return  A human readable status text string
  */
 function getStatusTextFromCode(code, defaultCode) {
   var reason;
   try {
     reason = gUpdateBundle.GetStringFromName("check_error-" + code);
     LOG("getStatusTextFromCode - transfer error: " + reason + ", code: " +
         code);
   }
   catch (e) {
     // Use the default reason
     reason = gUpdateBundle.GetStringFromName("check_error-" + defaultCode);
     LOG("getStatusTextFromCode - transfer error: " + reason +
         ", default code: " + defaultCode);
   }
   return reason;
 }
 /**
  * Get the Active Updates directory
  * @return The active updates directory, as a nsIFile object
  */
 function getUpdatesDir() {
   // Right now, we only support downloading one patch at a time, so we always
   // use the same target directory.
   return getUpdateDirCreate([DIR_UPDATES, "0"]);
 }
 /**
  * Get the Active Updates directory inside the directory where we apply the
  * background updates.
  * @return The active updates directory inside the updated directory, as a
  *         nsIFile object.
  */
 function getUpdatesDirInApplyToDir() {
   var dir = getAppBaseDir();
 #ifdef XP_MACOSX
   dir = dir.parent.parent; // the bundle directory
 #endif
   dir.append(UPDATED_DIR);
 #ifdef XP_MACOSX
   dir.append("Contents");
   dir.append("MacOS");
 #endif
   dir.append(DIR_UPDATES);
   if (!dir.exists()) {
     dir.create(Ci.nsILocalFile.DIRECTORY_TYPE, FileUtils.PERMS_DIRECTORY);
   }
   return dir;
 }
 /**
  * Reads the update state from the update.status file in the specified
  * directory.
  * @param   dir
  *          The dir to look for an update.status file in
  * @return  The status value of the update.
  */
 function readStatusFile(dir) {
   var statusFile = dir.clone();
   statusFile.append(FILE_UPDATE_STATUS);
   var status = readStringFromFile(statusFile) || STATE_NONE;
   LOG("readStatusFile - status: " + status + ", path: " + statusFile.path);
   return status;
 }
 /**
  * Writes the current update operation/state to a file in the patch
  * directory, indicating to the patching system that operations need
  * to be performed.
  * @param   dir
  *          The patch directory where the update.status file should be
  *          written.
  * @param   state
  *          The state value to write.
  */
 function writeStatusFile(dir, state) {
   var statusFile = dir.clone();
   statusFile.append(FILE_UPDATE_STATUS);
   writeStringToFile(statusFile, state);
 }
 #ifdef MOZ_WIDGET_GONK
 /**
  * Reads the link file specified in the update.link file in the
  * specified directory and returns the nsIFile for the
  * corresponding file.
  * @param   dir
  *          The dir to look for an update.link file in
  * @return  A nsIFile for the file path specified in the
  *          update.link file or null if the update.link file
  *          doesn't exist.
  */
 function getFileFromUpdateLink(dir) {
   var linkFile = dir.clone();
   linkFile.append(FILE_UPDATE_LINK);
   var link = readStringFromFile(linkFile);
   LOG("getFileFromUpdateLink linkFile.path: " + linkFile.path + ", link: " + link);
   if (!link) {
     return null;
   }
   let file = Cc["@mozilla.org/file/local;1"].createInstance(Ci.nsIFile);
   file.initWithPath(link);
   return file;
 }
 /**
  * Creates a link file, which allows the actual patch to live in
  * a directory different from the update directory.
  * @param   dir
  *          The patch directory where the update.link file
  *          should be written.
  * @param   patchFile
  *          The fully qualified filename of the patchfile.
  */
 function writeLinkFile(dir, patchFile) {
   var linkFile = dir.clone();
   linkFile.append(FILE_UPDATE_LINK);
   writeStringToFile(linkFile, patchFile.path);
   if (patchFile.path.indexOf(gExtStorage) == 0) {
     // The patchfile is being stored on external storage. Try to lock it
     // so that it doesn't get shared with the PC while we're downloading
     // to it.
     acquireSDCardMountLock();
   }
 }
 /**
  * Acquires a VolumeMountLock for the sdcard volume.
  *
  * This prevents the SDCard from being shared with the PC while
  * we're downloading the update.
  */
 function acquireSDCardMountLock() {
   let volsvc = Cc["@mozilla.org/telephony/volume-service;1"].
                     getService(Ci.nsIVolumeService);
   if (volsvc) {
     gSDCardMountLock = volsvc.createMountLock("sdcard");
   }
 }
 /**
  * Determines if the state corresponds to an interrupted update.
  * This could either be because the download was interrupted, or
  * because staging the update was interrupted.
  *
  * @return true if the state corresponds to an interrupted
  *         update.
  */
 function isInterruptedUpdate(status) {
   return (status == STATE_DOWNLOADING) ||
          (status == STATE_PENDING) ||
          (status == STATE_APPLYING);
 }
 #endif // MOZ_WIDGET_GONK
 /**
  * Releases any SDCard mount lock that we might have.
  *
  * This once again allows the SDCard to be shared with the PC.
  *
  * This function was placed outside the #ifdef so that we didn't
  * need to put #ifdefs around the callers.
  */
 function releaseSDCardMountLock() {
 #ifdef MOZ_WIDGET_GONK
   if (gSDCardMountLock) {
     gSDCardMountLock.unlock();
     gSDCardMountLock = null;
   }
 #endif
 }
 /**
  * Determines if the service should be used to attempt an update
  * or not.  For now this is only when PREF_APP_UPDATE_SERVICE_ENABLED
  * is true and we have Firefox.
  *
  * @return  true if the service should be used for updates.
  */
 function shouldUseService() {
 #ifdef MOZ_MAINTENANCE_SERVICE
   return getPref("getBoolPref",
                  PREF_APP_UPDATE_SERVICE_ENABLED, false);
 #else
   return false;
 #endif
 }
 /**
  * Determines if the service is is installed and enabled or not.
  *
  * @return  true if the service should be used for updates,
  *          is installed and enabled.
  */
 function isServiceInstalled() {
 #ifdef XP_WIN
   let installed = 0;
   try {
     let wrk = Cc["@mozilla.org/windows-registry-key;1"].
               createInstance(Ci.nsIWindowsRegKey);
     wrk.open(wrk.ROOT_KEY_LOCAL_MACHINE,
              "SOFTWARE\\Mozilla\\MaintenanceService",
              wrk.ACCESS_READ | wrk.WOW64_64);
     installed = wrk.readIntValue("Installed");
     wrk.close();
   } catch(e) {
   }
   installed = installed == 1;  // convert to bool
   LOG("isServiceInstalled = " + installed);
   return installed;
 #else
   return false;
 #endif
 }
 /**
 #  Writes the update's application version to a file in the patch directory. If
 #  the update doesn't provide application version information via the
 #  appVersion attribute the string "null" will be written to the file.
 #  This value is compared during startup (in nsUpdateDriver.cpp) to determine if
 #  the update should be applied. Note that this won't provide protection from
 #  downgrade of the application for the nightly user case where the application
 #  version doesn't change.
 #  @param   dir
 #           The patch directory where the update.version file should be
 #           written.
 #  @param   version
 #           The version value to write. Will be the string "null" when the
 #           update doesn't provide the appVersion attribute in the update xml.
  */
 function writeVersionFile(dir, version) {
   var versionFile = dir.clone();
   versionFile.append(FILE_UPDATE_VERSION);
   writeStringToFile(versionFile, version);
 }
 /**
  * Removes the MozUpdater folders that bgupdates/staged updates creates.
  */
 function cleanUpMozUpdaterDirs() {
   try {
     var tmpDir = Cc["@mozilla.org/file/directory_service;1"].
                  getService(Ci.nsIProperties).
                  get("TmpD", Ci.nsIFile);
     // We used to store MozUpdater-i folders directly inside the temp directory.
     // We need to cleanup these directories if we detect that they still exist.
     // To check if they still exist, we simply check for MozUpdater-1.
     var mozUpdaterDir1 = tmpDir.clone();
     mozUpdaterDir1.append("MozUpdater-1");
     // Only try to delete the left over folders in "$Temp/MozUpdater-i/*" if
     // MozUpdater-1 exists.
     if (mozUpdaterDir1.exists()) {
       LOG("cleanUpMozUpdaterDirs - Cleaning top level MozUpdater-i folders");
       let i = 0;
       let dirEntries = tmpDir.directoryEntries;
       while (dirEntries.hasMoreElements() && i < 10) {
         let file = dirEntries.getNext().QueryInterface(Ci.nsILocalFile);
         if (file.leafName.startsWith("MozUpdater-") && file.leafName != "MozUpdater-1") {
           file.remove(true);
           i++;
         }
       }
       // If you enumerate the whole temp directory and the count of deleted
       // items is less than 10, then delete MozUpdate-1.
       if (i < 10) {
         mozUpdaterDir1.remove(true);
       }
     }
     // If we reach here, we simply need to clean the MozUpdater folder.  In our
     // new way of storing these files, the unique subfolders are inside MozUpdater
     var mozUpdaterDir = tmpDir.clone();
     mozUpdaterDir.append("MozUpdater");
     if (mozUpdaterDir.exists()) {
       LOG("cleanUpMozUpdaterDirs - Cleaning MozUpdater folder");
       mozUpdaterDir.remove(true);
     }
   } catch (e) {
     LOG("cleanUpMozUpdaterDirs - Exception: " + e);
   }
 }
 /**
  * Removes the contents of the Updates Directory
  *
  * @param aBackgroundUpdate Whether the update has been performed in the
  *        background.  If this is true, we move the update log file to the
  *        updated directory, so that it survives replacing the directories
  *        later on.
  */
 function cleanUpUpdatesDir(aBackgroundUpdate) {
   // Bail out if we don't have appropriate permissions
   try {
     var updateDir = getUpdatesDir();
   } catch (e) {
     return;
   }
   // Preserve the last update log file for debugging purposes.
   let file = updateDir.clone();
   file.append(FILE_UPDATE_LOG);
   if (file.exists()) {
     let dir;
     if (aBackgroundUpdate && getUpdateDirNoCreate([]).equals(getAppBaseDir())) {
       dir = getUpdatesDirInApplyToDir();
     } else {
       dir = updateDir.parent;
     }
     let logFile = dir.clone();
     logFile.append(FILE_LAST_LOG);
     if (logFile.exists()) {
       try {
         logFile.moveTo(dir, FILE_BACKUP_LOG);
       } catch (e) {
         LOG("cleanUpUpdatesDir - failed to rename file " + logFile.path +
             " to " + FILE_BACKUP_LOG);
       }
     }
     try {
       file.moveTo(dir, FILE_LAST_LOG);
     } catch (e) {
       LOG("cleanUpUpdatesDir - failed to rename file " + file.path +
           " to " + FILE_LAST_LOG);
     }
   }
   if (!aBackgroundUpdate) {
     let e = updateDir.directoryEntries;
     while (e.hasMoreElements()) {
       let f = e.getNext().QueryInterface(Ci.nsIFile);
 #ifdef MOZ_WIDGET_GONK
       if (f.leafName == FILE_UPDATE_LINK) {
         let linkedFile = getFileFromUpdateLink(updateDir);
         if (linkedFile && linkedFile.exists()) {
           linkedFile.remove(false);
         }
       }
 #endif
       // Now, recursively remove this file.  The recursive removal is needed for
       // Mac OSX because this directory will contain a copy of updater.app,
       // which is itself a directory.
       try {
         f.remove(true);
       } catch (e) {
         LOG("cleanUpUpdatesDir - failed to remove file " + f.path);
       }
     }
   }
   releaseSDCardMountLock();
 }
 /**
  * Clean up updates list and the updates directory.
  */
 function cleanupActiveUpdate() {
   // Move the update from the Active Update list into the Past Updates list.
   var um = Cc["@mozilla.org/updates/update-manager;1"].
            getService(Ci.nsIUpdateManager);
   um.activeUpdate = null;
   um.saveUpdates();
   // Now trash the updates directory, since we're done with it
   cleanUpUpdatesDir();
 }
 /**
  * Gets the locale from the update.locale file for replacing %LOCALE% in the
  * update url. The update.locale file can be located in the application
  * directory or the GRE directory with preference given to it being located in
  * the application directory.
  */
 function getLocale() {
   if (gLocale)
     return gLocale;
   for (let res of ['app', 'gre']) {
     var channel = Services.io.newChannel("resource://" + res + "/" + FILE_UPDATE_LOCALE, null, null);
     try {
       var inputStream = channel.open();
       gLocale = readStringFromInputStream(inputStream);
     } catch(e) {}
     if (gLocale)
       break;
   }
   if (!gLocale)
     throw Components.Exception(FILE_UPDATE_LOCALE + " file doesn't exist in " +
                                "either the application or GRE directories",
                                Cr.NS_ERROR_FILE_NOT_FOUND);
   LOG("getLocale - getting locale from file: " + channel.originalURI.spec +
       ", locale: " + gLocale);
   return gLocale;
 }
 /* Get the distribution pref values, from defaults only */
 function getDistributionPrefValue(aPrefName) {
   var prefValue = "default";
   try {
     prefValue = Services.prefs.getDefaultBranch(null).getCharPref(aPrefName);
   } catch (e) {
     // use default when pref not found
   }
   return prefValue;
 }
 /**
  * An enumeration of items in a JS array.
  * @constructor
  */
 function ArrayEnumerator(aItems) {
   this._index = 0;
   if (aItems) {
     for (var i = 0; i < aItems.length; ++i) {
       if (!aItems[i])
         aItems.splice(i, 1);
     }
   }
   this._contents = aItems;
 }
 ArrayEnumerator.prototype = {
   _index: 0,
   _contents: [],
   hasMoreElements: function ArrayEnumerator_hasMoreElements() {
     return this._index < this._contents.length;
   },
   getNext: function ArrayEnumerator_getNext() {
     return this._contents[this._index++];
   }
 };
 /**
  * Writes a string of text to a file.  A newline will be appended to the data
  * written to the file.  This function only works with ASCII text.
  */
 function writeStringToFile(file, text) {
   var fos = FileUtils.openSafeFileOutputStream(file)
   text += "\n";
   fos.write(text, text.length);
   FileUtils.closeSafeFileOutputStream(fos);
 }
 function readStringFromInputStream(inputStream) {
   var sis = Cc["@mozilla.org/scriptableinputstream;1"].
             createInstance(Ci.nsIScriptableInputStream);
   sis.init(inputStream);
   var text = sis.read(sis.available());
   sis.close();
   if (text[text.length - 1] == "\n")
     text = text.slice(0, -1);
   return text;
 }
 /**
  * Reads a string of text from a file.  A trailing newline will be removed
  * before the result is returned.  This function only works with ASCII text.
  */
 function readStringFromFile(file) {
   if (!file.exists()) {
     LOG("readStringFromFile - file doesn't exist: " + file.path);
     return null;
   }
   var fis = Cc["@mozilla.org/network/file-input-stream;1"].
             createInstance(Ci.nsIFileInputStream);
   fis.init(file, FileUtils.MODE_RDONLY, FileUtils.PERMS_FILE, 0);
   return readStringFromInputStream(fis);
 }
 function handleUpdateFailure(update, errorCode) {
   update.errorCode = parseInt(errorCode);
   if (update.errorCode == FOTA_GENERAL_ERROR ||
       update.errorCode == FOTA_FILE_OPERATION_ERROR ||
       update.errorCode == FOTA_RECOVERY_ERROR ||
       update.errorCode == FOTA_UNKNOWN_ERROR) {
     // In the case of FOTA update errors, don't reset the state to pending. This
     // causes the FOTA update path to try again, which is not necessarily what
     // we want.
     update.statusText = gUpdateBundle.GetStringFromName("statusFailed");
     Cc["@mozilla.org/updates/update-prompt;1"].
       createInstance(Ci.nsIUpdatePrompt).
       showUpdateError(update);
     writeStatusFile(getUpdatesDir(), STATE_FAILED + ": " + errorCode);
     cleanupActiveUpdate();
     return true;
   }
   if (update.errorCode == WRITE_ERROR ||
       update.errorCode == WRITE_ERROR_ACCESS_DENIED ||
       update.errorCode == WRITE_ERROR_SHARING_VIOLATION_SIGNALED ||
       update.errorCode == WRITE_ERROR_SHARING_VIOLATION_NOPROCESSFORPID ||
       update.errorCode == WRITE_ERROR_SHARING_VIOLATION_NOPID ||
       update.errorCode == WRITE_ERROR_CALLBACK_APP ||
       update.errorCode == FILESYSTEM_MOUNT_READWRITE_ERROR) {
     Cc["@mozilla.org/updates/update-prompt;1"].
       createInstance(Ci.nsIUpdatePrompt).
       showUpdateError(update);
     writeStatusFile(getUpdatesDir(), update.state = STATE_PENDING);
     return true;
   }
   if (update.errorCode == ELEVATION_CANCELED) {
     writeStatusFile(getUpdatesDir(), update.state = STATE_PENDING);
     return true;
   }
   if (update.errorCode == SERVICE_UPDATER_COULD_NOT_BE_STARTED ||
       update.errorCode == SERVICE_NOT_ENOUGH_COMMAND_LINE_ARGS ||
       update.errorCode == SERVICE_UPDATER_SIGN_ERROR ||
       update.errorCode == SERVICE_UPDATER_COMPARE_ERROR ||
       update.errorCode == SERVICE_UPDATER_IDENTITY_ERROR ||
       update.errorCode == SERVICE_STILL_APPLYING_ON_SUCCESS ||
       update.errorCode == SERVICE_STILL_APPLYING_ON_FAILURE ||
       update.errorCode == SERVICE_UPDATER_NOT_FIXED_DRIVE ||
       update.errorCode == SERVICE_COULD_NOT_LOCK_UPDATER ||
       update.errorCode == SERVICE_COULD_NOT_COPY_UPDATER ||
       update.errorCode == SERVICE_INSTALLDIR_ERROR) {
     var failCount = getPref("getIntPref",
                             PREF_APP_UPDATE_SERVICE_ERRORS, 0);
     var maxFail = getPref("getIntPref",
                           PREF_APP_UPDATE_SERVICE_MAX_ERRORS,
                           DEFAULT_SERVICE_MAX_ERRORS);
     // As a safety, when the service reaches maximum failures, it will
     // disable itself and fallback to using the normal update mechanism
     // without the service.
     if (failCount >= maxFail) {
       Services.prefs.setBoolPref(PREF_APP_UPDATE_SERVICE_ENABLED, false);
       Services.prefs.clearUserPref(PREF_APP_UPDATE_SERVICE_ERRORS);
     } else {
       failCount++;
       Services.prefs.setIntPref(PREF_APP_UPDATE_SERVICE_ERRORS,
                                 failCount);
     }
     writeStatusFile(getUpdatesDir(), update.state = STATE_PENDING);
     try {
       Services.telemetry.getHistogramById("UPDATER_SERVICE_ERROR_CODE").
         add(update.errorCode);
     }
     catch (e) {
       Cu.reportError(e);
     }
     return true;
   }
   try {
     Services.telemetry.getHistogramById("UPDATER_SERVICE_ERROR_CODE").add(0);
   }
   catch (e) {
     Cu.reportError(e);
   }
   return false;
 }
 /**
  * Fall back to downloading a complete update in case an update has failed.
  *
  * @param update the update object that has failed to apply.
  * @param postStaging true if we have just attempted to stage an update.
  */
 function handleFallbackToCompleteUpdate(update, postStaging) {
   cleanupActiveUpdate();
   update.statusText = gUpdateBundle.GetStringFromName("patchApplyFailure");
   var oldType = update.selectedPatch ? update.selectedPatch.type
                                      : "complete";
   if (update.selectedPatch && oldType == "partial" && update.patchCount == 2) {
     // Partial patch application failed, try downloading the complete
     // update in the background instead.
     LOG("handleFallbackToCompleteUpdate - install of partial patch " +
         "failed, downloading complete patch");
     var status = Cc["@mozilla.org/updates/update-service;1"].
                  getService(Ci.nsIApplicationUpdateService).
                  downloadUpdate(update, !postStaging);
     if (status == STATE_NONE)
       cleanupActiveUpdate();
   }
   else {
     LOG("handleFallbackToCompleteUpdate - install of complete or " +
         "only one patch offered failed.");
   }
   update.QueryInterface(Ci.nsIWritablePropertyBag);
   update.setProperty("patchingFailed", oldType);
 }
 /**
  * Update Patch
  * @param   patch
  *          A <patch> element to initialize this object with
  * @throws if patch has a size of 0
  * @constructor
  */
 function UpdatePatch(patch) {
   this._properties = {};
   for (var i = 0; i < patch.attributes.length; ++i) {
     var attr = patch.attributes.item(i);
     attr.QueryInterface(Ci.nsIDOMAttr);
     switch (attr.name) {
     case "selected":
       this.selected = attr.value == "true";
       break;
     case "size":
       if (0 == parseInt(attr.value)) {
         LOG("UpdatePatch:init - 0-sized patch!");
         throw Cr.NS_ERROR_ILLEGAL_VALUE;
       }
       // fall through
     default:
       this[attr.name] = attr.value;
       break;
     };
   }
 }
 UpdatePatch.prototype = {
   /**
    * See nsIUpdateService.idl
    */
   serialize: function UpdatePatch_serialize(updates) {
     var patch = updates.createElementNS(URI_UPDATE_NS, "patch");
     patch.setAttribute("type", this.type);
     patch.setAttribute("URL", this.URL);
     // finalURL is not available until after the download has started
     if (this.finalURL)
       patch.setAttribute("finalURL", this.finalURL);
     patch.setAttribute("hashFunction", this.hashFunction);
     patch.setAttribute("hashValue", this.hashValue);
     patch.setAttribute("size", this.size);
     patch.setAttribute("selected", this.selected);
     patch.setAttribute("state", this.state);
     for (var p in this._properties) {
       if (this._properties[p].present)
         patch.setAttribute(p, this._properties[p].data);
     }
     return patch;
   },
   /**
    * A hash of custom properties
    */
   _properties: null,
   /**
    * See nsIWritablePropertyBag.idl
    */
   setProperty: function UpdatePatch_setProperty(name, value) {
     this._properties[name] = { data: value, present: true };
   },
   /**
    * See nsIWritablePropertyBag.idl
    */
   deleteProperty: function UpdatePatch_deleteProperty(name) {
     if (name in this._properties)
       this._properties[name].present = false;
     else
       throw Cr.NS_ERROR_FAILURE;
   },
   /**
    * See nsIPropertyBag.idl
    */
   get enumerator() {
     var properties = [];
     for (var p in this._properties)
       properties.push(this._properties[p].data);
     return new ArrayEnumerator(properties);
   },
   /**
    * See nsIPropertyBag.idl
    */
   getProperty: function UpdatePatch_getProperty(name) {
     if (name in this._properties &&
         this._properties[name].present)
       return this._properties[name].data;
     throw Cr.NS_ERROR_FAILURE;
   },
   /**
    * Returns whether or not the update.status file for this patch exists at the
    * appropriate location.
    */
   get statusFileExists() {
     var statusFile = getUpdatesDir();
     statusFile.append(FILE_UPDATE_STATUS);
     return statusFile.exists();
   },
   /**
    * See nsIUpdateService.idl
    */
   get state() {
     if (this._properties.state)
       return this._properties.state;
     return STATE_NONE;
   },
   set state(val) {
     this._properties.state = val;
   },
   QueryInterface: XPCOMUtils.generateQI([Ci.nsIUpdatePatch,
                                          Ci.nsIPropertyBag,
                                          Ci.nsIWritablePropertyBag])
 };
 /**
  * Update
  * Implements nsIUpdate
  * @param   update
  *          An <update> element to initialize this object with
  * @throws if the update contains no patches
  * @constructor
  */
 function Update(update) {
   this._properties = {};
   this._patches = [];
   this.isCompleteUpdate = false;
   this.isOSUpdate = false;
   this.showPrompt = false;
   this.showNeverForVersion = false;
   this.unsupported = false;
   this.channel = "default";
   this.promptWaitTime = getPref("getIntPref", PREF_APP_UPDATE_PROMPTWAITTIME, 43200);
   // Null <update>, assume this is a message container and do no
   // further initialization
   if (!update)
     return;
   const ELEMENT_NODE = Ci.nsIDOMNode.ELEMENT_NODE;
   for (var i = 0; i < update.childNodes.length; ++i) {
     var patchElement = update.childNodes.item(i);
     if (patchElement.nodeType != ELEMENT_NODE ||
         patchElement.localName != "patch")
       continue;
     patchElement.QueryInterface(Ci.nsIDOMElement);
     try {
       var patch = new UpdatePatch(patchElement);
     } catch (e) {
       continue;
     }
     this._patches.push(patch);
   }
   if (update.hasAttribute("unsupported"))
     this.unsupported = ("true" == update.getAttribute("unsupported"));
   else if (update.hasAttribute("minSupportedOSVersion")) {
     let minOSVersion = update.getAttribute("minSupportedOSVersion");
     try {
       let osVersion = Services.sysinfo.getProperty("version");
       this.unsupported = (Services.vc.compare(osVersion, minOSVersion) < 0);
     } catch (e) {}
   }
   if (this._patches.length == 0 && !this.unsupported)
     throw Cr.NS_ERROR_ILLEGAL_VALUE;
   // Fallback to the behavior prior to bug 530872 if the update does not have an
   // appVersion attribute.
   if (!update.hasAttribute("appVersion")) {
     if (update.getAttribute("type") == "major") {
       if (update.hasAttribute("detailsURL")) {
         this.billboardURL = update.getAttribute("detailsURL");
         this.showPrompt = true;
         this.showNeverForVersion = true;
       }
     }
   }
   for (var i = 0; i < update.attributes.length; ++i) {
     var attr = update.attributes.item(i);
     attr.QueryInterface(Ci.nsIDOMAttr);
     if (attr.value == "undefined")
       continue;
     else if (attr.name == "detailsURL")
       this._detailsURL = attr.value;
     else if (attr.name == "extensionVersion") {
       // Prevent extensionVersion from replacing appVersion if appVersion is
       // present in the update xml.
       if (!this.appVersion)
         this.appVersion = attr.value;
     }
     else if (attr.name == "installDate" && attr.value)
       this.installDate = parseInt(attr.value);
     else if (attr.name == "isCompleteUpdate")
       this.isCompleteUpdate = attr.value == "true";
     else if (attr.name == "isSecurityUpdate")
       this.isSecurityUpdate = attr.value == "true";
     else if (attr.name == "isOSUpdate")
       this.isOSUpdate = attr.value == "true";
     else if (attr.name == "showNeverForVersion")
       this.showNeverForVersion = attr.value == "true";
     else if (attr.name == "showPrompt")
       this.showPrompt = attr.value == "true";
     else if (attr.name == "promptWaitTime")
     {
       if(!isNaN(attr.value))
         this.promptWaitTime = parseInt(attr.value);
     }
     else if (attr.name == "version") {
       // Prevent version from replacing displayVersion if displayVersion is
       // present in the update xml.
       if (!this.displayVersion)
         this.displayVersion = attr.value;
     }
     else if (attr.name != "unsupported") {
       this[attr.name] = attr.value;
       switch (attr.name) {
       case "appVersion":
       case "billboardURL":
       case "buildID":
       case "channel":
       case "displayVersion":
       case "licenseURL":
       case "name":
       case "platformVersion":
       case "previousAppVersion":
       case "serviceURL":
       case "statusText":
       case "type":
         break;
       default:
         // Save custom attributes when serializing to the local xml file but
         // don't use this method for the expected attributes which are already
         // handled in serialize.
         this.setProperty(attr.name, attr.value);
         break;
       };
     }
   }
   // Set the initial value with the current time when it doesn't already have a
   // value or the value is already set to 0 (bug 316328).
   if (!this.installDate && this.installDate != 0)
     this.installDate = (new Date()).getTime();
   // The Update Name is either the string provided by the <update> element, or
   // the string: "<App Name> <Update App Version>"
   var name = "";
   if (update.hasAttribute("name"))
     name = update.getAttribute("name");
   else {
     var brandBundle = Services.strings.createBundle(URI_BRAND_PROPERTIES);
     var appName = brandBundle.GetStringFromName("brandShortName");
     name = gUpdateBundle.formatStringFromName("updateName",
                                               [appName, this.displayVersion], 2);
   }
   this.name = name;
 }
 Update.prototype = {
   /**
    * See nsIUpdateService.idl
    */
   get patchCount() {
     return this._patches.length;
   },
   /**
    * See nsIUpdateService.idl
    */
   getPatchAt: function Update_getPatchAt(index) {
     return this._patches[index];
   },
   /**
    * See nsIUpdateService.idl
    *
    * We use a copy of the state cached on this object in |_state| only when
    * there is no selected patch, i.e. in the case when we could not load
    * |.activeUpdate| from the update manager for some reason but still have
    * the update.status file to work with.
    */
   _state: "",
   set state(state) {
     if (this.selectedPatch)
       this.selectedPatch.state = state;
     this._state = state;
     return state;
   },
   get state() {
     if (this.selectedPatch)
       return this.selectedPatch.state;
     return this._state;
   },
   /**
    * See nsIUpdateService.idl
    */
   errorCode: 0,
   /**
    * See nsIUpdateService.idl
    */
   get selectedPatch() {
     for (var i = 0; i < this.patchCount; ++i) {
       if (this._patches[i].selected)
         return this._patches[i];
     }
     return null;
   },
   /**
    * See nsIUpdateService.idl
    */
   get detailsURL() {
     if (!this._detailsURL) {
       try {
         // Try using a default details URL supplied by the distribution
         // if the update XML does not supply one.
         return Services.urlFormatter.formatURLPref(PREF_APP_UPDATE_URL_DETAILS);
       }
       catch (e) {
       }
     }
     return this._detailsURL || "";
   },
   /**
    * See nsIUpdateService.idl
    */
   serialize: function Update_serialize(updates) {
     var update = updates.createElementNS(URI_UPDATE_NS, "update");
     update.setAttribute("appVersion", this.appVersion);
     update.setAttribute("buildID", this.buildID);
     update.setAttribute("channel", this.channel);
     update.setAttribute("displayVersion", this.displayVersion);
     // for backwards compatibility in case the user downgrades
     update.setAttribute("extensionVersion", this.appVersion);
     update.setAttribute("installDate", this.installDate);
     update.setAttribute("isCompleteUpdate", this.isCompleteUpdate);
     update.setAttribute("isOSUpdate", this.isOSUpdate);
     update.setAttribute("name", this.name);
     update.setAttribute("serviceURL", this.serviceURL);
     update.setAttribute("showNeverForVersion", this.showNeverForVersion);
     update.setAttribute("showPrompt", this.showPrompt);
     update.setAttribute("promptWaitTime", this.promptWaitTime);
     update.setAttribute("type", this.type);
     // for backwards compatibility in case the user downgrades
     update.setAttribute("version", this.displayVersion);
     // Optional attributes
     if (this.billboardURL)
       update.setAttribute("billboardURL", this.billboardURL);
     if (this.detailsURL)
       update.setAttribute("detailsURL", this.detailsURL);
     if (this.licenseURL)
       update.setAttribute("licenseURL", this.licenseURL);
     if (this.platformVersion)
       update.setAttribute("platformVersion", this.platformVersion);
     if (this.previousAppVersion)
       update.setAttribute("previousAppVersion", this.previousAppVersion);
     if (this.statusText)
       update.setAttribute("statusText", this.statusText);
     if (this.unsupported)
       update.setAttribute("unsupported", this.unsupported);
     updates.documentElement.appendChild(update);
     for (var p in this._properties) {
       if (this._properties[p].present)
         update.setAttribute(p, this._properties[p].data);
     }
     for (var i = 0; i < this.patchCount; ++i)
       update.appendChild(this.getPatchAt(i).serialize(updates));
     return update;
   },
   /**
    * A hash of custom properties
    */
   _properties: null,
   /**
    * See nsIWritablePropertyBag.idl
    */
   setProperty: function Update_setProperty(name, value) {
     this._properties[name] = { data: value, present: true };
   },
   /**
    * See nsIWritablePropertyBag.idl
    */
   deleteProperty: function Update_deleteProperty(name) {
     if (name in this._properties)
       this._properties[name].present = false;
     else
       throw Cr.NS_ERROR_FAILURE;
   },
   /**
    * See nsIPropertyBag.idl
    */
   get enumerator() {
     var properties = [];
     for (var p in this._properties)
       properties.push(this._properties[p].data);
     return new ArrayEnumerator(properties);
   },
   /**
    * See nsIPropertyBag.idl
    */
   getProperty: function Update_getProperty(name) {
     if (name in this._properties && this._properties[name].present)
       return this._properties[name].data;
     throw Cr.NS_ERROR_FAILURE;
   },
   QueryInterface: XPCOMUtils.generateQI([Ci.nsIUpdate,
                                          Ci.nsIPropertyBag,
                                          Ci.nsIWritablePropertyBag])
 };
 const UpdateServiceFactory = {
   _instance: null,
   createInstance: function (outer, iid) {
     if (outer != null)
       throw Cr.NS_ERROR_NO_AGGREGATION;
     return this._instance == null ? this._instance = new UpdateService() :
                                     this._instance;
   }
 };
 /**
  * UpdateService
  * A Service for managing the discovery and installation of software updates.
  * @constructor
  */
 function UpdateService() {
   LOG("Creating UpdateService");
   Services.obs.addObserver(this, "xpcom-shutdown", false);
   Services.prefs.addObserver(PREF_APP_UPDATE_LOG, this, false);
 #ifdef MOZ_WIDGET_GONK
   // PowerManagerService::SyncProfile (which is called for Reboot, PowerOff
   // and Restart) sends the profile-change-net-teardown event. We can then
   // pause the download in a similar manner to xpcom-shutdown.
   Services.obs.addObserver(this, "profile-change-net-teardown", false);
 #endif
 }
 UpdateService.prototype = {
   /**
    * The downloader we are using to download updates. There is only ever one of
    * these.
    */
   _downloader: null,
   /**
    * Incompatible add-on count.
    */
   _incompatAddonsCount: 0,
   /**
    * Whether or not the service registered the "online" observer.
    */
   _registeredOnlineObserver: false,
   /**
    * The current number of consecutive socket errors
    */
   _consecutiveSocketErrors: 0,
   /**
    * A timer used to retry socket errors
    */
   _retryTimer: null,
   /**
    * Whether or not a background update check was initiated by the
    * application update timer notification.
    */
   _isNotify: true,
   /**
    * Handle Observer Service notifications
    * @param   subject
    *          The subject of the notification
    * @param   topic
    *          The notification name
    * @param   data
    *          Additional data
    */
   observe: function AUS_observe(subject, topic, data) {
     switch (topic) {
     case "post-update-processing":
       // Clean up any extant updates
       this._postUpdateProcessing();
       break;
     case "network:offline-status-changed":
       this._offlineStatusChanged(data);
       break;
     case "nsPref:changed":
       if (data == PREF_APP_UPDATE_LOG) {
         gLogEnabled = getPref("getBoolPref", PREF_APP_UPDATE_LOG, false);
       }
       break;
 #ifdef MOZ_WIDGET_GONK
     case "profile-change-net-teardown": // fall thru
 #endif
     case "xpcom-shutdown":
       Services.obs.removeObserver(this, topic);
       Services.prefs.removeObserver(PREF_APP_UPDATE_LOG, this);
       if (this._retryTimer) {
         this._retryTimer.cancel();
       }
       this.pauseDownload();
       // Prevent leaking the downloader (bug 454964)
       this._downloader = null;
       break;
     }
   },
   /**
    * The following needs to happen during the post-update-processing
    * notification from nsUpdateServiceStub.js:
    * 1. post update processing
    * 2. resume of a download that was in progress during a previous session
    * 3. start of a complete update download after the failure to apply a partial
    *    update
    */
   /**
    * Perform post-processing on updates lingering in the updates directory
    * from a previous application session - either report install failures (and
    * optionally attempt to fetch a different version if appropriate) or
    * notify the user of install success.
    */
   _postUpdateProcessing: function AUS__postUpdateProcessing() {
     // canCheckForUpdates will return false when metro-only updates are disabled
     // from within metro.  In that case we still want _postUpdateProcessing to
     // run.  gMetroUpdatesEnabled returns true on non Windows 8 platforms.
     // We want _postUpdateProcessing to run so that it will update the history
     // XML. Without updating the history XML, the about flyout will continue to
     // have the "Restart to Apply Update" button (history xml indicates update
     // is applied).
     // TODO: I think this whole if-block should be removed since updates can
     // always be applied via the about dialog, we should be running post update
     // in those cases.
     if (!this.canCheckForUpdates && gMetroUpdatesEnabled) {
       LOG("UpdateService:_postUpdateProcessing - unable to check for " +
           "updates... returning early");
       return;
     }
     if (!this.canApplyUpdates) {
       LOG("UpdateService:_postUpdateProcessing - unable to apply " +
           "updates... returning early");
       // If the update is present in the update directly somehow,
       // it would prevent us from notifying the user of futher updates.
       cleanupActiveUpdate();
       return;
     }
     var status = readStatusFile(getUpdatesDir());
     // STATE_NONE status means that the update.status file is present but a
     // background download error occurred.
     if (status == STATE_NONE) {
       LOG("UpdateService:_postUpdateProcessing - no status, no update");
       cleanupActiveUpdate();
       return;
     }
     var um = Cc["@mozilla.org/updates/update-manager;1"].
              getService(Ci.nsIUpdateManager);
 #ifdef MOZ_WIDGET_GONK
     // This code is called very early in the boot process, before we've even
     // had a chance to setup the UI so we can give feedback to the user.
     //
     // Since the download may be occuring over a link which has associated
     // cost, we want to require user-consent before resuming the download.
     // Also, applying an already downloaded update now is undesireable,
     // since the phone will look dead while the update is being applied.
     // Applying the update can take several minutes. Instead we wait until
     // the UI is initialized so it is possible to give feedback to and get
     // consent to update from the user.
     if (isInterruptedUpdate(status)) {
       LOG("UpdateService:_postUpdateProcessing - interrupted update detected - wait for user consent");
       return;
     }
 #endif
     var update = um.activeUpdate;
     if (status == STATE_DOWNLOADING) {
       LOG("UpdateService:_postUpdateProcessing - patch found in downloading " +
           "state");
       if (update && update.state != STATE_SUCCEEDED) {
         // Resume download
         var status = this.downloadUpdate(update, true);
         if (status == STATE_NONE)
           cleanupActiveUpdate();
       }
       return;
     }
     if (status == STATE_APPLYING) {
       // This indicates that the background updater service is in either of the
       // following two states:
       // 1. It is in the process of applying an update in the background, and
       //    we just happen to be racing against that.
       // 2. It has failed to apply an update for some reason, and we hit this
       //    case because the updater process has set the update status to
       //    applying, but has never finished.
       // In order to differentiate between these two states, we look at the
       // state field of the update object.  If it's "pending", then we know
       // that this is the first time we're hitting this case, so we switch
       // that state to "applying" and we just wait and hope for the best.
       // If it's "applying", we know that we've already been here once, so
       // we really want to start from a clean state.
       if (update &&
           (update.state == STATE_PENDING || update.state == STATE_PENDING_SVC)) {
         LOG("UpdateService:_postUpdateProcessing - patch found in applying " +
             "state for the first time");
         update.state = STATE_APPLYING;
         um.saveUpdates();
       } else { // We get here even if we don't have an update object
         LOG("UpdateService:_postUpdateProcessing - patch found in applying " +
             "state for the second time");
         cleanupActiveUpdate();
       }
       return;
     }
 #ifdef MOZ_WIDGET_GONK
     // The update is only applied but not selected to be installed
     if (status == STATE_APPLIED && update && update.isOSUpdate) {
       LOG("UpdateService:_postUpdateProcessing - update staged as applied found");
       return;
     }
     if (status == STATE_APPLIED_OS && update && update.isOSUpdate) {
       // In gonk, we need to check for OS update status after startup, since
       // the recovery partition won't write to update.status for us
       var recoveryService = Cc["@mozilla.org/recovery-service;1"].
                             getService(Ci.nsIRecoveryService);
       var fotaStatus = recoveryService.getFotaUpdateStatus();
       switch (fotaStatus) {
         case Ci.nsIRecoveryService.FOTA_UPDATE_SUCCESS:
           status = STATE_SUCCEEDED;
           break;
         case Ci.nsIRecoveryService.FOTA_UPDATE_FAIL:
           status = STATE_FAILED + ": " + FOTA_GENERAL_ERROR;
           break;
         case Ci.nsIRecoveryService.FOTA_UPDATE_UNKNOWN:
         default:
           status = STATE_FAILED + ": " + FOTA_UNKNOWN_ERROR;
           break;
       }
     }
 #endif
     if (!update) {
       if (status != STATE_SUCCEEDED) {
         LOG("UpdateService:_postUpdateProcessing - previous patch failed " +
             "and no patch available");
         cleanupActiveUpdate();
         return;
       }
       update = new Update(null);
     }
     var prompter = Cc["@mozilla.org/updates/update-prompt;1"].
                    createInstance(Ci.nsIUpdatePrompt);
     update.state = status;
     this._sendStatusCodeTelemetryPing(status);
     if (status == STATE_SUCCEEDED) {
       update.statusText = gUpdateBundle.GetStringFromName("installSuccess");
       // Update the patch's metadata.
       um.activeUpdate = update;
       Services.prefs.setBoolPref(PREF_APP_UPDATE_POSTUPDATE, true);
       prompter.showUpdateInstalled();
       // Done with this update. Clean it up.
       cleanupActiveUpdate();
     }
     else {
       // If we hit an error, then the error code will be included in the status
       // string following a colon and a space. If we had an I/O error, then we
       // assume that the patch is not invalid, and we re-stage the patch so that
       // it can be attempted again the next time we restart. This will leave a
       // space at the beginning of the error code when there is a failure which
       // will be removed by using parseInt below. This prevents panic which has
       // occurred numerous times previously (see bug 569642 comment #9 for one
       // example) when testing releases due to forgetting to include the space.
       var ary = status.split(":");
       update.state = ary[0];
       if (update.state == STATE_FAILED && ary[1]) {
         if (handleUpdateFailure(update, ary[1])) {
           return;
         }
       }
       // Something went wrong with the patch application process.
       handleFallbackToCompleteUpdate(update, false);
       prompter.showUpdateError(update);
     }
     // Now trash the MozUpdater folders which staged/bgupdates uses.
     cleanUpMozUpdaterDirs();
   },
   /**
    * Submit a telemetry ping with the boolean value of a pref for a histogram
    *
    * @param  pref
    *         The preference to report
    * @param  histogram
    *         The histogram ID to report to
    */
   _sendBoolPrefTelemetryPing: function AUS__boolTelemetryPing(pref, histogram) {
     try {
       // The getPref is already wrapped in a try/catch but we never
       // want telemetry pings breaking app update so we just put it
       // inside the try to be safe.
       let val = getPref("getBoolPref", pref, false);
       Services.telemetry.getHistogramById(histogram).add(+val);
     } catch(e) {
       // Don't allow any exception to be propagated.
       Cu.reportError(e);
     }
   },
 #ifdef XP_WIN
   /**
    * Submit a telemetry ping with a boolean value which indicates if the service
    * is installed.
    * Also submits a telemetry ping with a boolean value which indicates if the
    * service was at some point installed, but is now uninstalled.
    */
   _sendServiceInstalledTelemetryPing: function AUS__svcInstallTelemetryPing() {
     let installed = isServiceInstalled(); // Is the service installed?
     let attempted = 0;
     try {
       let wrk = Cc["@mozilla.org/windows-registry-key;1"].
                 createInstance(Ci.nsIWindowsRegKey);
       wrk.open(wrk.ROOT_KEY_LOCAL_MACHINE,
                "SOFTWARE\\Mozilla\\MaintenanceService",
                wrk.ACCESS_READ | wrk.WOW64_64);
       // Was the service at some point installed, but is now uninstalled?
       attempted = wrk.readIntValue("Attempted");
       wrk.close();
     } catch(e) {
     }
     try {
       let h = Services.telemetry.getHistogramById("UPDATER_SERVICE_INSTALLED");
       h.add(Number(installed));
     } catch(e) {
       // Don't allow any exception to be propagated.
       Cu.reportError(e);
     }
     try {
       let h = Services.telemetry.getHistogramById("UPDATER_SERVICE_MANUALLY_UNINSTALLED");
       h.add(!installed && attempted ? 1 : 0);
     } catch(e) {
       // Don't allow any exception to be propagated.
       Cu.reportError(e);
     }
   },
 #endif
   /**
    * Submit a telemetry ping with the int value of a pref for a histogram
    *
    * @param  pref
    *         The preference to report
    * @param histogram
    *         The histogram ID to report to
    */
   _sendIntPrefTelemetryPing: function AUS__intTelemetryPing(pref, histogram) {
     try {
       // The getPref is already wrapped in a try/catch but we never
       // want telemetry pings breaking app update so we just put it
       // inside the try to be safe.
       let val = getPref("getIntPref", pref, 0);
       Services.telemetry.getHistogramById(histogram).add(val);
     } catch(e) {
       // Don't allow any exception to be propagated.
       Cu.reportError(e);
     }
   },
   /**
    * Submit the results of applying the update via telemetry.
    *
    * @param  status
    *         The status of the update as read from the update.status file
    */
   _sendStatusCodeTelemetryPing: function AUS__statusTelemetryPing(status) {
     try {
       let parts = status.split(":");
       if ((parts.length == 1 && status != STATE_SUCCEEDED) ||
           (parts.length > 1  && parts[0] != STATE_FAILED)) {
         // Should also report STATE_DOWNLOAD_FAILED
         return;
       }
       let result = 0; // 0 means success
       if (parts.length > 1) {
         result = parseInt(parts[1]) || INVALID_UPDATER_STATUS_CODE;
       }
       Services.telemetry.getHistogramById("UPDATER_STATUS_CODES").add(result);
     } catch(e) {
       // Don't allow any exception to be propagated.
       Cu.reportError(e);
     }
   },
   /**
    * Submit the interval in days since the last notification for this background
    * update check.
    */
   _sendLastNotifyIntervalPing: function AUS__notifyIntervalPing() {
     if (Services.prefs.prefHasUserValue(PREF_APP_UPDATE_LASTUPDATETIME)) {
       let idSuffix = this._isNotify ? "NOTIFY" : "EXTERNAL";
       let lastUpdateTimeSeconds = getPref("getIntPref",
                                           PREF_APP_UPDATE_LASTUPDATETIME, 0);
       if (lastUpdateTimeSeconds) {
         let currentTimeSeconds = Math.round(Date.now() / 1000);
         if (lastUpdateTimeSeconds > currentTimeSeconds) {
           try {
             Services.telemetry.
               getHistogramById("UPDATER_INVALID_LASTUPDATETIME_" + idSuffix).
               add(1);
           } catch(e) {
             Cu.reportError(e);
           }
         }
         else {
           let intervalDays = (currentTimeSeconds - lastUpdateTimeSeconds) /
                              (60 * 60 * 24);
           try {
             Services.telemetry.
               getHistogramById("UPDATER_INVALID_LASTUPDATETIME_" + idSuffix).
               add(0);
             Services.telemetry.
               getHistogramById("UPDATER_LAST_NOTIFY_INTERVAL_DAYS_" + idSuffix).
               add(intervalDays);
           } catch(e) {
             Cu.reportError(e);
           }
         }
       }
     }
   },
   /**
    * Submit the result for the background update check.
    *
    * @param  code
    *         An integer value as defined by the PING_BGUC_* constants.
    */
   _backgroundUpdateCheckCodePing: function AUS__backgroundUpdateCheckCodePing(code) {
     try {
       let idSuffix = this._isNotify ? "NOTIFY" : "EXTERNAL";
       Services.telemetry.
         getHistogramById("UPDATER_BACKGROUND_CHECK_CODE_" + idSuffix).add(code);
     }
     catch (e) {
       Cu.reportError(e);
     }
   },
   /**
    * Register an observer when the network comes online, so we can short-circuit
    * the app.update.interval when there isn't connectivity
    */
   _registerOnlineObserver: function AUS__registerOnlineObserver() {
     if (this._registeredOnlineObserver) {
       LOG("UpdateService:_registerOnlineObserver - observer already registered");
       return;
     }
     LOG("UpdateService:_registerOnlineObserver - waiting for the network to " +
         "be online, then forcing another check");
     Services.obs.addObserver(this, "network:offline-status-changed", false);
     this._registeredOnlineObserver = true;
   },
   /**
    * Called from the network:offline-status-changed observer.
    */
   _offlineStatusChanged: function AUS__offlineStatusChanged(status) {
     if (status !== "online") {
       return;
     }
     Services.obs.removeObserver(this, "network:offline-status-changed");
     this._registeredOnlineObserver = false;
     LOG("UpdateService:_offlineStatusChanged - network is online, forcing " +
         "another background check");
     // the background checker is contained in notify
     this._attemptResume();
   },
   onCheckComplete: function AUS_onCheckComplete(request, updates, updateCount) {
     this._selectAndInstallUpdate(updates);
   },
   onError: function AUS_onError(request, update) {
     LOG("UpdateService:onError - error during background update. error code: " +
         update.errorCode + ", status text: " + update.statusText);
     var maxErrors;
     var errCount;
     if (update.errorCode == NETWORK_ERROR_OFFLINE) {
       // Register an online observer to try again
       this._registerOnlineObserver();
       this._backgroundUpdateCheckCodePing(PING_BGUC_OFFLINE);
       return;
     }
     if (update.errorCode == CERT_ATTR_CHECK_FAILED_NO_UPDATE ||
         update.errorCode == CERT_ATTR_CHECK_FAILED_HAS_UPDATE) {
       errCount = getPref("getIntPref", PREF_APP_UPDATE_CERT_ERRORS, 0);
       errCount++;
       Services.prefs.setIntPref(PREF_APP_UPDATE_CERT_ERRORS, errCount);
       maxErrors = getPref("getIntPref", PREF_APP_UPDATE_CERT_MAXERRORS, 5);
     }
     else {
       update.errorCode = BACKGROUNDCHECK_MULTIPLE_FAILURES;
       errCount = getPref("getIntPref", PREF_APP_UPDATE_BACKGROUNDERRORS, 0);
       errCount++;
       Services.prefs.setIntPref(PREF_APP_UPDATE_BACKGROUNDERRORS, errCount);
       maxErrors = getPref("getIntPref", PREF_APP_UPDATE_BACKGROUNDMAXERRORS,
 );
     }
     var pingCode;
     if (errCount >= maxErrors) {
       var prompter = Cc["@mozilla.org/updates/update-prompt;1"].
                      createInstance(Ci.nsIUpdatePrompt);
       prompter.showUpdateError(update);
       switch (update.errorCode) {
         case CERT_ATTR_CHECK_FAILED_NO_UPDATE:
           pingCode = PING_BGUC_CERT_ATTR_NO_UPDATE_NOTIFY;
           break;
         case CERT_ATTR_CHECK_FAILED_HAS_UPDATE:
           pingCode = PING_BGUC_CERT_ATTR_WITH_UPDATE_NOTIFY;
           break;
         default:
           pingCode = PING_BGUC_GENERAL_ERROR_NOTIFY;
       }
     }
     else {
       switch (update.errorCode) {
         case CERT_ATTR_CHECK_FAILED_NO_UPDATE:
           pingCode = PING_BGUC_CERT_ATTR_NO_UPDATE_SILENT;
           break;
         case CERT_ATTR_CHECK_FAILED_HAS_UPDATE:
           pingCode = PING_BGUC_CERT_ATTR_WITH_UPDATE_SILENT;
           break;
         default:
           pingCode = PING_BGUC_GENERAL_ERROR_SILENT;
       }
     }
     this._backgroundUpdateCheckCodePing(pingCode);
   },
   /**
    * Called when a connection should be resumed
    */
   _attemptResume: function AUS_attemptResume() {
     LOG("UpdateService:_attemptResume")
     // If a download is in progress, then resume it.
     if (this._downloader && this._downloader._patch &&
         this._downloader._patch.state == STATE_DOWNLOADING &&
         this._downloader._update) {
       LOG("UpdateService:_attemptResume - _patch.state: " +
           this._downloader._patch.state);
       // Make sure downloading is the state for selectPatch to work correctly
       writeStatusFile(getUpdatesDir(), STATE_DOWNLOADING);
       var status = this.downloadUpdate(this._downloader._update,
                                        this._downloader.background);
       LOG("UpdateService:_attemptResume - downloadUpdate status: " + status);
       if (status == STATE_NONE) {
         cleanupActiveUpdate();
       }
       return;
     }
     this.backgroundChecker.checkForUpdates(this, false);
   },
   /**
    * Notified when a timer fires
    * @param   timer
    *          The timer that fired
    */
   notify: function AUS_notify(timer) {
     // The telemetry below is specific to background notification.
     this._sendBoolPrefTelemetryPing(PREF_APP_UPDATE_ENABLED,
                                     "UPDATER_UPDATES_ENABLED");
     this._sendBoolPrefTelemetryPing(PREF_APP_UPDATE_METRO_ENABLED,
                                     "UPDATER_UPDATES_METRO_ENABLED");
     this._sendBoolPrefTelemetryPing(PREF_APP_UPDATE_AUTO,
                                     "UPDATER_UPDATES_AUTOMATIC");
     this._sendBoolPrefTelemetryPing(PREF_APP_UPDATE_STAGING_ENABLED,
                                     "UPDATER_STAGE_ENABLED");
 #ifdef XP_WIN
     this._sendBoolPrefTelemetryPing(PREF_APP_UPDATE_SERVICE_ENABLED,
                                     "UPDATER_SERVICE_ENABLED");
     this._sendIntPrefTelemetryPing(PREF_APP_UPDATE_SERVICE_ERRORS,
                                    "UPDATER_SERVICE_ERRORS");
     this._sendServiceInstalledTelemetryPing();
 #endif
     this._checkForBackgroundUpdates(true);
   },
   /**
    * See nsIUpdateService.idl
    */
   checkForBackgroundUpdates: function AUS_checkForBackgroundUpdates() {
     this._checkForBackgroundUpdates(false);
   },
   /**
    * Checks for updates in the background.
    * @param   isNotify
    *          Whether or not a background update check was initiated by the
    *          application update timer notification.
    */
   _checkForBackgroundUpdates: function AUS__checkForBackgroundUpdates(isNotify) {
     this._isNotify = isNotify;
     // From this point on, the telemetry reported differentiates between a call
     // to notify and a call to checkForBackgroundUpdates so they are reported
     // separately.
     this._sendLastNotifyIntervalPing();
     // If a download is in progress or the patch has been staged do nothing.
     if (this.isDownloading) {
       this._backgroundUpdateCheckCodePing(PING_BGUC_IS_DOWNLOADING);
       return;
     }
     if (this._downloader && this._downloader.patchIsStaged) {
       this._backgroundUpdateCheckCodePing(PING_BGUC_IS_STAGED);
       return;
     }
     // The following checks will return early without notification in the call
     // to checkForUpdates below. To simplify the background update check ping
     // their values are checked here.
     try {
       if (!this.backgroundChecker.getUpdateURL(false)) {
         let prefs = Services.prefs;
         if (!prefs.prefHasUserValue(PREF_APP_UPDATE_URL_OVERRIDE)) {
           if (!prefs.prefHasUserValue(PREF_APP_UPDATE_URL)) {
             this._backgroundUpdateCheckCodePing(PING_BGUC_INVALID_DEFAULT_URL);
           }
           else {
             this._backgroundUpdateCheckCodePing(PING_BGUC_INVALID_CUSTOM_URL);
           }
         }
         else {
           this._backgroundUpdateCheckCodePing(PING_BGUC_INVALID_OVERRIDE_URL);
         }
       }
       else if (!gMetroUpdatesEnabled) {
         this._backgroundUpdateCheckCodePing(PING_BGUC_METRO_DISABLED);
       }
       else if (!getPref("getBoolPref", PREF_APP_UPDATE_ENABLED, true)) {
         this._backgroundUpdateCheckCodePing(PING_BGUC_PREF_DISABLED);
       }
       else if (!(gCanCheckForUpdates && hasUpdateMutex())) {
         this._backgroundUpdateCheckCodePing(PING_BGUC_UNABLE_TO_CHECK);
       }
       else if (!this.backgroundChecker._enabled) {
         this._backgroundUpdateCheckCodePing(PING_BGUC_DISABLED_FOR_SESSION);
       }
     }
     catch (e) {
       Cu.reportError(e);
     }
     this.backgroundChecker.checkForUpdates(this, false);
   },
   /**
    * Determine the update from the specified updates that should be offered.
    * If both valid major and minor updates are available the minor update will
    * be offered.
    * @param   updates
    *          An array of available nsIUpdate items
    * @return  The nsIUpdate to offer.
    */
   selectUpdate: function AUS_selectUpdate(updates) {
     if (updates.length == 0) {
       this._backgroundUpdateCheckCodePing(PING_BGUC_NO_UPDATE_FOUND);
       return null;
     }
     // The ping for unsupported is sent after the call to showPrompt.
     if (updates.length == 1 && updates[0].unsupported)
       return updates[0];
     // Choose the newest of the available minor and major updates.
     var majorUpdate = null;
     var minorUpdate = null;
     var vc = Services.vc;
     var lastPingCode = PING_BGUC_NO_COMPAT_UPDATE_FOUND;
     updates.forEach(function(aUpdate) {
       // Ignore updates for older versions of the application and updates for
       // the same version of the application with the same build ID.
 #ifdef TOR_BROWSER_UPDATE
       var compatVersion = TOR_BROWSER_VERSION;
 #else
       var compatVersion = Services.appinfo.version;
 #endif
       var rc = vc.compare(aUpdate.appVersion, compatVersion);
       if (rc < 0 || ((rc == 0) &&
                      (aUpdate.buildID == Services.appinfo.appBuildID))) {
         LOG("UpdateService:selectUpdate - skipping update because the " +
             "update's application version is less than the current " +
             "application version");
         lastPingCode = PING_BGUC_UPDATE_PREVIOUS_VERSION;
         return;
       }
       // Skip the update if the user responded with "never" to this update's
       // application version and the update specifies showNeverForVersion
       // (see bug 350636).
       let neverPrefName = PREF_APP_UPDATE_NEVER_BRANCH + aUpdate.appVersion;
       if (aUpdate.showNeverForVersion &&
           getPref("getBoolPref", neverPrefName, false)) {
         LOG("UpdateService:selectUpdate - skipping update because the " +
             "preference " + neverPrefName + " is true");
         lastPingCode = PING_BGUC_UPDATE_NEVER_PREF;
         return;
       }
       switch (aUpdate.type) {
         case "major":
           if (!majorUpdate)
             majorUpdate = aUpdate;
           else if (vc.compare(majorUpdate.appVersion, aUpdate.appVersion) <= 0)
             majorUpdate = aUpdate;
           break;
         case "minor":
           if (!minorUpdate)
             minorUpdate = aUpdate;
           else if (vc.compare(minorUpdate.appVersion, aUpdate.appVersion) <= 0)
             minorUpdate = aUpdate;
           break;
         default:
           LOG("UpdateService:selectUpdate - skipping unknown update type: " +
               aUpdate.type);
           lastPingCode = PING_BGUC_UPDATE_INVALID_TYPE;
           break;
       }
     });
     var update = minorUpdate || majorUpdate;
     if (!update)
       this._backgroundUpdateCheckCodePing(lastPingCode);
     return update;
   },
   /**
    * Reference to the currently selected update for when add-on compatibility
    * is checked.
    */
   _update: null,
   /**
    * Determine which of the specified updates should be installed and begin the
    * download/installation process or notify the user about the update.
    * @param   updates
    *          An array of available updates
    */
   _selectAndInstallUpdate: function AUS__selectAndInstallUpdate(updates) {
     // Return early if there's an active update. The user is already aware and
     // is downloading or performed some user action to prevent notification.
     var um = Cc["@mozilla.org/updates/update-manager;1"].
              getService(Ci.nsIUpdateManager);
     if (um.activeUpdate) {
 #ifdef MOZ_WIDGET_GONK
       // For gonk, the user isn't necessarily aware of the update, so we need
       // to show the prompt to make sure.
       this._showPrompt(um.activeUpdate);
 #endif
       this._backgroundUpdateCheckCodePing(PING_BGUC_HAS_ACTIVEUPDATE);
       return;
     }
     var updateEnabled = getPref("getBoolPref", PREF_APP_UPDATE_ENABLED, true);
     if (!updateEnabled) {
       this._backgroundUpdateCheckCodePing(PING_BGUC_PREF_DISABLED);
       LOG("UpdateService:_selectAndInstallUpdate - not prompting because " +
           "update is disabled");
       return;
     }
     if (!gMetroUpdatesEnabled) {
       this._backgroundUpdateCheckCodePing(PING_BGUC_METRO_DISABLED);
       return;
     }
     var update = this.selectUpdate(updates, updates.length);
     if (!update) {
       return;
     }
     if (update.unsupported) {
       LOG("UpdateService:_selectAndInstallUpdate - update not supported for " +
           "this system");
       if (!getPref("getBoolPref", PREF_APP_UPDATE_NOTIFIEDUNSUPPORTED, false)) {
         LOG("UpdateService:_selectAndInstallUpdate - notifying that the " +
             "update is not supported for this system");
         this._showPrompt(update);
       }
       this._backgroundUpdateCheckCodePing(PING_BGUC_UNSUPPORTED);
       return;
     }
     if (!(gCanApplyUpdates && hasUpdateMutex())) {
       LOG("UpdateService:_selectAndInstallUpdate - the user is unable to " +
           "apply updates... prompting");
       this._showPrompt(update);
       this._backgroundUpdateCheckCodePing(PING_BGUC_UNABLE_TO_APPLY);
       return;
     }
     /**
 #      From this point on there are two possible outcomes:
 #      1. download and install the update automatically
 #      2. notify the user about the availability of an update
 #
 #      Notes:
 #      a) if the app.update.auto preference is false then automatic download and
 #         install is disabled and the user will be notified.
 #      b) if the update has a showPrompt attribute the user will be notified.
 #      c) Mode is determined by the value of the app.update.mode preference.
 #
 #      If the update when it is first read has an appVersion attribute the
 #      following behavior implemented in bug 530872 will occur:
 #      Mode   Incompatible Add-ons   Outcome
 #      0      N/A                    Auto Install
 #      1      Yes                    Notify
 #      1      No                     Auto Install
 #
 #      If the update when it is first read does not have an appVersion attribute
 #      the following deprecated behavior will occur:
 #      Update Type   Mode   Incompatible Add-ons   Outcome
 #      Major         all    N/A                    Notify
 #      Minor         0      N/A                    Auto Install
 #      Minor         1      Yes                    Notify
 #      Minor         1      No                     Auto Install
      */
     if (update.showPrompt) {
       LOG("UpdateService:_selectAndInstallUpdate - prompting because the " +
           "update snippet specified showPrompt");
       this._showPrompt(update);
       if (!Services.metro || !Services.metro.immersive) {
         this._backgroundUpdateCheckCodePing(PING_BGUC_SHOWPROMPT_SNIPPET);
         return;
       }
     }
     if (!getPref("getBoolPref", PREF_APP_UPDATE_AUTO, true)) {
       LOG("UpdateService:_selectAndInstallUpdate - prompting because silent " +
           "install is disabled");
       this._showPrompt(update);
       if (!Services.metro || !Services.metro.immersive) {
         this._backgroundUpdateCheckCodePing(PING_BGUC_SHOWPROMPT_PREF);
         return;
       }
     }
     if (getPref("getIntPref", PREF_APP_UPDATE_MODE, 1) == 0) {
       // Do not prompt regardless of add-on incompatibilities
       LOG("UpdateService:_selectAndInstallUpdate - add-on compatibility " +
           "check disabled by preference, just download the update");
       var status = this.downloadUpdate(update, true);
       if (status == STATE_NONE)
         cleanupActiveUpdate();
       this._backgroundUpdateCheckCodePing(PING_BGUC_ADDON_PREF_DISABLED);
       return;
     }
     // Only check add-on compatibility when the version changes.
 #ifdef TOR_BROWSER_UPDATE
     var compatVersion = TOR_BROWSER_VERSION;
 #else
     var compatVersion = Services.appinfo.version;
 #endif
     if (update.appVersion &&
         Services.vc.compare(update.appVersion, compatVersion) != 0) {
       this._update = update;
       this._checkAddonCompatibility();
     }
     else {
       LOG("UpdateService:_selectAndInstallUpdate - add-on compatibility " +
           "check not performed due to the update version being the same as " +
           "the current application version, just download the update");
       var status = this.downloadUpdate(update, true);
       if (status == STATE_NONE)
         cleanupActiveUpdate();
       this._backgroundUpdateCheckCodePing(PING_BGUC_ADDON_SAME_APP_VER);
     }
   },
   _showPrompt: function AUS__showPrompt(update) {
     var prompter = Cc["@mozilla.org/updates/update-prompt;1"].
                    createInstance(Ci.nsIUpdatePrompt);
     prompter.showUpdateAvailable(update);
   },
   _checkAddonCompatibility: function AUS__checkAddonCompatibility() {
     try {
       var hotfixID = Services.prefs.getCharPref(PREF_EM_HOTFIX_ID);
     }
     catch (e) { }
     // Get all the installed add-ons
     var self = this;
     AddonManager.getAllAddons(function(addons) {
 #ifdef TOR_BROWSER_UPDATE
       let compatVersion = self._update.platformVersion;
 #else
       let compatVersion = self._update.appVersion;
 #endif
       self._incompatibleAddons = [];
       addons.forEach(function(addon) {
         // Protect against code that overrides the add-ons manager and doesn't
         // implement the isCompatibleWith or the findUpdates method.
         if (!("isCompatibleWith" in addon) || !("findUpdates" in addon)) {
           let errMsg = "Add-on doesn't implement either the isCompatibleWith " +
                        "or the findUpdates method!";
           if (addon.id)
             errMsg += " Add-on ID: " + addon.id;
           Cu.reportError(errMsg);
           return;
         }
         // If an add-on isn't appDisabled and isn't userDisabled then it is
         // either active now or the user expects it to be active after the
         // restart. If that is the case and the add-on is not installed by the
         // application and is not compatible with the new application version
         // then the user should be warned that the add-on will become
         // incompatible. If an addon's type equals plugin it is skipped since
         // checking plugins compatibility information isn't supported and
         // getting the scope property of a plugin breaks in some environments
         // (see bug 566787). The hotfix add-on is also ignored as it shouldn't
         // block the user from upgrading.
         try {
           if (addon.type != "plugin" && addon.id != hotfixID &&
               !addon.appDisabled && !addon.userDisabled &&
               addon.scope != AddonManager.SCOPE_APPLICATION &&
               addon.isCompatible &&
               !addon.isCompatibleWith(compatVersion,
                                       self._update.platformVersion))
             self._incompatibleAddons.push(addon);
         }
         catch (e) {
           Cu.reportError(e);
         }
       });
       if (self._incompatibleAddons.length > 0) {
       /**
 #        PREF_APP_UPDATE_INCOMPATIBLE_MODE
 #        Controls the mode in which we check for updates as follows.
 #
 #          PREF_APP_UPDATE_INCOMPATIBLE_MODE != 1
 #          We check for VersionInfo _and_ NewerVersion updates for the
 #          incompatible add-ons - i.e. if Foo 1.2 is installed and it is
 #          incompatible with the update, and we find Foo 2.0 which is but has
 #          not been installed, then we do NOT prompt because the user can
 #          download Foo 2.0 when they restart after the update during the add-on
 #          mismatch checking UI. This is the default, since it suppresses most
 #          prompt dialogs.
 #
 #          PREF_APP_UPDATE_INCOMPATIBLE_MODE == 1
 #          We check for VersionInfo updates for the incompatible add-ons - i.e.
 #          if the situation above with Foo 1.2 and available update to 2.0
 #          applies, we DO show the prompt since a download operation will be
 #          required after the update. This is not the default and is supplied
 #          only as a hidden option for those that want it.
        */
         self._updateCheckCount = self._incompatibleAddons.length;
         LOG("UpdateService:_checkAddonCompatibility - checking for " +
             "incompatible add-ons");
         self._incompatibleAddons.forEach(function(addon) {
           addon.findUpdates(this, AddonManager.UPDATE_WHEN_NEW_APP_DETECTED,
                             compatVersion, this._update.platformVersion);
         }, self);
       }
       else {
         LOG("UpdateService:_checkAddonCompatibility - no incompatible " +
             "add-ons found, just download the update");
         var status = self.downloadUpdate(self._update, true);
         if (status == STATE_NONE)
           cleanupActiveUpdate();
         self._update = null;
         this._backgroundUpdateCheckCodePing(PING_BGUC_CHECK_NO_INCOMPAT);
       }
     });
   },
   // AddonUpdateListener
   onCompatibilityUpdateAvailable: function(addon) {
     // Remove the add-on from the list of add-ons that will become incompatible
     // with the new version of the application.
     for (var i = 0; i < this._incompatibleAddons.length; ++i) {
       if (this._incompatibleAddons[i].id == addon.id) {
         LOG("UpdateService:onCompatibilityUpdateAvailable - found update for " +
             "add-on ID: " + addon.id);
         this._incompatibleAddons.splice(i, 1);
       }
     }
   },
   onUpdateAvailable: function(addon, install) {
     if (getPref("getIntPref", PREF_APP_UPDATE_INCOMPATIBLE_MODE, 0) == 1)
       return;
     // If the new version of this add-on is blocklisted for the new application
     // then it isn't a valid update and the user should still be warned that
     // the add-on will become incompatible.
     let bs = Cc["@mozilla.org/extensions/blocklist;1"].
              getService(Ci.nsIBlocklistService);
 #ifdef TOR_BROWSER_UPDATE
     let compatVersion = gUpdates.update.platformVersion;
 #else
     let compatVersion = gUpdates.update.appVersion;
 #endif
     if (bs.isAddonBlocklisted(addon,
                               compatVersion,
                               gUpdates.update.platformVersion))
       return;
     // Compatibility or new version updates mean the same thing here.
     this.onCompatibilityUpdateAvailable(addon);
   },
   onUpdateFinished: function(addon) {
     if (--this._updateCheckCount > 0)
       return;
     if (this._incompatibleAddons.length > 0 ||
         !(gCanApplyUpdates && hasUpdateMutex())) {
       LOG("UpdateService:onUpdateEnded - prompting because there are " +
           "incompatible add-ons");
       this._showPrompt(this._update);
       this._backgroundUpdateCheckCodePing(PING_BGUC_ADDON_HAVE_INCOMPAT);
     }
     else {
       LOG("UpdateService:_selectAndInstallUpdate - updates for all " +
           "incompatible add-ons found, just download the update");
       var status = this.downloadUpdate(this._update, true);
       if (status == STATE_NONE)
         cleanupActiveUpdate();
       this._backgroundUpdateCheckCodePing(PING_BGUC_ADDON_UPDATES_FOR_INCOMPAT);
     }
     this._update = null;
   },
   /**
    * The Checker used for background update checks.
    */
   _backgroundChecker: null,
   /**
    * See nsIUpdateService.idl
    */
   get backgroundChecker() {
     if (!this._backgroundChecker)
       this._backgroundChecker = new Checker();
     return this._backgroundChecker;
   },
   /**
    * See nsIUpdateService.idl
    */
   get canCheckForUpdates() {
     return gCanCheckForUpdates && hasUpdateMutex();
   },
   /**
    * See nsIUpdateService.idl
    */
   get canApplyUpdates() {
     return gCanApplyUpdates && hasUpdateMutex();
   },
   /**
    * See nsIUpdateService.idl
    */
   get canStageUpdates() {
     return getCanStageUpdates();
   },
   /**
    * See nsIUpdateService.idl
    */
   get isOtherInstanceHandlingUpdates() {
     return !hasUpdateMutex();
   },
   /**
    * See nsIUpdateService.idl
    */
   addDownloadListener: function AUS_addDownloadListener(listener) {
     if (!this._downloader) {
       LOG("UpdateService:addDownloadListener - no downloader!");
       return;
     }
     this._downloader.addDownloadListener(listener);
   },
   /**
    * See nsIUpdateService.idl
    */
   removeDownloadListener: function AUS_removeDownloadListener(listener) {
     if (!this._downloader) {
       LOG("UpdateService:removeDownloadListener - no downloader!");
       return;
     }
     this._downloader.removeDownloadListener(listener);
   },
   /**
    * See nsIUpdateService.idl
    */
   downloadUpdate: function AUS_downloadUpdate(update, background) {
     if (!update)
       throw Cr.NS_ERROR_NULL_POINTER;
     // Don't download the update if the update's version is less than the
     // current application's version or the update's version is the same as the
     // application's version and the build ID is the same as the application's
     // build ID.
 #ifdef TOR_BROWSER_UPDATE
     var compatVersion = TOR_BROWSER_VERSION;
 #else
     var compatVersion = Services.appinfo.version;
 #endif
     if (update.appVersion &&
         (Services.vc.compare(update.appVersion, compatVersion) < 0 ||
          update.buildID && update.buildID == Services.appinfo.appBuildID &&
          update.appVersion == compatVersion)) {
       LOG("UpdateService:downloadUpdate - canceling download of update since " +
           "it is for an earlier or same application version and build ID.\n" +
 #ifdef TOR_BROWSER_UPDATE
           "current Tor Browser version: " + compatVersion + "\n" +
           "update Tor Browser version : " + update.appVersion + "\n" +
 #else
           "current application version: " + compatVersion + "\n" +
           "update application version : " + update.appVersion + "\n" +
 #endif
           "current build ID: " + Services.appinfo.appBuildID + "\n" +
           "update build ID : " + update.buildID);
       cleanupActiveUpdate();
       return STATE_NONE;
     }
     // If a download request is in progress vs. a download ready to resume
     if (this.isDownloading) {
       if (update.isCompleteUpdate == this._downloader.isCompleteUpdate &&
           background == this._downloader.background) {
         LOG("UpdateService:downloadUpdate - no support for downloading more " +
             "than one update at a time");
         return readStatusFile(getUpdatesDir());
       }
       this._downloader.cancel();
     }
 #ifdef MOZ_WIDGET_GONK
     var um = Cc["@mozilla.org/updates/update-manager;1"].
              getService(Ci.nsIUpdateManager);
     var activeUpdate = um.activeUpdate;
     if (activeUpdate &&
         (activeUpdate.appVersion != update.appVersion ||
          activeUpdate.buildID != update.buildID)) {
       // We have an activeUpdate (which presumably was interrupted), and are
       // about start downloading a new one. Make sure we remove all traces
       // of the active one (otherwise we'll start appending the new update.mar
       // the the one that's been partially downloaded).
       LOG("UpdateService:downloadUpdate - removing stale active update.");
       cleanupActiveUpdate();
     }
 #endif
     // Set the previous application version prior to downloading the update.
     update.previousAppVersion = compatVersion;
     this._downloader = new Downloader(background, this);
     return this._downloader.downloadUpdate(update);
   },
   /**
    * See nsIUpdateService.idl
    */
   pauseDownload: function AUS_pauseDownload() {
     if (this.isDownloading) {
       this._downloader.cancel();
     } else if (this._retryTimer) {
       // Download status is still consider as 'downloading' during retry.
       // We need to cancel both retry and download at this stage.
       this._retryTimer.cancel();
       this._retryTimer = null;
       this._downloader.cancel();
     }
   },
   /**
    * See nsIUpdateService.idl
    */
   getUpdatesDirectory: getUpdatesDir,
   /**
    * See nsIUpdateService.idl
    */
   get isDownloading() {
     return this._downloader && this._downloader.isBusy;
   },
   /**
    * See nsIUpdateService.idl
    */
   applyOsUpdate: function AUS_applyOsUpdate(aUpdate) {
     if (!aUpdate.isOSUpdate || aUpdate.state != STATE_APPLIED) {
       aUpdate.statusText = "fota-state-error";
       throw Cr.NS_ERROR_FAILURE;
     }
     let osApplyToDir;
     try {
       aUpdate.QueryInterface(Ci.nsIWritablePropertyBag);
       osApplyToDir = aUpdate.getProperty("osApplyToDir");
     } catch (e) {}
     if (!osApplyToDir) {
       LOG("UpdateService:applyOsUpdate - Error: osApplyToDir is not defined" +
           "in the nsIUpdate!");
       handleUpdateFailure(aUpdate, FOTA_FILE_OPERATION_ERROR);
       return;
     }
     let updateFile = Cc["@mozilla.org/file/local;1"].createInstance(Ci.nsIFile);
     updateFile.initWithPath(osApplyToDir + "/update.zip");
     if (!updateFile.exists()) {
       LOG("UpdateService:applyOsUpdate - Error: OS update is not found at " +
           updateFile.path);
       handleUpdateFailure(aUpdate, FOTA_FILE_OPERATION_ERROR);
       return;
     }
     writeStatusFile(getUpdatesDir(), aUpdate.state = STATE_APPLIED_OS);
     LOG("UpdateService:applyOsUpdate - Rebooting into recovery to apply " +
         "FOTA update: " + updateFile.path);
     try {
       let recoveryService = Cc["@mozilla.org/recovery-service;1"]
                             .getService(Ci.nsIRecoveryService);
       recoveryService.installFotaUpdate(updateFile.path);
     } catch (e) {
       LOG("UpdateService:applyOsUpdate - Error: Couldn't reboot into recovery" +
           " to apply FOTA update " + updateFile.path);
       writeStatusFile(getUpdatesDir(), aUpdate.state = STATE_APPLIED);
       handleUpdateFailure(aUpdate, FOTA_RECOVERY_ERROR);
     }
   },
   classID: UPDATESERVICE_CID,
   classInfo: XPCOMUtils.generateCI({classID: UPDATESERVICE_CID,
                                     contractID: UPDATESERVICE_CONTRACTID,
                                     interfaces: [Ci.nsIApplicationUpdateService,
                                                  Ci.nsITimerCallback,
                                                  Ci.nsIObserver],
                                     flags: Ci.nsIClassInfo.SINGLETON}),
   _xpcom_factory: UpdateServiceFactory,
   QueryInterface: XPCOMUtils.generateQI([Ci.nsIApplicationUpdateService,
                                          Ci.nsIUpdateCheckListener,
                                          Ci.nsITimerCallback,
                                          Ci.nsIObserver])
 };
 /**
  * A service to manage active and past updates.
  * @constructor
  */
 function UpdateManager() {
   // Ensure the Active Update file is loaded
   var updates = this._loadXMLFileIntoArray(getUpdateFile(
                   [FILE_UPDATE_ACTIVE]));
   if (updates.length > 0) {
     // Under some edgecases such as Windows system restore the active-update.xml
     // will contain a pending update without the status file which will return
     // STATE_NONE. To recover from this situation clean the updates dir and
     // rewrite the active-update.xml file without the broken update.
     if (readStatusFile(getUpdatesDir()) == STATE_NONE) {
       cleanUpUpdatesDir();
       this._writeUpdatesToXMLFile([], getUpdateFile([FILE_UPDATE_ACTIVE]));
     }
     else
       this._activeUpdate = updates[0];
   }
 }
 UpdateManager.prototype = {
   /**
    * All previously downloaded and installed updates, as an array of nsIUpdate
    * objects.
    */
   _updates: null,
   /**
    * The current actively downloading/installing update, as a nsIUpdate object.
    */
   _activeUpdate: null,
   /**
    * Handle Observer Service notifications
    * @param   subject
    *          The subject of the notification
    * @param   topic
    *          The notification name
    * @param   data
    *          Additional data
    */
   observe: function UM_observe(subject, topic, data) {
     // Hack to be able to run and cleanup tests by reloading the update data.
     if (topic == "um-reload-update-data") {
       this._updates = this._loadXMLFileIntoArray(getUpdateFile(
                         [FILE_UPDATES_DB]));
       this._activeUpdate = null;
       var updates = this._loadXMLFileIntoArray(getUpdateFile(
                       [FILE_UPDATE_ACTIVE]));
       if (updates.length > 0)
         this._activeUpdate = updates[0];
     }
   },
   /**
    * Loads an updates.xml formatted file into an array of nsIUpdate items.
    * @param   file
    *          A nsIFile for the updates.xml file
    * @return  The array of nsIUpdate items held in the file.
    */
   _loadXMLFileIntoArray: function UM__loadXMLFileIntoArray(file) {
     if (!file.exists()) {
       LOG("UpdateManager:_loadXMLFileIntoArray: XML file does not exist");
       return [];
     }
     var result = [];
     var fileStream = Cc["@mozilla.org/network/file-input-stream;1"].
                      createInstance(Ci.nsIFileInputStream);
     fileStream.init(file, FileUtils.MODE_RDONLY, FileUtils.PERMS_FILE, 0);
     try {
       var parser = Cc["@mozilla.org/xmlextras/domparser;1"].
                    createInstance(Ci.nsIDOMParser);
       var doc = parser.parseFromStream(fileStream, "UTF-8",
                                        fileStream.available(), "text/xml");
       const ELEMENT_NODE = Ci.nsIDOMNode.ELEMENT_NODE;
       var updateCount = doc.documentElement.childNodes.length;
       for (var i = 0; i < updateCount; ++i) {
         var updateElement = doc.documentElement.childNodes.item(i);
         if (updateElement.nodeType != ELEMENT_NODE ||
             updateElement.localName != "update")
           continue;
         updateElement.QueryInterface(Ci.nsIDOMElement);
         try {
           var update = new Update(updateElement);
         } catch (e) {
           LOG("UpdateManager:_loadXMLFileIntoArray - invalid update");
           continue;
         }
         result.push(update);
       }
     }
     catch (e) {
       LOG("UpdateManager:_loadXMLFileIntoArray - error constructing update " +
           "list. Exception: " + e);
     }
     fileStream.close();
     return result;
   },
   /**
    * Load the update manager, initializing state from state files.
    */
   _ensureUpdates: function UM__ensureUpdates() {
     if (!this._updates) {
       this._updates = this._loadXMLFileIntoArray(getUpdateFile(
                         [FILE_UPDATES_DB]));
       var activeUpdates = this._loadXMLFileIntoArray(getUpdateFile(
                             [FILE_UPDATE_ACTIVE]));
       if (activeUpdates.length > 0)
         this._activeUpdate = activeUpdates[0];
     }
   },
   /**
    * See nsIUpdateService.idl
    */
   getUpdateAt: function UM_getUpdateAt(index) {
     this._ensureUpdates();
     return this._updates[index];
   },
   /**
    * See nsIUpdateService.idl
    */
   get updateCount() {
     this._ensureUpdates();
     return this._updates.length;
   },
   /**
    * See nsIUpdateService.idl
    */
   get activeUpdate() {
     if (this._activeUpdate &&
         this._activeUpdate.channel != UpdateChannel.get()) {
       LOG("UpdateManager:get activeUpdate - channel has changed, " +
           "reloading default preferences to workaround bug 802022");
       // Workaround to get distribution preferences loaded (Bug 774618). This
       // can be removed after bug 802022 is fixed.
       let prefSvc = Services.prefs.QueryInterface(Ci.nsIObserver);
       prefSvc.observe(null, "reload-default-prefs", null);
       if (this._activeUpdate.channel != UpdateChannel.get()) {
         // User switched channels, clear out any old active updates and remove
         // partial downloads
         this._activeUpdate = null;
         this.saveUpdates();
         // Destroy the updates directory, since we're done with it.
         cleanUpUpdatesDir();
       }
     }
     return this._activeUpdate;
   },
   set activeUpdate(activeUpdate) {
     this._addUpdate(activeUpdate);
     this._activeUpdate = activeUpdate;
     if (!activeUpdate) {
       // If |activeUpdate| is null, we have updated both lists - the active list
       // and the history list, so we want to write both files.
       this.saveUpdates();
     }
     else
       this._writeUpdatesToXMLFile([this._activeUpdate],
                                   getUpdateFile([FILE_UPDATE_ACTIVE]));
     return activeUpdate;
   },
   /**
    * Add an update to the Updates list. If the item already exists in the list,
    * replace the existing value with the new value.
    * @param   update
    *          The nsIUpdate object to add.
    */
   _addUpdate: function UM__addUpdate(update) {
     if (!update)
       return;
     this._ensureUpdates();
     if (this._updates) {
       for (var i = 0; i < this._updates.length; ++i) {
         if (this._updates[i] &&
             this._updates[i].appVersion == update.appVersion &&
             this._updates[i].buildID == update.buildID) {
           // Replace the existing entry with the new value, updating
           // all metadata.
           this._updates[i] = update;
           return;
         }
       }
     }
     // Otherwise add it to the front of the list.
     this._updates.unshift(update);
   },
   /**
    * Serializes an array of updates to an XML file
    * @param   updates
    *          An array of nsIUpdate objects
    * @param   file
    *          The nsIFile object to serialize to
    */
   _writeUpdatesToXMLFile: function UM__writeUpdatesToXMLFile(updates, file) {
     var fos = Cc["@mozilla.org/network/safe-file-output-stream;1"].
               createInstance(Ci.nsIFileOutputStream);
     var modeFlags = FileUtils.MODE_WRONLY | FileUtils.MODE_CREATE |
                     FileUtils.MODE_TRUNCATE;
     if (!file.exists())
       file.create(Ci.nsILocalFile.NORMAL_FILE_TYPE, FileUtils.PERMS_FILE);
     fos.init(file, modeFlags, FileUtils.PERMS_FILE, 0);
     try {
       var parser = Cc["@mozilla.org/xmlextras/domparser;1"].
                    createInstance(Ci.nsIDOMParser);
       const EMPTY_UPDATES_DOCUMENT = "<?xml version=\"1.0\"?><updates xmlns=\"http://www.mozilla.org/2005/app-update\"></updates>";
       var doc = parser.parseFromString(EMPTY_UPDATES_DOCUMENT, "text/xml");
       for (var i = 0; i < updates.length; ++i) {
         if (updates[i])
           doc.documentElement.appendChild(updates[i].serialize(doc));
       }
       var serializer = Cc["@mozilla.org/xmlextras/xmlserializer;1"].
                        createInstance(Ci.nsIDOMSerializer);
       serializer.serializeToStream(doc.documentElement, fos, null);
     }
     catch (e) {
     }
     FileUtils.closeSafeFileOutputStream(fos);
   },
   /**
    * See nsIUpdateService.idl
    */
   saveUpdates: function UM_saveUpdates() {
     this._writeUpdatesToXMLFile([this._activeUpdate],
                                 getUpdateFile([FILE_UPDATE_ACTIVE]));
     if (this._activeUpdate)
       this._addUpdate(this._activeUpdate);
     this._ensureUpdates();
     // Don't write updates that have a temporary state to the updates.xml file.
     if (this._updates) {
       let updates = this._updates.slice();
       for (let i = updates.length - 1; i >= 0; --i) {
         let state = updates[i].state;
         if (state == STATE_NONE || state == STATE_DOWNLOADING ||
             state == STATE_APPLIED || state == STATE_APPLIED_SVC ||
             state == STATE_PENDING || state == STATE_PENDING_SVC) {
           updates.splice(i, 1);
         }
       }
       this._writeUpdatesToXMLFile(updates.slice(0, 10),
                                   getUpdateFile([FILE_UPDATES_DB]));
     }
   },
   refreshUpdateStatus: function UM_refreshUpdateStatus(update) {
     var updateSucceeded = true;
     var status = readStatusFile(getUpdatesDir());
     var ary = status.split(":");
     update.state = ary[0];
     if (update.state == STATE_FAILED && ary[1]) {
       updateSucceeded = false;
       if (!handleUpdateFailure(update, ary[1])) {
         handleFallbackToCompleteUpdate(update, true);
       }
     }
     if (update.state == STATE_APPLIED && shouldUseService()) {
       writeStatusFile(getUpdatesDir(), update.state = STATE_APPLIED_SVC);
     }
     var um = Cc["@mozilla.org/updates/update-manager;1"].
              getService(Ci.nsIUpdateManager);
     um.saveUpdates();
     if (update.state != STATE_PENDING && update.state != STATE_PENDING_SVC) {
       // Destroy the updates directory, since we're done with it.
       // Make sure to not do this when the updater has fallen back to
       // non-staged updates.
       cleanUpUpdatesDir(updateSucceeded);
     }
     // Send an observer notification which the update wizard uses in
     // order to update its UI.
     LOG("UpdateManager:refreshUpdateStatus - Notifying observers that " +
         "the update was staged. state: " + update.state + ", status: " + status);
     Services.obs.notifyObservers(null, "update-staged", update.state);
     // Do this after *everything* else, since it will likely cause the app
     // to shut down.
 #ifdef MOZ_WIDGET_GONK
     if (update.state == STATE_APPLIED) {
       // Notify the user that an update has been staged and is ready for
       // installation (i.e. that they should restart the application). We do
       // not notify on failed update attempts.
       var prompter = Cc["@mozilla.org/updates/update-prompt;1"].
                      createInstance(Ci.nsIUpdatePrompt);
       prompter.showUpdateDownloaded(update, true);
     } else {
       releaseSDCardMountLock();
     }
 #else
     // Only prompt when the UI isn't already open.
     let windowType = getPref("getCharPref", PREF_APP_UPDATE_ALTWINDOWTYPE, null);
     if (Services.wm.getMostRecentWindow(UPDATE_WINDOW_NAME) ||
         windowType && Services.wm.getMostRecentWindow(windowType)) {
       return;
     }
     if (update.state == STATE_APPLIED || update.state == STATE_APPLIED_SVC ||
         update.state == STATE_PENDING || update.state == STATE_PENDING_SVC) {
       // Notify the user that an update has been staged and is ready for
       // installation (i.e. that they should restart the application).
       var prompter = Cc["@mozilla.org/updates/update-prompt;1"].
                      createInstance(Ci.nsIUpdatePrompt);
       prompter.showUpdateDownloaded(update, true);
     }
 #endif
   },
   classID: Components.ID("{093C2356-4843-4C65-8709-D7DBCBBE7DFB}"),
   QueryInterface: XPCOMUtils.generateQI([Ci.nsIUpdateManager, Ci.nsIObserver])
 };
 /**
  * Checker
  * Checks for new Updates
  * @constructor
  */
 function Checker() {
 }
 Checker.prototype = {
   /**
    * The XMLHttpRequest object that performs the connection.
    */
   _request  : null,
   /**
    * The nsIUpdateCheckListener callback
    */
   _callback : null,
   /**
    * The URL of the update service XML file to connect to that contains details
    * about available updates.
    */
   getUpdateURL: function UC_getUpdateURL(force) {
     this._forced = force;
     // Use the override URL if specified.
     var url = getPref("getCharPref", PREF_APP_UPDATE_URL_OVERRIDE, null);
     // Otherwise, construct the update URL from component parts.
     if (!url) {
       try {
         url = Services.prefs.getDefaultBranch(null).
               getCharPref(PREF_APP_UPDATE_URL);
       } catch (e) {
       }
     }
     if (!url || url == "") {
       LOG("Checker:getUpdateURL - update URL not defined");
       return null;
     }
     url = url.replace(/%PRODUCT%/g, Services.appinfo.name);
 #ifdef TOR_BROWSER_UPDATE
     url = url.replace(/%VERSION%/g, TOR_BROWSER_VERSION);
 #else
     url = url.replace(/%VERSION%/g, Services.appinfo.version);
 #endif
     url = url.replace(/%BUILD_ID%/g, Services.appinfo.appBuildID);
     url = url.replace(/%BUILD_TARGET%/g, Services.appinfo.OS + "_" + gABI);
     url = url.replace(/%OS_VERSION%/g, gOSVersion);
     if (/%LOCALE%/.test(url))
       url = url.replace(/%LOCALE%/g, getLocale());
     url = url.replace(/%CHANNEL%/g, UpdateChannel.get());
     url = url.replace(/%PLATFORM_VERSION%/g, Services.appinfo.platformVersion);
     url = url.replace(/%DISTRIBUTION%/g,
                       getDistributionPrefValue(PREF_APP_DISTRIBUTION));
     url = url.replace(/%DISTRIBUTION_VERSION%/g,
                       getDistributionPrefValue(PREF_APP_DISTRIBUTION_VERSION));
     url = url.replace(/%CUSTOM%/g, getPref("getCharPref", PREF_APP_UPDATE_CUSTOM, ""));
     url = url.replace(/\+/g, "%2B");
 #ifdef MOZ_WIDGET_GONK
     url = url.replace(/%PRODUCT_MODEL%/g, gProductModel);
     url = url.replace(/%B2G_VERSION%/g, getPref("getCharPref", PREF_APP_B2G_VERSION, null));
 #endif
     if (force)
       url += (url.indexOf("?") != -1 ? "&" : "?") + "force=1";
     LOG("Checker:getUpdateURL - update URL: " + url);
     return url;
   },
   /**
    * See nsIUpdateService.idl
    */
   checkForUpdates: function UC_checkForUpdates(listener, force) {
     LOG("Checker: checkForUpdates, force: " + force);
     if (!listener)
       throw Cr.NS_ERROR_NULL_POINTER;
     Services.obs.notifyObservers(null, "update-check-start", null);
     var url = this.getUpdateURL(force);
     if (!url || (!this.enabled && !force))
       return;
     this._request = Cc["@mozilla.org/xmlextras/xmlhttprequest;1"].
                     createInstance(Ci.nsISupports);
     // This is here to let unit test code override XHR
     if (this._request.wrappedJSObject) {
       this._request = this._request.wrappedJSObject;
     }
     this._request.open("GET", url, true);
     var allowNonBuiltIn = !getPref("getBoolPref",
                                    PREF_APP_UPDATE_CERT_REQUIREBUILTIN, true);
     this._request.channel.notificationCallbacks = new gCertUtils.BadCertHandler(allowNonBuiltIn);
     // Prevent the request from reading from the cache.
     this._request.channel.loadFlags |= Ci.nsIRequest.LOAD_BYPASS_CACHE;
     // Prevent the request from writing to the cache.
     this._request.channel.loadFlags |= Ci.nsIRequest.INHIBIT_CACHING;
     this._request.overrideMimeType("text/xml");
     // The Cache-Control header is only interpreted by proxies and the
     // final destination. It does not help if a resource is already
     // cached locally.
     this._request.setRequestHeader("Cache-Control", "no-cache");
     // HTTP/1.0 servers might not implement Cache-Control and
     // might only implement Pragma: no-cache
     this._request.setRequestHeader("Pragma", "no-cache");
     var self = this;
     this._request.addEventListener("error", function(event) { self.onError(event); } ,false);
     this._request.addEventListener("load", function(event) { self.onLoad(event); }, false);
     LOG("Checker:checkForUpdates - sending request to: " + url);
     this._request.send(null);
     this._callback = listener;
   },
   /**
    * Returns an array of nsIUpdate objects discovered by the update check.
    * @throws if the XML document element node name is not updates.
    */
   get _updates() {
     var updatesElement = this._request.responseXML.documentElement;
     if (!updatesElement) {
       LOG("Checker:_updates get - empty updates document?!");
       return [];
     }
     if (updatesElement.nodeName != "updates") {
       LOG("Checker:_updates get - unexpected node name!");
       throw new Error("Unexpected node name, expected: updates, got: " +
                       updatesElement.nodeName);
     }
     const ELEMENT_NODE = Ci.nsIDOMNode.ELEMENT_NODE;
     var updates = [];
     for (var i = 0; i < updatesElement.childNodes.length; ++i) {
       var updateElement = updatesElement.childNodes.item(i);
       if (updateElement.nodeType != ELEMENT_NODE ||
           updateElement.localName != "update")
         continue;
       updateElement.QueryInterface(Ci.nsIDOMElement);
       try {
         var update = new Update(updateElement);
       } catch (e) {
         LOG("Checker:_updates get - invalid <update/>, ignoring...");
         continue;
       }
       update.serviceURL = this.getUpdateURL(this._forced);
       update.channel = UpdateChannel.get();
       updates.push(update);
     }
     return updates;
   },
   /**
    * Returns the status code for the XMLHttpRequest
    */
   _getChannelStatus: function UC__getChannelStatus(request) {
     var status = 0;
     try {
       status = request.status;
     }
     catch (e) {
     }
     if (status == 0)
       status = request.channel.QueryInterface(Ci.nsIRequest).status;
     return status;
   },
   _isHttpStatusCode: function UC__isHttpStatusCode(status) {
     return status >= 100 && status <= 599;
   },
   /**
    * The XMLHttpRequest succeeded and the document was loaded.
    * @param   event
    *          The nsIDOMEvent for the load
    */
   onLoad: function UC_onLoad(event) {
     LOG("Checker:onLoad - request completed downloading document");
     var prefs = Services.prefs;
     var certs = null;
     if (!prefs.prefHasUserValue(PREF_APP_UPDATE_URL_OVERRIDE) &&
         getPref("getBoolPref", PREF_APP_UPDATE_CERT_CHECKATTRS, true)) {
       certs = gCertUtils.readCertPrefs(PREF_APP_UPDATE_CERTS_BRANCH);
     }
     try {
       // Analyze the resulting DOM and determine the set of updates.
       var updates = this._updates;
       LOG("Checker:onLoad - number of updates available: " + updates.length);
       var allowNonBuiltIn = !getPref("getBoolPref",
                                      PREF_APP_UPDATE_CERT_REQUIREBUILTIN, true);
       gCertUtils.checkCert(this._request.channel, allowNonBuiltIn, certs);
       if (Services.prefs.prefHasUserValue(PREF_APP_UPDATE_CERT_ERRORS))
         Services.prefs.clearUserPref(PREF_APP_UPDATE_CERT_ERRORS);
       if (Services.prefs.prefHasUserValue(PREF_APP_UPDATE_BACKGROUNDERRORS))
         Services.prefs.clearUserPref(PREF_APP_UPDATE_BACKGROUNDERRORS);
       // Tell the callback about the updates
       this._callback.onCheckComplete(event.target, updates, updates.length);
     }
     catch (e) {
       LOG("Checker:onLoad - there was a problem checking for updates. " +
           "Exception: " + e);
       var request = event.target;
       var status = this._getChannelStatus(request);
       LOG("Checker:onLoad - request.status: " + status);
       var update = new Update(null);
       update.errorCode = status;
       update.statusText = getStatusTextFromCode(status, 404);
       if (this._isHttpStatusCode(status)) {
         update.errorCode = HTTP_ERROR_OFFSET + status;
       }
       if (e.result == Cr.NS_ERROR_ILLEGAL_VALUE) {
         update.errorCode = updates[0] ? CERT_ATTR_CHECK_FAILED_HAS_UPDATE
                                       : CERT_ATTR_CHECK_FAILED_NO_UPDATE;
       }
       this._callback.onError(request, update);
     }
     this._callback = null;
     this._request = null;
   },
   /**
    * There was an error of some kind during the XMLHttpRequest
    * @param   event
    *          The nsIDOMEvent for the error
    */
   onError: function UC_onError(event) {
     var request = event.target;
     var status = this._getChannelStatus(request);
     LOG("Checker:onError - request.status: " + status);
     // If we can't find an error string specific to this status code,
     // just use the 200 message from above, which means everything
     // "looks" fine but there was probably an XML error or a bogus file.
     var update = new Update(null);
     update.errorCode = status;
     update.statusText = getStatusTextFromCode(status, 200);
     if (status == Cr.NS_ERROR_OFFLINE) {
       // We use a separate constant here because nsIUpdate.errorCode is signed
       update.errorCode = NETWORK_ERROR_OFFLINE;
     } else if (this._isHttpStatusCode(status)) {
       update.errorCode = HTTP_ERROR_OFFSET + status;
     }
     this._callback.onError(request, update);
     this._request = null;
   },
   /**
    * Whether or not we are allowed to do update checking.
    */
   _enabled: true,
   get enabled() {
     if (!gMetroUpdatesEnabled) {
       return false;
     }
     return getPref("getBoolPref", PREF_APP_UPDATE_ENABLED, true) &&
            gCanCheckForUpdates && hasUpdateMutex() && this._enabled;
   },
   /**
    * See nsIUpdateService.idl
    */
   stopChecking: function UC_stopChecking(duration) {
     // Always stop the current check
     if (this._request)
       this._request.abort();
     switch (duration) {
     case Ci.nsIUpdateChecker.CURRENT_SESSION:
       this._enabled = false;
       break;
     case Ci.nsIUpdateChecker.ANY_CHECKS:
       this._enabled = false;
       Services.prefs.setBoolPref(PREF_APP_UPDATE_ENABLED, this._enabled);
       break;
     }
     this._callback = null;
   },
   classID: Components.ID("{898CDC9B-E43F-422F-9CC4-2F6291B415A3}"),
   QueryInterface: XPCOMUtils.generateQI([Ci.nsIUpdateChecker])
 };
 /**
  * Manages the download of updates
  * @param   background
  *          Whether or not this downloader is operating in background
  *          update mode.
  * @param   updateService
  *          The update service that created this downloader.
  * @constructor
  */
 function Downloader(background, updateService) {
   LOG("Creating Downloader");
   this.background = background;
   this.updateService = updateService;
 }
 Downloader.prototype = {
   /**
    * The nsIUpdatePatch that we are downloading
    */
   _patch: null,
   /**
    * The nsIUpdate that we are downloading
    */
   _update: null,
   /**
    * The nsIIncrementalDownload object handling the download
    */
   _request: null,
   /**
    * Whether or not the update being downloaded is a complete replacement of
    * the user's existing installation or a patch representing the difference
    * between the new version and the previous version.
    */
   isCompleteUpdate: null,
   /**
    * Cancels the active download.
    */
   cancel: function Downloader_cancel(cancelError) {
     LOG("Downloader: cancel");
     if (cancelError === undefined) {
       cancelError = Cr.NS_BINDING_ABORTED;
     }
     if (this._request && this._request instanceof Ci.nsIRequest) {
       this._request.cancel(cancelError);
     }
     releaseSDCardMountLock();
   },
   /**
    * Whether or not a patch has been downloaded and staged for installation.
    */
   get patchIsStaged() {
     var readState = readStatusFile(getUpdatesDir());
     // Note that if we decide to download and apply new updates after another
     // update has been successfully applied in the background, we need to stop
     // checking for the APPLIED state here.
     return readState == STATE_PENDING || readState == STATE_PENDING_SVC ||
            readState == STATE_APPLIED || readState == STATE_APPLIED_SVC;
   },
   /**
    * Verify the downloaded file.  We assume that the download is complete at
    * this point.
    */
   _verifyDownload: function Downloader__verifyDownload() {
     LOG("Downloader:_verifyDownload called");
     if (!this._request)
       return false;
     var destination = this._request.destination;
     // Ensure that the file size matches the expected file size.
     if (destination.fileSize != this._patch.size) {
       LOG("Downloader:_verifyDownload downloaded size != expected size.");
       return false;
     }
     LOG("Downloader:_verifyDownload downloaded size == expected size.");
     var fileStream = Cc["@mozilla.org/network/file-input-stream;1"].
                      createInstance(Ci.nsIFileInputStream);
     fileStream.init(destination, FileUtils.MODE_RDONLY, FileUtils.PERMS_FILE, 0);
     try {
       var hash = Cc["@mozilla.org/security/hash;1"].
                  createInstance(Ci.nsICryptoHash);
       var hashFunction = Ci.nsICryptoHash[this._patch.hashFunction.toUpperCase()];
       if (hashFunction == undefined)
         throw Cr.NS_ERROR_UNEXPECTED;
       hash.init(hashFunction);
       hash.updateFromStream(fileStream, -1);
       // NOTE: For now, we assume that the format of _patch.hashValue is hex
       // encoded binary (such as what is typically output by programs like
       // sha1sum).  In the future, this may change to base64 depending on how
       // we choose to compute these hashes.
       digest = binaryToHex(hash.finish(false));
     } catch (e) {
       LOG("Downloader:_verifyDownload - failed to compute hash of the " +
           "downloaded update archive");
       digest = "";
     }
     fileStream.close();
     if (digest == this._patch.hashValue.toLowerCase()) {
       LOG("Downloader:_verifyDownload hashes match.");
       return true;
     }
     LOG("Downloader:_verifyDownload hashes do not match. ");
     return false;
   },
   /**
    * Select the patch to use given the current state of updateDir and the given
    * set of update patches.
    * @param   update
    *          A nsIUpdate object to select a patch from
    * @param   updateDir
    *          A nsIFile representing the update directory
    * @return  A nsIUpdatePatch object to download
    */
   _selectPatch: function Downloader__selectPatch(update, updateDir) {
     // Given an update to download, we will always try to download the patch
     // for a partial update over the patch for a full update.
     /**
      * Return the first UpdatePatch with the given type.
      * @param   type
      *          The type of the patch ("complete" or "partial")
      * @return  A nsIUpdatePatch object matching the type specified
      */
     function getPatchOfType(type) {
       for (var i = 0; i < update.patchCount; ++i) {
         var patch = update.getPatchAt(i);
         if (patch && patch.type == type)
           return patch;
       }
       return null;
     }
     // Look to see if any of the patches in the Update object has been
     // pre-selected for download, otherwise we must figure out which one
     // to select ourselves.
     var selectedPatch = update.selectedPatch;
     var state = readStatusFile(updateDir);
     // If this is a patch that we know about, then select it.  If it is a patch
     // that we do not know about, then remove it and use our default logic.
     var useComplete = false;
     if (selectedPatch) {
       LOG("Downloader:_selectPatch - found existing patch with state: " +
           state);
       switch (state) {
       case STATE_DOWNLOADING:
         LOG("Downloader:_selectPatch - resuming download");
         return selectedPatch;
 #ifdef MOZ_WIDGET_GONK
       case STATE_PENDING:
       case STATE_APPLYING:
         LOG("Downloader:_selectPatch - resuming interrupted apply");
         return selectedPatch;
       case STATE_APPLIED:
         LOG("Downloader:_selectPatch - already downloaded and staged");
         return null;
 #else
       case STATE_PENDING_SVC:
       case STATE_PENDING:
         LOG("Downloader:_selectPatch - already downloaded and staged");
         return null;
 #endif
       default:
         // Something went wrong when we tried to apply the previous patch.
         // Try the complete patch next time.
         if (update && selectedPatch.type == "partial") {
           useComplete = true;
         } else {
           // This is a pretty fatal error.  Just bail.
           LOG("Downloader:_selectPatch - failed to apply complete patch!");
           writeStatusFile(updateDir, STATE_NONE);
           writeVersionFile(getUpdatesDir(), null);
           return null;
         }
       }
       selectedPatch = null;
     }
     // If we were not able to discover an update from a previous download, we
     // select the best patch from the given set.
     var partialPatch = getPatchOfType("partial");
     if (!useComplete)
       selectedPatch = partialPatch;
     if (!selectedPatch) {
       if (partialPatch)
         partialPatch.selected = false;
       selectedPatch = getPatchOfType("complete");
     }
     // Restore the updateDir since we may have deleted it.
     updateDir = getUpdatesDir();
     // if update only contains a partial patch, selectedPatch == null here if
     // the partial patch has been attempted and fails and we're trying to get a
     // complete patch
     if (selectedPatch)
       selectedPatch.selected = true;
     update.isCompleteUpdate = useComplete;
     // Reset the Active Update object on the Update Manager and flush the
     // Active Update DB.
     var um = Cc["@mozilla.org/updates/update-manager;1"].
              getService(Ci.nsIUpdateManager);
     um.activeUpdate = update;
     return selectedPatch;
   },
   /**
    * Whether or not we are currently downloading something.
    */
   get isBusy() {
     return this._request != null;
   },
   /**
    * Get the nsIFile to use for downloading the active update's selected patch
    */
   _getUpdateArchiveFile: function Downloader__getUpdateArchiveFile() {
     var updateArchive;
 #ifdef USE_UPDATE_ARCHIVE_DIR
     try {
       updateArchive = FileUtils.getDir(KEY_UPDATE_ARCHIVE_DIR, [], true);
     } catch (e) {
       return null;
     }
 #else
     updateArchive = getUpdatesDir().clone();
 #endif
     updateArchive.append(FILE_UPDATE_ARCHIVE);
     return updateArchive;
   },
   /**
    * Download and stage the given update.
    * @param   update
    *          A nsIUpdate object to download a patch for. Cannot be null.
    */
   downloadUpdate: function Downloader_downloadUpdate(update) {
     LOG("UpdateService:_downloadUpdate");
     if (!update)
       throw Cr.NS_ERROR_NULL_POINTER;
     var updateDir = getUpdatesDir();
     this._update = update;
     // This function may return null, which indicates that there are no patches
     // to download.
     this._patch = this._selectPatch(update, updateDir);
     if (!this._patch) {
       LOG("Downloader:downloadUpdate - no patch to download");
       return readStatusFile(updateDir);
     }
     this.isCompleteUpdate = this._patch.type == "complete";
     var patchFile = null;
 #ifdef MOZ_WIDGET_GONK
     let status = readStatusFile(updateDir);
     if (isInterruptedUpdate(status)) {
       LOG("Downloader:downloadUpdate - interruptted update");
       // The update was interrupted. Try to locate the existing patch file.
       // For an interrupted download, this allows a resume rather than a
       // re-download.
       patchFile = getFileFromUpdateLink(updateDir);
       if (!patchFile) {
         // No link file. We'll just assume that the update.mar is in the
         // update directory.
         patchFile = updateDir.clone();
         patchFile.append(FILE_UPDATE_ARCHIVE);
       }
       if (patchFile.exists()) {
         LOG("Downloader:downloadUpdate - resuming with patchFile " + patchFile.path);
         if (patchFile.fileSize == this._patch.size) {
           LOG("Downloader:downloadUpdate - patchFile appears to be fully downloaded");
           // Bump the status along so that we don't try to redownload again.
           status = STATE_PENDING;
         }
       } else {
         LOG("Downloader:downloadUpdate - patchFile " + patchFile.path +
             " doesn't exist - performing full download");
         // The patchfile doesn't exist, we might as well treat this like
         // a new download.
         patchFile = null;
       }
       if (patchFile && (status != STATE_DOWNLOADING)) {
         // It looks like the patch was downloaded, but got interrupted while it
         // was being verified or applied. So we'll fake the downloading portion.
         writeStatusFile(updateDir, STATE_PENDING);
         // Since the code expects the onStopRequest callback to happen
         // asynchronously (And you have to call AUS_addDownloadListener
         // after calling AUS_downloadUpdate) we need to defer this.
         this._downloadTimer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer);
         this._downloadTimer.initWithCallback(function() {
           this._downloadTimer = null;
           // Send a fake onStopRequest. Filling in the destination allows
           // _verifyDownload to work, and then the update will be applied.
           this._request = {destination: patchFile};
           this.onStopRequest(this._request, null, Cr.NS_OK);
         }.bind(this), 0, Ci.nsITimer.TYPE_ONE_SHOT);
         // Returning STATE_DOWNLOADING makes UpdatePrompt think we're
         // downloading. The onStopRequest that we spoofed above will make it
         // look like the download finished.
         return STATE_DOWNLOADING;
       }
     }
 #endif
     if (!patchFile) {
       // Find a place to put the patchfile that we're going to download.
       patchFile = this._getUpdateArchiveFile();
     }
     if (!patchFile) {
       return STATE_NONE;
     }
 #ifdef MOZ_WIDGET_GONK
     if (patchFile.path.indexOf(updateDir.path) != 0) {
       // The patchFile is in a directory which is different from the
       // updateDir, create a link file.
       writeLinkFile(updateDir, patchFile);
       if (!isInterruptedUpdate(status) && patchFile.exists()) {
         // Remove stale patchFile
         patchFile.remove(false);
       }
     }
 #endif
     var uri = Services.io.newURI(this._patch.URL, null, null);
     this._request = Cc["@mozilla.org/network/incremental-download;1"].
                     createInstance(Ci.nsIIncrementalDownload);
     LOG("Downloader:downloadUpdate - downloading from " + uri.spec + " to " +
         patchFile.path);
     var interval = this.background ? getPref("getIntPref",
                                              PREF_APP_UPDATE_BACKGROUND_INTERVAL,
                                              DOWNLOAD_BACKGROUND_INTERVAL)
                                    : DOWNLOAD_FOREGROUND_INTERVAL;
     this._request.init(uri, patchFile, DOWNLOAD_CHUNK_SIZE, interval);
     this._request.start(this, null);
     writeStatusFile(updateDir, STATE_DOWNLOADING);
     this._patch.QueryInterface(Ci.nsIWritablePropertyBag);
     this._patch.state = STATE_DOWNLOADING;
     var um = Cc["@mozilla.org/updates/update-manager;1"].
              getService(Ci.nsIUpdateManager);
     um.saveUpdates();
     return STATE_DOWNLOADING;
   },
   /**
    * An array of download listeners to notify when we receive
    * nsIRequestObserver or nsIProgressEventSink method calls.
    */
   _listeners: [],
   /**
    * Adds a listener to the download process
    * @param   listener
    *          A download listener, implementing nsIRequestObserver and
    *          nsIProgressEventSink
    */
   addDownloadListener: function Downloader_addDownloadListener(listener) {
     for (var i = 0; i < this._listeners.length; ++i) {
       if (this._listeners[i] == listener)
         return;
     }
     this._listeners.push(listener);
   },
   /**
    * Removes a download listener
    * @param   listener
    *          The listener to remove.
    */
   removeDownloadListener: function Downloader_removeDownloadListener(listener) {
     for (var i = 0; i < this._listeners.length; ++i) {
       if (this._listeners[i] == listener) {
         this._listeners.splice(i, 1);
         return;
       }
     }
   },
   /**
    * When the async request begins
    * @param   request
    *          The nsIRequest object for the transfer
    * @param   context
    *          Additional data
    */
   onStartRequest: function Downloader_onStartRequest(request, context) {
     if (request instanceof Ci.nsIIncrementalDownload)
       LOG("Downloader:onStartRequest - original URI spec: " + request.URI.spec +
           ", final URI spec: " + request.finalURI.spec);
     // Always set finalURL in onStartRequest since it can change.
     this._patch.finalURL = request.finalURI.spec;
     var um = Cc["@mozilla.org/updates/update-manager;1"].
              getService(Ci.nsIUpdateManager);
     um.saveUpdates();
     var listeners = this._listeners.concat();
     var listenerCount = listeners.length;
     for (var i = 0; i < listenerCount; ++i)
       listeners[i].onStartRequest(request, context);
   },
   /**
    * When new data has been downloaded
    * @param   request
    *          The nsIRequest object for the transfer
    * @param   context
    *          Additional data
    * @param   progress
    *          The current number of bytes transferred
    * @param   maxProgress
    *          The total number of bytes that must be transferred
    */
   onProgress: function Downloader_onProgress(request, context, progress,
                                              maxProgress) {
     LOG("Downloader:onProgress - progress: " + progress + "/" + maxProgress);
     if (progress > this._patch.size) {
       LOG("Downloader:onProgress - progress: " + progress +
           " is higher than patch size: " + this._patch.size);
       // It's important that we use a different code than
       // NS_ERROR_CORRUPTED_CONTENT so that tests can verify the difference
       // between a hash error and a wrong download error.
       this.cancel(Cr.NS_ERROR_UNEXPECTED);
       return;
     }
     if (maxProgress != this._patch.size) {
       LOG("Downloader:onProgress - maxProgress: " + maxProgress +
           " is not equal to expectd patch size: " + this._patch.size);
       // It's important that we use a different code than
       // NS_ERROR_CORRUPTED_CONTENT so that tests can verify the difference
       // between a hash error and a wrong download error.
       this.cancel(Cr.NS_ERROR_UNEXPECTED);
       return;
     }
     var listeners = this._listeners.concat();
     var listenerCount = listeners.length;
     for (var i = 0; i < listenerCount; ++i) {
       var listener = listeners[i];
       if (listener instanceof Ci.nsIProgressEventSink)
         listener.onProgress(request, context, progress, maxProgress);
     }
     this.updateService._consecutiveSocketErrors = 0;
   },
   /**
    * When we have new status text
    * @param   request
    *          The nsIRequest object for the transfer
    * @param   context
    *          Additional data
    * @param   status
    *          A status code
    * @param   statusText
    *          Human readable version of |status|
    */
   onStatus: function Downloader_onStatus(request, context, status, statusText) {
     LOG("Downloader:onStatus - status: " + status + ", statusText: " +
         statusText);
     var listeners = this._listeners.concat();
     var listenerCount = listeners.length;
     for (var i = 0; i < listenerCount; ++i) {
       var listener = listeners[i];
       if (listener instanceof Ci.nsIProgressEventSink)
         listener.onStatus(request, context, status, statusText);
     }
   },
   /**
    * When data transfer ceases
    * @param   request
    *          The nsIRequest object for the transfer
    * @param   context
    *          Additional data
    * @param   status
    *          Status code containing the reason for the cessation.
    */
   onStopRequest: function  Downloader_onStopRequest(request, context, status) {
     if (request instanceof Ci.nsIIncrementalDownload)
       LOG("Downloader:onStopRequest - original URI spec: " + request.URI.spec +
           ", final URI spec: " + request.finalURI.spec + ", status: " + status);
     // XXX ehsan shouldShowPrompt should always be false here.
     // But what happens when there is already a UI showing?
     var state = this._patch.state;
     var shouldShowPrompt = false;
     var shouldRegisterOnlineObserver = false;
     var shouldRetrySoon = false;
     var deleteActiveUpdate = false;
     var retryTimeout = getPref("getIntPref", PREF_APP_UPDATE_RETRY_TIMEOUT,
                                DEFAULT_UPDATE_RETRY_TIMEOUT);
     var maxFail = getPref("getIntPref", PREF_APP_UPDATE_SOCKET_ERRORS,
                           DEFAULT_SOCKET_MAX_ERRORS);
     LOG("Downloader:onStopRequest - status: " + status + ", " +
         "current fail: " + this.updateService._consecutiveSocketErrors + ", " +
         "max fail: " + maxFail + ", " + "retryTimeout: " + retryTimeout);
     if (Components.isSuccessCode(status)) {
       if (this._verifyDownload()) {
         state = shouldUseService() ? STATE_PENDING_SVC : STATE_PENDING;
         if (this.background) {
           shouldShowPrompt = !getCanStageUpdates();
         }
         // Tell the updater.exe we're ready to apply.
         writeStatusFile(getUpdatesDir(), state);
         writeVersionFile(getUpdatesDir(), this._update.appVersion);
         this._update.installDate = (new Date()).getTime();
         this._update.statusText = gUpdateBundle.GetStringFromName("installPending");
       }
       else {
         LOG("Downloader:onStopRequest - download verification failed");
         state = STATE_DOWNLOAD_FAILED;
         status = Cr.NS_ERROR_CORRUPTED_CONTENT;
         // Yes, this code is a string.
         const vfCode = "verification_failed";
         var message = getStatusTextFromCode(vfCode, vfCode);
         this._update.statusText = message;
         if (this._update.isCompleteUpdate || this._update.patchCount != 2)
           deleteActiveUpdate = true;
         // Destroy the updates directory, since we're done with it.
         cleanUpUpdatesDir();
       }
     } else if (status == Cr.NS_ERROR_OFFLINE) {
       // Register an online observer to try again.
       // The online observer will continue the incremental download by
       // calling downloadUpdate on the active update which continues
       // downloading the file from where it was.
       LOG("Downloader:onStopRequest - offline, register online observer: true");
       shouldRegisterOnlineObserver = true;
       deleteActiveUpdate = false;
     // Each of NS_ERROR_NET_TIMEOUT, ERROR_CONNECTION_REFUSED, and
     // NS_ERROR_NET_RESET can be returned when disconnecting the internet while
     // a download of a MAR is in progress.  There may be others but I have not
     // encountered them during testing.
     } else if ((status == Cr.NS_ERROR_NET_TIMEOUT ||
                 status == Cr.NS_ERROR_CONNECTION_REFUSED ||
                 status == Cr.NS_ERROR_NET_RESET) &&
                this.updateService._consecutiveSocketErrors < maxFail) {
       LOG("Downloader:onStopRequest - socket error, shouldRetrySoon: true");
       shouldRetrySoon = true;
       deleteActiveUpdate = false;
     } else if (status != Cr.NS_BINDING_ABORTED &&
                status != Cr.NS_ERROR_ABORT &&
                status != Cr.NS_ERROR_DOCUMENT_NOT_CACHED) {
       LOG("Downloader:onStopRequest - non-verification failure");
       // Some sort of other failure, log this in the |statusText| property
       state = STATE_DOWNLOAD_FAILED;
       // XXXben - if |request| (The Incremental Download) provided a means
       // for accessing the http channel we could do more here.
       this._update.statusText = getStatusTextFromCode(status,
                                                       Cr.NS_BINDING_FAILED);
 #ifdef MOZ_WIDGET_GONK
       // bug891009: On FirefoxOS, manaully retry OTA download will reuse
       // the Update object. We need to remove selected patch so that download
       // can be triggered again successfully.
       this._update.selectedPatch.selected = false;
 #endif
       // Destroy the updates directory, since we're done with it.
       cleanUpUpdatesDir();
       deleteActiveUpdate = true;
     }
     LOG("Downloader:onStopRequest - setting state to: " + state);
     this._patch.state = state;
     var um = Cc["@mozilla.org/updates/update-manager;1"].
              getService(Ci.nsIUpdateManager);
     if (deleteActiveUpdate) {
       this._update.installDate = (new Date()).getTime();
       um.activeUpdate = null;
     }
     else {
       if (um.activeUpdate)
         um.activeUpdate.state = state;
     }
     um.saveUpdates();
     // Only notify listeners about the stopped state if we
     // aren't handling an internal retry.
     if (!shouldRetrySoon && !shouldRegisterOnlineObserver) {
       var listeners = this._listeners.concat();
       var listenerCount = listeners.length;
       for (var i = 0; i < listenerCount; ++i) {
         listeners[i].onStopRequest(request, context, status);
       }
     }
     this._request = null;
     if (state == STATE_DOWNLOAD_FAILED) {
       var allFailed = true;
       // Check if there is a complete update patch that can be downloaded.
       if (!this._update.isCompleteUpdate && this._update.patchCount == 2) {
         LOG("Downloader:onStopRequest - verification of patch failed, " +
             "downloading complete update patch");
         this._update.isCompleteUpdate = true;
         let updateStatus = this.downloadUpdate(this._update);
         if (updateStatus == STATE_NONE) {
           cleanupActiveUpdate();
         } else {
           allFailed = false;
         }
       }
       if (allFailed) {
         LOG("Downloader:onStopRequest - all update patch downloads failed");
         // If the update UI is not open (e.g. the user closed the window while
         // downloading) and if at any point this was a foreground download
         // notify the user about the error. If the update was a background
         // update there is no notification since the user won't be expecting it.
         if (!Services.wm.getMostRecentWindow(UPDATE_WINDOW_NAME)) {
           try {
             this._update.QueryInterface(Ci.nsIWritablePropertyBag);
             var fgdl = this._update.getProperty("foregroundDownload");
           }
           catch (e) {
           }
           if (fgdl == "true") {
             var prompter = Cc["@mozilla.org/updates/update-prompt;1"].
                            createInstance(Ci.nsIUpdatePrompt);
             prompter.showUpdateError(this._update);
           }
         }
 #ifdef MOZ_WIDGET_GONK
         // We always forward errors in B2G, since Gaia controls the update UI
         var prompter = Cc["@mozilla.org/updates/update-prompt;1"].
                        createInstance(Ci.nsIUpdatePrompt);
         prompter.showUpdateError(this._update);
 #endif
         // Prevent leaking the update object (bug 454964).
         this._update = null;
       }
       // A complete download has been initiated or the failure was handled.
       return;
     }
     if (state == STATE_PENDING || state == STATE_PENDING_SVC) {
       if (getCanStageUpdates()) {
         LOG("Downloader:onStopRequest - attempting to stage update: " +
             this._update.name);
         // Initiate the update in the background
         try {
           Cc["@mozilla.org/updates/update-processor;1"].
             createInstance(Ci.nsIUpdateProcessor).
             processUpdate(this._update);
         } catch (e) {
           // Fail gracefully in case the application does not support the update
           // processor service.
           LOG("Downloader:onStopRequest - failed to stage update. Exception: " +
               e);
           if (this.background) {
             shouldShowPrompt = true;
           }
         }
       }
     }
     // Do this after *everything* else, since it will likely cause the app
     // to shut down.
     if (shouldShowPrompt) {
       // Notify the user that an update has been downloaded and is ready for
       // installation (i.e. that they should restart the application). We do
       // not notify on failed update attempts.
       var prompter = Cc["@mozilla.org/updates/update-prompt;1"].
                      createInstance(Ci.nsIUpdatePrompt);
       prompter.showUpdateDownloaded(this._update, true);
     }
     if (shouldRegisterOnlineObserver) {
       LOG("Downloader:onStopRequest - Registering online observer");
       this.updateService._registerOnlineObserver();
     } else if (shouldRetrySoon) {
       LOG("Downloader:onStopRequest - Retrying soon");
       this.updateService._consecutiveSocketErrors++;
       if (this.updateService._retryTimer) {
         this.updateService._retryTimer.cancel();
       }
       this.updateService._retryTimer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer);
       this.updateService._retryTimer.initWithCallback(function() {
         this._attemptResume();
       }.bind(this.updateService), retryTimeout, Ci.nsITimer.TYPE_ONE_SHOT);
     } else {
       // Prevent leaking the update object (bug 454964)
       this._update = null;
     }
   },
   /**
    * See nsIInterfaceRequestor.idl
    */
   getInterface: function Downloader_getInterface(iid) {
     // The network request may require proxy authentication, so provide the
     // default nsIAuthPrompt if requested.
     if (iid.equals(Ci.nsIAuthPrompt)) {
       var prompt = Cc["@mozilla.org/network/default-auth-prompt;1"].
                    createInstance();
       return prompt.QueryInterface(iid);
     }
     throw Cr.NS_NOINTERFACE;
   },
   QueryInterface: XPCOMUtils.generateQI([Ci.nsIRequestObserver,
                                          Ci.nsIProgressEventSink,
                                          Ci.nsIInterfaceRequestor])
 };
 /**
  * UpdatePrompt
  * An object which can prompt the user with information about updates, request
  * action, etc. Embedding clients can override this component with one that
  * invokes a native front end.
  * @constructor
  */
 function UpdatePrompt() {
 }
 UpdatePrompt.prototype = {
   /**
    * See nsIUpdateService.idl
    */
   checkForUpdates: function UP_checkForUpdates() {
     if (this._getAltUpdateWindow())
       return;
     this._showUI(null, URI_UPDATE_PROMPT_DIALOG, null, UPDATE_WINDOW_NAME,
                  null, null);
   },
   /**
    * See nsIUpdateService.idl
    */
   showUpdateAvailable: function UP_showUpdateAvailable(update) {
     if (getPref("getBoolPref", PREF_APP_UPDATE_SILENT, false) ||
         this._getUpdateWindow() || this._getAltUpdateWindow())
       return;
     var stringsPrefix = "updateAvailable_" + update.type + ".";
     var title = gUpdateBundle.formatStringFromName(stringsPrefix + "title",
                                                    [update.name], 1);
     var text = gUpdateBundle.GetStringFromName(stringsPrefix + "text");
     var imageUrl = "";
     this._showUnobtrusiveUI(null, URI_UPDATE_PROMPT_DIALOG, null,
                            UPDATE_WINDOW_NAME, "updatesavailable", update,
                            title, text, imageUrl);
   },
   /**
    * See nsIUpdateService.idl
    */
   showUpdateDownloaded: function UP_showUpdateDownloaded(update, background) {
     if (this._getAltUpdateWindow())
       return;
     if (background) {
       if (getPref("getBoolPref", PREF_APP_UPDATE_SILENT, false))
         return;
       var stringsPrefix = "updateDownloaded_" + update.type + ".";
       var title = gUpdateBundle.formatStringFromName(stringsPrefix + "title",
                                                      [update.name], 1);
       var text = gUpdateBundle.GetStringFromName(stringsPrefix + "text");
       var imageUrl = "";
       this._showUnobtrusiveUI(null, URI_UPDATE_PROMPT_DIALOG, null,
                               UPDATE_WINDOW_NAME, "finishedBackground", update,
                               title, text, imageUrl);
     } else {
       this._showUI(null, URI_UPDATE_PROMPT_DIALOG, null,
                    UPDATE_WINDOW_NAME, "finishedBackground", update);
     }
   },
   /**
    * See nsIUpdateService.idl
    */
   showUpdateInstalled: function UP_showUpdateInstalled() {
     if (getPref("getBoolPref", PREF_APP_UPDATE_SILENT, false) ||
         !getPref("getBoolPref", PREF_APP_UPDATE_SHOW_INSTALLED_UI, false) ||
         this._getUpdateWindow())
       return;
     var page = "installed";
     var win = this._getUpdateWindow();
     if (win) {
       if (page && "setCurrentPage" in win)
         win.setCurrentPage(page);
       win.focus();
     }
     else {
       var openFeatures = "chrome,centerscreen,dialog=no,resizable=no,titlebar,toolbar=no";
       var arg = Cc["@mozilla.org/supports-string;1"].
                 createInstance(Ci.nsISupportsString);
       arg.data = page;
       Services.ww.openWindow(null, URI_UPDATE_PROMPT_DIALOG, null, openFeatures, arg);
     }
   },
   /**
    * See nsIUpdateService.idl
    */
   showUpdateError: function UP_showUpdateError(update) {
     if (getPref("getBoolPref", PREF_APP_UPDATE_SILENT, false) ||
         this._getAltUpdateWindow())
       return;
     // In some cases, we want to just show a simple alert dialog:
     if (update.state == STATE_FAILED &&
         (update.errorCode == WRITE_ERROR ||
          update.errorCode == WRITE_ERROR_ACCESS_DENIED ||
          update.errorCode == WRITE_ERROR_SHARING_VIOLATION_SIGNALED ||
          update.errorCode == WRITE_ERROR_SHARING_VIOLATION_NOPROCESSFORPID ||
          update.errorCode == WRITE_ERROR_SHARING_VIOLATION_NOPID ||
          update.errorCode == WRITE_ERROR_CALLBACK_APP ||
          update.errorCode == FILESYSTEM_MOUNT_READWRITE_ERROR ||
          update.errorCode == FOTA_GENERAL_ERROR ||
          update.errorCode == FOTA_FILE_OPERATION_ERROR ||
          update.errorCode == FOTA_RECOVERY_ERROR ||
          update.errorCode == FOTA_UNKNOWN_ERROR)) {
       var title = gUpdateBundle.GetStringFromName("updaterIOErrorTitle");
       var text = gUpdateBundle.formatStringFromName("updaterIOErrorMsg",
                                                     [Services.appinfo.name,
                                                      Services.appinfo.name], 2);
       Services.ww.getNewPrompter(null).alert(title, text);
       return;
     }
     if (update.errorCode == CERT_ATTR_CHECK_FAILED_NO_UPDATE ||
         update.errorCode == CERT_ATTR_CHECK_FAILED_HAS_UPDATE ||
         update.errorCode == BACKGROUNDCHECK_MULTIPLE_FAILURES) {
       this._showUIWhenIdle(null, URI_UPDATE_PROMPT_DIALOG, null,
                            UPDATE_WINDOW_NAME, null, update);
       return;
     }
     this._showUI(null, URI_UPDATE_PROMPT_DIALOG, null, UPDATE_WINDOW_NAME,
                  "errors", update);
   },
   /**
    * See nsIUpdateService.idl
    */
   showUpdateHistory: function UP_showUpdateHistory(parent) {
     this._showUI(parent, URI_UPDATE_HISTORY_DIALOG, "modal,dialog=yes",
                  "Update:History", null, null);
   },
   /**
    * Returns the update window if present.
    */
   _getUpdateWindow: function UP__getUpdateWindow() {
     return Services.wm.getMostRecentWindow(UPDATE_WINDOW_NAME);
   },
   /**
    * Returns an alternative update window if present. When a window with this
    * windowtype is open the application update service won't open the normal
    * application update user interface window.
    */
   _getAltUpdateWindow: function UP__getAltUpdateWindow() {
     let windowType = getPref("getCharPref", PREF_APP_UPDATE_ALTWINDOWTYPE, null);
     if (!windowType)
       return null;
     return Services.wm.getMostRecentWindow(windowType);
   },
   /**
    * Initiate a less obtrusive UI, starting with a non-modal notification alert
    * @param   parent
    *          A parent window, can be null
    * @param   uri
    *          The URI string of the dialog to show
    * @param   name
    *          The Window Name of the dialog to show, in case it is already open
    *          and can merely be focused
    * @param   page
    *          The page of the wizard to be displayed, if one is already open.
    * @param   update
    *          An update to pass to the UI in the window arguments.
    *          Can be null
    * @param   title
    *          The title for the notification alert.
    * @param   text
    *          The contents of the notification alert.
    * @param   imageUrl
    *          A URL identifying the image to put in the notification alert.
    */
   _showUnobtrusiveUI: function UP__showUnobUI(parent, uri, features, name, page,
                                               update, title, text, imageUrl) {
     var observer = {
       updatePrompt: this,
       service: null,
       timer: null,
       notify: function () {
         // the user hasn't restarted yet => prompt when idle
         this.service.removeObserver(this, "quit-application");
         // If the update window is already open skip showing the UI
         if (this.updatePrompt._getUpdateWindow())
           return;
         this.updatePrompt._showUIWhenIdle(parent, uri, features, name, page, update);
       },
       observe: function (aSubject, aTopic, aData) {
         switch (aTopic) {
           case "alertclickcallback":
             this.updatePrompt._showUI(parent, uri, features, name, page, update);
             // fall thru
           case "quit-application":
             if (this.timer)
               this.timer.cancel();
             this.service.removeObserver(this, "quit-application");
             break;
         }
       }
     };
     // bug 534090 - show the UI for update available notifications when the
     // the system has been idle for at least IDLE_TIME without displaying an
     // alert notification.
     if (page == "updatesavailable") {
       var idleService = Cc["@mozilla.org/widget/idleservice;1"].
                         getService(Ci.nsIIdleService);
       const IDLE_TIME = getPref("getIntPref", PREF_APP_UPDATE_IDLETIME, 60);
       if (idleService.idleTime / 1000 >= IDLE_TIME) {
         this._showUI(parent, uri, features, name, page, update);
         return;
       }
     }
     try {
       var notifier = Cc["@mozilla.org/alerts-service;1"].
                      getService(Ci.nsIAlertsService);
       notifier.showAlertNotification(imageUrl, title, text, true, "", observer);
     }
     catch (e) {
       // Failed to retrieve alerts service, platform unsupported
       this._showUIWhenIdle(parent, uri, features, name, page, update);
       return;
     }
     observer.service = Services.obs;
     observer.service.addObserver(observer, "quit-application", false);
     // bug 534090 - show the UI when idle for update available notifications.
     if (page == "updatesavailable") {
       this._showUIWhenIdle(parent, uri, features, name, page, update);
       return;
     }
     // Give the user x seconds to react before prompting as defined by
     // promptWaitTime
     observer.timer = Cc["@mozilla.org/timer;1"].
                      createInstance(Ci.nsITimer);
     observer.timer.initWithCallback(observer, update.promptWaitTime * 1000,
                                     observer.timer.TYPE_ONE_SHOT);
   },
   /**
    * Show the UI when the user was idle
    * @param   parent
    *          A parent window, can be null
    * @param   uri
    *          The URI string of the dialog to show
    * @param   name
    *          The Window Name of the dialog to show, in case it is already open
    *          and can merely be focused
    * @param   page
    *          The page of the wizard to be displayed, if one is already open.
    * @param   update
    *          An update to pass to the UI in the window arguments.
    *          Can be null
    */
   _showUIWhenIdle: function UP__showUIWhenIdle(parent, uri, features, name,
                                                page, update) {
     var idleService = Cc["@mozilla.org/widget/idleservice;1"].
                       getService(Ci.nsIIdleService);
     const IDLE_TIME = getPref("getIntPref", PREF_APP_UPDATE_IDLETIME, 60);
     if (idleService.idleTime / 1000 >= IDLE_TIME) {
       this._showUI(parent, uri, features, name, page, update);
     } else {
       var observer = {
         updatePrompt: this,
         observe: function (aSubject, aTopic, aData) {
           switch (aTopic) {
             case "idle":
               // If the update window is already open skip showing the UI
               if (!this.updatePrompt._getUpdateWindow())
                 this.updatePrompt._showUI(parent, uri, features, name, page, update);
               // fall thru
             case "quit-application":
               idleService.removeIdleObserver(this, IDLE_TIME);
               Services.obs.removeObserver(this, "quit-application");
               break;
           }
         }
       };
       idleService.addIdleObserver(observer, IDLE_TIME);
       Services.obs.addObserver(observer, "quit-application", false);
     }
   },
   /**
    * Show the Update Checking UI
    * @param   parent
    *          A parent window, can be null
    * @param   uri
    *          The URI string of the dialog to show
    * @param   name
    *          The Window Name of the dialog to show, in case it is already open
    *          and can merely be focused
    * @param   page
    *          The page of the wizard to be displayed, if one is already open.
    * @param   update
    *          An update to pass to the UI in the window arguments.
    *          Can be null
    */
   _showUI: function UP__showUI(parent, uri, features, name, page, update) {
     var ary = null;
     if (update) {
       ary = Cc["@mozilla.org/supports-array;1"].
             createInstance(Ci.nsISupportsArray);
       ary.AppendElement(update);
     }
     var win = this._getUpdateWindow();
     if (win) {
       if (page && "setCurrentPage" in win)
         win.setCurrentPage(page);
       win.focus();
     }
     else {
       var openFeatures = "chrome,centerscreen,dialog=no,resizable=no,titlebar,toolbar=no";
       if (features)
         openFeatures += "," + features;
       Services.ww.openWindow(parent, uri, "", openFeatures, ary);
     }
   },
   classDescription: "Update Prompt",
   contractID: "@mozilla.org/updates/update-prompt;1",
   classID: Components.ID("{27ABA825-35B5-4018-9FDD-F99250A0E722}"),
   QueryInterface: XPCOMUtils.generateQI([Ci.nsIUpdatePrompt])
 };
 var components = [UpdateService, Checker, UpdatePrompt, UpdateManager];
 this.NSGetFactory = XPCOMUtils.generateNSGetFactory(components);
 #if 0
 /**
  * Logs a message and stack trace to the console.
  * @param   string
  *          The string to write to the console.
  */
 function STACK(string) {
   dump("*** " + string + "\n");
   stackTrace(arguments.callee.caller.arguments, -1);
 }
 function stackTraceFunctionFormat(aFunctionName) {
   var classDelimiter = aFunctionName.indexOf("_");
   var className = aFunctionName.substr(0, classDelimiter);
   if (!className)
     className = "<global>";
   var functionName = aFunctionName.substr(classDelimiter + 1, aFunctionName.length);
   if (!functionName)
     functionName = "<anonymous>";
   return className + "::" + functionName;
 }
 function stackTraceArgumentsFormat(aArguments) {
   arglist = "";
   for (var i = 0; i < aArguments.length; i++) {
     arglist += aArguments[i];
     if (i < aArguments.length - 1)
       arglist += ", ";
   }
   return arglist;
 }
 function stackTrace(aArguments, aMaxCount) {
   dump("=[STACKTRACE]=====================================================\n");
   dump("*** at: " + stackTraceFunctionFormat(aArguments.callee.name) + "(" +
        stackTraceArgumentsFormat(aArguments) + ")\n");
   var temp = aArguments.callee.caller;
   var count = 0;
   while (temp) {
     dump("***     " + stackTraceFunctionFormat(temp.name) + "(" +
          stackTraceArgumentsFormat(temp.arguments) + ")\n");
     temp = temp.arguments.callee.caller;
     if (aMaxCount > 0 && ++count == aMaxCount)
       break;
   }
   dump("==================================================================\n");
 }
 function dumpFile(file) {
   dump("*** file = " + file.path + ", exists = " + file.exists() + "\n");
 }
 #endif