The Tor Browser / file revision

 #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,

                           10);

     }

     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) {