diff --git a/toolkit/mozapps/update/tests/TestAUSHelper.cpp b/toolkit/mozapps/update/tests/TestAUSHelper.cpp
index 8d207a742597..e3c5d40af127 100644
--- a/toolkit/mozapps/update/tests/TestAUSHelper.cpp
+++ b/toolkit/mozapps/update/tests/TestAUSHelper.cpp
@@ -327,6 +327,16 @@ int NS_main(int argc, NS_tchar **argv)
 #endif
   }
 
+  if (!NS_tstrcmp(argv[1], NS_T("is-process-running"))) {
+#ifdef XP_WIN
+    LPCWSTR application = argv[2];
+    return (ERROR_NOT_FOUND == IsProcessRunning(application)) ? 0 : 1;
+#else
+    // Not implemented on non-Windows platforms
+    return 1;
+#endif
+  }
+
   if (NS_tchdir(argv[1]) != 0) {
     return 1;
   }
diff --git a/toolkit/mozapps/update/tests/chrome/test_0111_neverButton_basic.xul b/toolkit/mozapps/update/tests/chrome/test_0111_neverButton_basic.xul
index c3b2fdfa8250..3851a0982ca7 100644
--- a/toolkit/mozapps/update/tests/chrome/test_0111_neverButton_basic.xul
+++ b/toolkit/mozapps/update/tests/chrome/test_0111_neverButton_basic.xul
@@ -19,7 +19,7 @@
 <script type="application/javascript">
 <![CDATA[
 
-gPrefToCheck = PREF_APP_UPDATE_NEVER_BRANCH + Services.appinfo.version;
+gPrefToCheck = PREFBRANCH_APP_UPDATE_NEVER + Services.appinfo.version;
 
 const TESTS = [ {
   pageid: PAGEID_CHECKING
diff --git a/toolkit/mozapps/update/tests/chrome/test_0112_neverButton_billboard.xul b/toolkit/mozapps/update/tests/chrome/test_0112_neverButton_billboard.xul
index e5c4184fd9b8..9f6da5b9a541 100644
--- a/toolkit/mozapps/update/tests/chrome/test_0112_neverButton_billboard.xul
+++ b/toolkit/mozapps/update/tests/chrome/test_0112_neverButton_billboard.xul
@@ -19,7 +19,7 @@
 <script type="application/javascript">
 <![CDATA[
 
-gPrefToCheck = PREF_APP_UPDATE_NEVER_BRANCH + Services.appinfo.version;
+gPrefToCheck = PREFBRANCH_APP_UPDATE_NEVER + Services.appinfo.version;
 
 const TESTS = [ {
   pageid: PAGEID_CHECKING
diff --git a/toolkit/mozapps/update/tests/chrome/test_0113_showNeverForVersionRemovedWithPref.xul b/toolkit/mozapps/update/tests/chrome/test_0113_showNeverForVersionRemovedWithPref.xul
index d641c9c3eb1d..562918adbdab 100644
--- a/toolkit/mozapps/update/tests/chrome/test_0113_showNeverForVersionRemovedWithPref.xul
+++ b/toolkit/mozapps/update/tests/chrome/test_0113_showNeverForVersionRemovedWithPref.xul
@@ -19,7 +19,7 @@
 <script type="application/javascript">
 <![CDATA[
 
-gPrefToCheck = PREF_APP_UPDATE_NEVER_BRANCH + Services.appinfo.version;
+gPrefToCheck = PREFBRANCH_APP_UPDATE_NEVER + Services.appinfo.version;
 
 const TESTS = [ {
   pageid: PAGEID_FOUND_BASIC,
diff --git a/toolkit/mozapps/update/tests/chrome/test_0121_check_requireBuiltinCert.xul b/toolkit/mozapps/update/tests/chrome/test_0121_check_requireBuiltinCert.xul
index c0aebd1c4743..b45bf36969ce 100644
--- a/toolkit/mozapps/update/tests/chrome/test_0121_check_requireBuiltinCert.xul
+++ b/toolkit/mozapps/update/tests/chrome/test_0121_check_requireBuiltinCert.xul
@@ -78,12 +78,12 @@ function testXHRLoad(aEvent) {
   let cert = channel.securityInfo.QueryInterface(Ci.nsISSLStatusProvider).
              SSLStatus.QueryInterface(Ci.nsISSLStatus).serverCert;
   CERT_ATTRS.forEach(function(aCertAttrName) {
-    Services.prefs.setCharPref(PREF_APP_UPDATE_CERTS_BRANCH + "1." +
+    Services.prefs.setCharPref(PREFBRANCH_APP_UPDATE_CERTS + "1." +
                                aCertAttrName, cert[aCertAttrName]);
   });
 
   Services.prefs.setBoolPref(PREF_APP_UPDATE_CERT_REQUIREBUILTIN, true);
-  Services.prefs.setBoolPref(PREF_APP_UPDATE_CERT_CHECKATTRS, false);
+  Services.prefs.setBoolPref(PREF_APP_UPDATE_CERT_CHECKATTRIBUTES, false);
 
   let url = URL_HTTPS_UPDATE_XML + "?showDetails=1" + getVersionParams();
   gAppUpdateURLDefault = gDefaultPrefBranch.getCharPref(PREF_APP_UPDATE_URL);
diff --git a/toolkit/mozapps/update/tests/chrome/test_0122_check_allowNonBuiltinCert_validCertAttrs.xul b/toolkit/mozapps/update/tests/chrome/test_0122_check_allowNonBuiltinCert_validCertAttrs.xul
index a9726de8ca11..ce87f95881f2 100644
--- a/toolkit/mozapps/update/tests/chrome/test_0122_check_allowNonBuiltinCert_validCertAttrs.xul
+++ b/toolkit/mozapps/update/tests/chrome/test_0122_check_allowNonBuiltinCert_validCertAttrs.xul
@@ -78,12 +78,12 @@ function testXHRLoad(aEvent) {
   let cert = channel.securityInfo.QueryInterface(Ci.nsISSLStatusProvider).
              SSLStatus.QueryInterface(Ci.nsISSLStatus).serverCert;
   CERT_ATTRS.forEach(function(aCertAttrName) {
-    Services.prefs.setCharPref(PREF_APP_UPDATE_CERTS_BRANCH + "1." +
+    Services.prefs.setCharPref(PREFBRANCH_APP_UPDATE_CERTS + "1." +
                                aCertAttrName, cert[aCertAttrName]);
   });
 
   Services.prefs.setBoolPref(PREF_APP_UPDATE_CERT_REQUIREBUILTIN, false);
-  Services.prefs.setBoolPref(PREF_APP_UPDATE_CERT_CHECKATTRS, true);
+  Services.prefs.setBoolPref(PREF_APP_UPDATE_CERT_CHECKATTRIBUTES, true);
 
   let url = URL_HTTPS_UPDATE_XML + "?showDetails=1" + getVersionParams();
   gAppUpdateURLDefault = gDefaultPrefBranch.getCharPref(PREF_APP_UPDATE_URL);
diff --git a/toolkit/mozapps/update/tests/chrome/test_0123_check_allowNonBuiltinCert_noCertAttrsCheck.xul b/toolkit/mozapps/update/tests/chrome/test_0123_check_allowNonBuiltinCert_noCertAttrsCheck.xul
index 1356aa038ee6..70467fd74b37 100644
--- a/toolkit/mozapps/update/tests/chrome/test_0123_check_allowNonBuiltinCert_noCertAttrsCheck.xul
+++ b/toolkit/mozapps/update/tests/chrome/test_0123_check_allowNonBuiltinCert_noCertAttrsCheck.xul
@@ -35,7 +35,7 @@ function runTest() {
                              "Invalid Attribute Name");
   Services.prefs.setIntPref(PREF_APP_UPDATE_CERT_ERRORS, 1);
   Services.prefs.setBoolPref(PREF_APP_UPDATE_CERT_REQUIREBUILTIN, false);
-  Services.prefs.setBoolPref(PREF_APP_UPDATE_CERT_CHECKATTRS, false);
+  Services.prefs.setBoolPref(PREF_APP_UPDATE_CERT_CHECKATTRIBUTES, false);
 
   let url = URL_HTTPS_UPDATE_XML + "?showDetails=1" + getVersionParams();
   gAppUpdateURLDefault = gDefaultPrefBranch.getCharPref(PREF_APP_UPDATE_URL);
diff --git a/toolkit/mozapps/update/tests/chrome/test_0131_check_invalidCertAttrs_noUpdate.xul b/toolkit/mozapps/update/tests/chrome/test_0131_check_invalidCertAttrs_noUpdate.xul
index 42830783055b..f67d16928ce0 100644
--- a/toolkit/mozapps/update/tests/chrome/test_0131_check_invalidCertAttrs_noUpdate.xul
+++ b/toolkit/mozapps/update/tests/chrome/test_0131_check_invalidCertAttrs_noUpdate.xul
@@ -36,7 +36,7 @@ function runTest() {
                              "Invalid Attribute Name");
   Services.prefs.setIntPref(PREF_APP_UPDATE_CERT_ERRORS, 1);
   Services.prefs.setBoolPref(PREF_APP_UPDATE_CERT_REQUIREBUILTIN, false);
-  Services.prefs.setBoolPref(PREF_APP_UPDATE_CERT_CHECKATTRS, true);
+  Services.prefs.setBoolPref(PREF_APP_UPDATE_CERT_CHECKATTRIBUTES, true);
 
   let url = URL_HTTPS_UPDATE_XML + "?noUpdates=1";
   gAppUpdateURLDefault = gDefaultPrefBranch.getCharPref(PREF_APP_UPDATE_URL);
diff --git a/toolkit/mozapps/update/tests/chrome/test_0132_check_invalidCertAttrs_hasUpdate.xul b/toolkit/mozapps/update/tests/chrome/test_0132_check_invalidCertAttrs_hasUpdate.xul
index c70f588afd51..c93358c86e7c 100644
--- a/toolkit/mozapps/update/tests/chrome/test_0132_check_invalidCertAttrs_hasUpdate.xul
+++ b/toolkit/mozapps/update/tests/chrome/test_0132_check_invalidCertAttrs_hasUpdate.xul
@@ -36,7 +36,7 @@ function runTest() {
                              "Invalid Attribute Name");
   Services.prefs.setIntPref(PREF_APP_UPDATE_CERT_ERRORS, 1);
   Services.prefs.setBoolPref(PREF_APP_UPDATE_CERT_REQUIREBUILTIN, false);
-  Services.prefs.setBoolPref(PREF_APP_UPDATE_CERT_CHECKATTRS, true);
+  Services.prefs.setBoolPref(PREF_APP_UPDATE_CERT_CHECKATTRIBUTES, true);
 
   let url = URL_HTTPS_UPDATE_XML + "?showDetails=1" + getVersionParams();
   gAppUpdateURLDefault = gDefaultPrefBranch.getCharPref(PREF_APP_UPDATE_URL);
diff --git a/toolkit/mozapps/update/tests/chrome/test_0141_notify_invalidCertAttrs_noUpdate.xul b/toolkit/mozapps/update/tests/chrome/test_0141_notify_invalidCertAttrs_noUpdate.xul
index b8ce97e2d3cf..d45f6645dfaf 100644
--- a/toolkit/mozapps/update/tests/chrome/test_0141_notify_invalidCertAttrs_noUpdate.xul
+++ b/toolkit/mozapps/update/tests/chrome/test_0141_notify_invalidCertAttrs_noUpdate.xul
@@ -33,7 +33,7 @@ function runTest() {
   Services.prefs.setCharPref(PREF_APP_UPDATE_CERT_INVALID_ATTR_NAME,
                              "Invalid Attribute Name");
   Services.prefs.setBoolPref(PREF_APP_UPDATE_CERT_REQUIREBUILTIN, false);
-  Services.prefs.setBoolPref(PREF_APP_UPDATE_CERT_CHECKATTRS, true);
+  Services.prefs.setBoolPref(PREF_APP_UPDATE_CERT_CHECKATTRIBUTES, true);
 
   let url = URL_HTTPS_UPDATE_XML + "?noUpdates=1";
   gAppUpdateURLDefault = gDefaultPrefBranch.getCharPref(PREF_APP_UPDATE_URL);
diff --git a/toolkit/mozapps/update/tests/chrome/test_0142_notify_invalidCertAttrs_hasUpdate.xul b/toolkit/mozapps/update/tests/chrome/test_0142_notify_invalidCertAttrs_hasUpdate.xul
index 6fa4f5565ec3..4b5d866eaf70 100644
--- a/toolkit/mozapps/update/tests/chrome/test_0142_notify_invalidCertAttrs_hasUpdate.xul
+++ b/toolkit/mozapps/update/tests/chrome/test_0142_notify_invalidCertAttrs_hasUpdate.xul
@@ -33,7 +33,7 @@ function runTest() {
   Services.prefs.setCharPref(PREF_APP_UPDATE_CERT_INVALID_ATTR_NAME,
                              "Invalid Attribute Name");
   Services.prefs.setBoolPref(PREF_APP_UPDATE_CERT_REQUIREBUILTIN, false);
-  Services.prefs.setBoolPref(PREF_APP_UPDATE_CERT_CHECKATTRS, true);
+  Services.prefs.setBoolPref(PREF_APP_UPDATE_CERT_CHECKATTRIBUTES, true);
 
   let url = URL_HTTPS_UPDATE_XML + "?showDetails=1" + getVersionParams();
   gAppUpdateURLDefault = gDefaultPrefBranch.getCharPref(PREF_APP_UPDATE_URL);
diff --git a/toolkit/mozapps/update/tests/chrome/test_0171_check_noPerms_manual.xul b/toolkit/mozapps/update/tests/chrome/test_0171_check_noPerms_manual.xul
index 76946ab37c97..c6aecd160b7a 100644
--- a/toolkit/mozapps/update/tests/chrome/test_0171_check_noPerms_manual.xul
+++ b/toolkit/mozapps/update/tests/chrome/test_0171_check_noPerms_manual.xul
@@ -43,7 +43,7 @@ function runTest() {
 
 function getWriteTestFile() {
   let file = getAppBaseDir();
-  file.append(FILE_PERMS_TEST);
+  file.append(FILE_UPDATE_TEST);
   file.QueryInterface(Ci.nsILocalFileWin);
   if (file.exists()) {
     file.fileAttributesWin |= file.WFA_READWRITE;
diff --git a/toolkit/mozapps/update/tests/chrome/test_0172_notify_noPerms_manual.xul b/toolkit/mozapps/update/tests/chrome/test_0172_notify_noPerms_manual.xul
index fdbdc0feb9ca..2c26be0f86b4 100644
--- a/toolkit/mozapps/update/tests/chrome/test_0172_notify_noPerms_manual.xul
+++ b/toolkit/mozapps/update/tests/chrome/test_0172_notify_noPerms_manual.xul
@@ -42,7 +42,7 @@ function runTest() {
 
 function getWriteTestFile() {
   let file = getAppBaseDir();
-  file.append(FILE_PERMS_TEST);
+  file.append(FILE_UPDATE_TEST);
   file.QueryInterface(Ci.nsILocalFileWin);
   if (file.exists()) {
     file.fileAttributesWin |= file.WFA_READWRITE;
diff --git a/toolkit/mozapps/update/tests/chrome/test_9999_cleanup.xul b/toolkit/mozapps/update/tests/chrome/test_9999_cleanup.xul
index 3af56b2bc117..a55263eb2db3 100644
--- a/toolkit/mozapps/update/tests/chrome/test_9999_cleanup.xul
+++ b/toolkit/mozapps/update/tests/chrome/test_9999_cleanup.xul
@@ -64,7 +64,7 @@ function runTest() {
   ok(!file.exists(), file.path + " should not exist");
 
   file = dir.clone();
-  file.append(FILE_UPDATE_ARCHIVE);
+  file.append(FILE_UPDATE_MAR);
   ok(!file.exists(), file.path + " should not exist");
 
   cleanupRestoreUpdaterBackup();
diff --git a/toolkit/mozapps/update/tests/chrome/utils.js b/toolkit/mozapps/update/tests/chrome/utils.js
index b228564257cf..ac7b0c0771a3 100644
--- a/toolkit/mozapps/update/tests/chrome/utils.js
+++ b/toolkit/mozapps/update/tests/chrome/utils.js
@@ -990,6 +990,10 @@ function resetPrefs() {
     Services.prefs.clearUserPref(PREF_APP_UPDATE_LOG);
   }
 
+  if (Services.prefs.prefHasUserValue(PREF_APP_UPDATE_SILENT)) {
+    Services.prefs.clearUserPref(PREF_APP_UPDATE_SILENT);
+  }
+
   if (Services.prefs.prefHasUserValue(PREF_APP_UPDATE_CERT_ERRORS)) {
     Services.prefs.clearUserPref(PREF_APP_UPDATE_CERT_ERRORS);
   }
@@ -1014,13 +1018,13 @@ function resetPrefs() {
     Services.prefs.clearUserPref(PREF_APP_UPDATE_CERT_REQUIREBUILTIN);
   }
 
-  if (Services.prefs.prefHasUserValue(PREF_APP_UPDATE_CERT_CHECKATTRS)) {
-    Services.prefs.clearUserPref(PREF_APP_UPDATE_CERT_CHECKATTRS);
+  if (Services.prefs.prefHasUserValue(PREF_APP_UPDATE_CERT_CHECKATTRIBUTES)) {
+    Services.prefs.clearUserPref(PREF_APP_UPDATE_CERT_CHECKATTRIBUTES);
   }
 
   try {
     CERT_ATTRS.forEach(function(aCertAttrName) {
-      Services.prefs.clearUserPref(PREF_APP_UPDATE_CERTS_BRANCH + "1." +
+      Services.prefs.clearUserPref(PREFBRANCH_APP_UPDATE_CERTS + "1." +
                                    aCertAttrName);
     });
   }
@@ -1028,14 +1032,10 @@ function resetPrefs() {
   }
 
   try {
-    Services.prefs.deleteBranch(PREF_APP_UPDATE_NEVER_BRANCH);
+    Services.prefs.deleteBranch(PREFBRANCH_APP_UPDATE_NEVER);
   }
   catch(e) {
   }
-
-  if (Services.prefs.prefHasUserValue(PREF_APP_UPDATE_SILENT)) {
-    Services.prefs.clearUserPref(PREF_APP_UPDATE_SILENT);
-  }
 }
 
 function setupTimer(aTestTimeout) {
diff --git a/toolkit/mozapps/update/tests/data/shared.js b/toolkit/mozapps/update/tests/data/shared.js
index 4b829c217807..f28c6eaa00e1 100644
--- a/toolkit/mozapps/update/tests/data/shared.js
+++ b/toolkit/mozapps/update/tests/data/shared.js
@@ -7,36 +7,38 @@
 Cu.import("resource://gre/modules/FileUtils.jsm");
 Cu.import("resource://gre/modules/XPCOMUtils.jsm");
 
-const PREF_APP_UPDATE_AUTO                = "app.update.auto";
-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_CHANNEL             = "app.update.channel";
-const PREF_APP_UPDATE_ENABLED             = "app.update.enabled";
-const PREF_APP_UPDATE_IDLETIME            = "app.update.idletime";
-const PREF_APP_UPDATE_LOG                 = "app.update.log";
-const PREF_APP_UPDATE_NEVER_BRANCH        = "app.update.never.";
-const PREF_APP_UPDATE_NOTIFIEDUNSUPPORTED = "app.update.notifiedUnsupported";
-const PREF_APP_UPDATE_PROMPTWAITTIME      = "app.update.promptWaitTime";
-const PREF_APP_UPDATE_SERVICE_ENABLED     = "app.update.service.enabled";
-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_SOCKET_ERRORS       = "app.update.socket.maxErrors";
-const PREF_APP_UPDATE_RETRY_TIMEOUT       = "app.update.socket.retryTimeout";
+const PREF_APP_UPDATE_AUTO                 = "app.update.auto";
+const PREF_APP_UPDATE_BACKGROUNDERRORS     = "app.update.backgroundErrors";
+const PREF_APP_UPDATE_BACKGROUNDMAXERRORS  = "app.update.backgroundMaxErrors";
+const PREF_APP_UPDATE_CERT_CHECKATTRIBUTES = "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_CHANNEL              = "app.update.channel";
+const PREF_APP_UPDATE_ENABLED              = "app.update.enabled";
+const PREF_APP_UPDATE_IDLETIME             = "app.update.idletime";
+const PREF_APP_UPDATE_LOG                  = "app.update.log";
+const PREF_APP_UPDATE_NOTIFIEDUNSUPPORTED  = "app.update.notifiedUnsupported";
+const PREF_APP_UPDATE_PROMPTWAITTIME       = "app.update.promptWaitTime";
+const PREF_APP_UPDATE_RETRYTIMEOUT         = "app.update.socket.retryTimeout";
+const PREF_APP_UPDATE_SERVICE_ENABLED      = "app.update.service.enabled";
+const PREF_APP_UPDATE_SILENT               = "app.update.silent";
+const PREF_APP_UPDATE_SOCKET_MAXERRORS     = "app.update.socket.maxErrors";
+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_CERT_INVALID_ATTR_NAME = PREF_APP_UPDATE_CERTS_BRANCH +
+const PREFBRANCH_APP_UPDATE_CERTS = "app.update.certs.";
+const PREFBRANCH_APP_UPDATE_NEVER = "app.update.never.";
+
+const PREF_APP_UPDATE_CERT_INVALID_ATTR_NAME = PREFBRANCH_APP_UPDATE_CERTS +
                                                "1.invalidName";
 
-const PREF_APP_PARTNER_BRANCH             = "app.partner.";
-const PREF_DISTRIBUTION_ID                = "distribution.id";
-const PREF_DISTRIBUTION_VERSION           = "distribution.version";
+const PREFBRANCH_APP_PARTNER         = "app.partner.";
+const PREF_DISTRIBUTION_ID           = "distribution.id";
+const PREF_DISTRIBUTION_VERSION      = "distribution.version";
+const PREF_TOOLKIT_TELEMETRY_ENABLED = "toolkit.telemetry.enabled";
 
 const NS_APP_PROFILE_DIR_STARTUP   = "ProfDS";
 const NS_APP_USER_PROFILE_50_DIR   = "ProfD";
@@ -54,18 +56,18 @@ const DIR_TOBEDELETED  = "tobedeleted";
 const DIR_UPDATES      = "updates";
 const DIR_UPDATED      = IS_MACOSX ? "Updated.app" : "updated";
 
+const FILE_ACTIVE_UPDATE_XML         = "active-update.xml";
 const FILE_APPLICATION_INI           = "application.ini";
-const FILE_BACKUP_LOG                = "backup-update.log";
-const FILE_LAST_LOG                  = "last-update.log";
-const FILE_PERMS_TEST                = "update.test";
-const FILE_UPDATER_INI               = "updater.ini";
-const FILE_UPDATES_DB                = "updates.xml";
-const FILE_UPDATE_ACTIVE             = "active-update.xml";
-const FILE_UPDATE_ARCHIVE            = "update.mar";
-const FILE_UPDATE_LOG                = "update.log";
+const FILE_BACKUP_UPDATE_LOG         = "backup-update.log";
+const FILE_LAST_UPDATE_LOG           = "last-update.log";
 const FILE_UPDATE_SETTINGS_INI       = "update-settings.ini";
 const FILE_UPDATE_SETTINGS_INI_BAK   = "update-settings.ini.bak";
+const FILE_UPDATER_INI               = "updater.ini";
+const FILE_UPDATES_XML               = "updates.xml";
+const FILE_UPDATE_LOG                = "update.log";
+const FILE_UPDATE_MAR                = "update.mar";
 const FILE_UPDATE_STATUS             = "update.status";
+const FILE_UPDATE_TEST               = "update.test";
 const FILE_UPDATE_VERSION            = "update.version";
 
 const UPDATE_SETTINGS_CONTENTS = "[Settings]\n" +
@@ -73,10 +75,7 @@ const UPDATE_SETTINGS_CONTENTS = "[Settings]\n" +
 
 const PR_RDWR        = 0x04;
 const PR_CREATE_FILE = 0x08;
-const PR_APPEND      = 0x10;
 const PR_TRUNCATE    = 0x20;
-const PR_SYNC        = 0x40;
-const PR_EXCL        = 0x80;
 
 const DEFAULT_UPDATE_VERSION = "999999.0";
 
@@ -87,9 +86,7 @@ Services.scriptloader.loadSubScript(DATA_URI_SPEC + "sharedUpdateXML.js", this);
 const PERMS_FILE      = FileUtils.PERMS_FILE;
 const PERMS_DIRECTORY = FileUtils.PERMS_DIRECTORY;
 
-const MODE_RDONLY   = FileUtils.MODE_RDONLY;
 const MODE_WRONLY   = FileUtils.MODE_WRONLY;
-const MODE_RDWR     = FileUtils.MODE_RDWR;
 const MODE_CREATE   = FileUtils.MODE_CREATE;
 const MODE_APPEND   = FileUtils.MODE_APPEND;
 const MODE_TRUNCATE = FileUtils.MODE_TRUNCATE;
@@ -201,7 +198,7 @@ function setUpdateURLOverride(aURL) {
  */
 function getUpdatesXMLFile(aIsActiveUpdate) {
   let file = getUpdatesRootDir();
-  file.append(aIsActiveUpdate ? FILE_UPDATE_ACTIVE : FILE_UPDATES_DB);
+  file.append(aIsActiveUpdate ? FILE_ACTIVE_UPDATE_XML : FILE_UPDATES_XML);
   return file;
 }
 
@@ -349,7 +346,9 @@ function readFile(aFile) {
   if (!aFile.exists()) {
     return null;
   }
-  fis.init(aFile, MODE_RDONLY, PERMS_FILE, 0);
+  // Specifying -1 for ioFlags will open the file with the default of PR_RDONLY.
+  // Specifying -1 for perm will open the file with the default of 0.
+  fis.init(aFile, -1, -1, Ci.nsIFileInputStream.CLOSE_ON_EOF);
   let sis = Cc["@mozilla.org/scriptableinputstream;1"].
             createInstance(Ci.nsIScriptableInputStream);
   sis.init(fis);
@@ -366,9 +365,12 @@ function readFile(aFile) {
  * @return The contents of the file as a string.
  */
 function readFileBytes(aFile) {
+  debugDump("attempting to read file, path: " + aFile.path);
   let fis = Cc["@mozilla.org/network/file-input-stream;1"].
             createInstance(Ci.nsIFileInputStream);
-  fis.init(aFile, -1, -1, false);
+  // Specifying -1 for ioFlags will open the file with the default of PR_RDONLY.
+  // Specifying -1 for perm will open the file with the default of 0.
+  fis.init(aFile, -1, -1, Ci.nsIFileInputStream.CLOSE_ON_EOF);
   let bis = Cc["@mozilla.org/binaryinputstream;1"].
             createInstance(Ci.nsIBinaryInputStream);
   bis.setInputStream(fis);
diff --git a/toolkit/mozapps/update/tests/data/sharedUpdateXML.js b/toolkit/mozapps/update/tests/data/sharedUpdateXML.js
index a1fa4c3ae6e7..83cd09d47d0e 100644
--- a/toolkit/mozapps/update/tests/data/sharedUpdateXML.js
+++ b/toolkit/mozapps/update/tests/data/sharedUpdateXML.js
@@ -40,7 +40,6 @@ const STATE_FAILED_READ_ERROR                  = STATE_FAILED + ": 6";
 const STATE_FAILED_WRITE_ERROR                 = STATE_FAILED + ": 7";
 const STATE_FAILED_CHANNEL_MISMATCH_ERROR      = STATE_FAILED + ": 22";
 const STATE_FAILED_VERSION_DOWNGRADE_ERROR     = STATE_FAILED + ": 23";
-const STATE_FAILED_WRITE_ERROR_FILE_COPY       = STATE_FAILED + ": 61";
 
 /**
  * Constructs a string representing a remote update xml file.
diff --git a/toolkit/mozapps/update/tests/data/xpcshellUtilsAUS.js b/toolkit/mozapps/update/tests/data/xpcshellUtilsAUS.js
index dc7c1bbc8f50..298b8202b836 100644
--- a/toolkit/mozapps/update/tests/data/xpcshellUtilsAUS.js
+++ b/toolkit/mozapps/update/tests/data/xpcshellUtilsAUS.js
@@ -35,21 +35,42 @@ const { classes: Cc, interfaces: Ci, manager: Cm, results: Cr,
 
 load("../data/xpcshellConstantsPP.js");
 
+function getLogSuffix() {
+  if (IS_WIN) {
+    return "_win";
+  }
+  if (IS_MACOSX) {
+    return "_mac";
+  }
+  if (IS_TOOLKIT_GONK) {
+    return "_gonk";
+  }
+  return "_linux";
+}
+
 Cu.import("resource://gre/modules/Services.jsm", this);
 Cu.import("resource://gre/modules/ctypes.jsm", this);
 
 const DIR_MACOS = IS_MACOSX ? "Contents/MacOS/" : "";
 const DIR_RESOURCES = IS_MACOSX ? "Contents/Resources/" : "";
-const TEST_FILE_SUFFIX =  IS_MACOSX ? "_mac" : "";
+const TEST_FILE_SUFFIX = IS_MACOSX ? "_mac" : "";
 const FILE_COMPLETE_MAR = "complete" + TEST_FILE_SUFFIX + ".mar";
 const FILE_PARTIAL_MAR = "partial" + TEST_FILE_SUFFIX + ".mar";
-const LOG_COMPLETE_SUCCESS = "complete_log_success" + TEST_FILE_SUFFIX;
-const LOG_PARTIAL_SUCCESS  = "partial_log_success" + TEST_FILE_SUFFIX;
-const LOG_PARTIAL_FAILURE  = "partial_log_failure" + TEST_FILE_SUFFIX;
 const FILE_COMPLETE_PRECOMPLETE = "complete_precomplete" + TEST_FILE_SUFFIX;
 const FILE_PARTIAL_PRECOMPLETE = "partial_precomplete" + TEST_FILE_SUFFIX;
 const FILE_COMPLETE_REMOVEDFILES = "complete_removed-files" + TEST_FILE_SUFFIX;
 const FILE_PARTIAL_REMOVEDFILES = "partial_removed-files" + TEST_FILE_SUFFIX;
+const FILE_UPDATE_IN_PROGRESS_LOCK = "updated.update_in_progress.lock";
+const COMPARE_LOG_SUFFIX = getLogSuffix();
+const LOG_COMPLETE_SUCCESS = "complete_log_success" + COMPARE_LOG_SUFFIX;
+const LOG_PARTIAL_SUCCESS = "partial_log_success" + COMPARE_LOG_SUFFIX;
+const LOG_PARTIAL_FAILURE = "partial_log_failure" + COMPARE_LOG_SUFFIX;
+// Gonk sorts differently when applying and staging an update.
+const LOG_COMPLETE_SUCCESS_STAGE = LOG_COMPLETE_SUCCESS +
+                                   (IS_TOOLKIT_GONK ? "_stage" : "");
+const LOG_PARTIAL_SUCCESS_STAGE = LOG_PARTIAL_SUCCESS +
+                                  (IS_TOOLKIT_GONK ? "_stage" : "");
+const LOG_REPLACE_SUCCESS = "replace_log_success";
 
 const USE_EXECV = IS_UNIX && !IS_MACOSX;
 
@@ -65,16 +86,18 @@ const FILE_PARTIAL_EXE = "partial.exe";
 const FILE_UPDATER_BIN = "updater" + BIN_SUFFIX;
 const FILE_WRONG_CHANNEL_MAR = "wrong_product_channel.mar";
 
-const LOG_SWITCH_SUCCESS = "rename_file: proceeding to rename the directory\n" +
-                           "rename_file: proceeding to rename the directory\n" +
-                           "Now, remove the tmpDir\n" +
-                           "succeeded\n" +
-                           "calling QuitProgressUI";
-
+const PERFORMING_STAGED_UPDATE = "Performing a staged update";
+const CALL_QUIT = "calling QuitProgressUI";
+const REMOVE_OLD_DIST_DIR = "removing old distribution directory";
+const MOVE_OLD_DIST_DIR = "Moving old distribution directory to new location";
+const ERR_UPDATE_IN_PROGRESS = "Update already in progress! Exiting";
 const ERR_RENAME_FILE = "rename_file: failed to rename file";
+const ERR_ENSURE_COPY = "ensure_copy: failed to copy the file";
 const ERR_UNABLE_OPEN_DEST = "unable to open destination file";
 const ERR_BACKUP_DISCARD = "backup_discard: unable to remove";
 const ERR_MOVE_DESTDIR_7 = "Moving destDir to tmpDir failed, err: 7";
+const ERR_BACKUP_CREATE_7 = "backup_create failed: 7";
+const ERR_LOADSOURCEFILE_FAILED = "LoadSourceFile failed";
 
 const LOG_SVC_SUCCESSFUL_LAUNCH = "Process was started... waiting on result.";
 
@@ -88,16 +111,11 @@ const MSG_SHOULD_NOT_EXIST = "the file or directory should not exist";
 // difference in the last modified time.
 const MAC_MAX_TIME_DIFFERENCE = 60000;
 
-// Time to wait for the test helper process before continuing the test
-const TEST_HELPER_TIMEOUT = 100;
+// How many of do_execute_soon calls to wait before the test is aborted.
+const MAX_TIMEOUT_RUNS = 20000;
 
-// Time to wait for a check in the test before continuing the test
-const TEST_CHECK_TIMEOUT = 100;
-
-// How many of TEST_CHECK_TIMEOUT to wait before we abort the test.
-const MAX_TIMEOUT_RUNS = 2000;
-
-// Time in seconds the helper application should sleep.the helper's input and output files
+// Time in seconds the helper application should sleep before exiting. The
+// helper can also be made to exit by writing |finish| to its input file.
 const HELPER_SLEEP_TIMEOUT = 180;
 
 // Maximum number of milliseconds the process that is launched can run before
@@ -143,8 +161,6 @@ var gServiceLaunchedCallbackArgs = null;
 var gCallbackBinFile = "callback_app" + BIN_SUFFIX;
 var gCallbackArgs = ["./", "callback.log", "Test Arg 2", "Test Arg 3"];
 var gPostUpdateBinFile = "postup_app" + BIN_SUFFIX;
-var gStageUpdate = false;
-var gSwitchApp = false;
 var gUseTestAppDir = true;
 
 var gTimeoutRuns = 0;
@@ -760,8 +776,6 @@ if (MOZ_APP_NAME == "xulrunner") {
 function setupTestCommon() {
   debugDump("start - general test setup");
 
-  do_test_pending();
-
   Assert.strictEqual(gTestID, undefined,
                      "gTestID should be 'undefined' (setupTestCommon should " +
                      "only be called once)");
@@ -769,6 +783,28 @@ function setupTestCommon() {
   let caller = Components.stack.caller;
   gTestID = caller.filename.toString().split("/").pop().split(".")[0];
 
+  // Tests that don't work with XULRunner.
+  const XUL_RUNNER_INCOMPATIBLE = ["marAppApplyUpdateAppBinInUseStageSuccess_win",
+                                   "marAppApplyUpdateStageSuccess",
+                                   "marAppApplyUpdateSuccess",
+                                   "marAppApplyUpdateAppBinInUseStageSuccessSvc_win",
+                                   "marAppApplyUpdateStageSuccessSvc",
+                                   "marAppApplyUpdateSuccessSvc"];
+  // Replace with Array.prototype.includes when it has stabilized.
+  if (MOZ_APP_NAME == "xulrunner" &&
+      XUL_RUNNER_INCOMPATIBLE.indexOf(gTestID) != -1) {
+    logTestInfo("Unable to run this test on xulrunner");
+    return false;
+  }
+
+  if (IS_SERVICE_TEST && !shouldRunServiceTest()) {
+    return false;
+  }
+
+  do_test_pending();
+
+  setDefaultPrefs();
+
   if (DEBUG_TEST_LOG) {
     let logFile = do_get_file(gTestID + ".log", true);
     if (logFile.exists()) {
@@ -788,6 +824,11 @@ function setupTestCommon() {
     }
   }
 
+  if (IS_WIN) {
+    Services.prefs.setBoolPref(PREF_APP_UPDATE_SERVICE_ENABLED,
+                               IS_SERVICE_TEST ? true : false);
+  }
+
   // Don't attempt to show a prompt when an update finishes.
   Services.prefs.setBoolPref(PREF_APP_UPDATE_SILENT, true);
 
@@ -843,6 +884,7 @@ function setupTestCommon() {
   }
 
   debugDump("finish - general test setup");
+  return true;
 }
 
 /**
@@ -900,8 +942,8 @@ function cleanupTestCommon() {
   }
 
   // The updates directory is located outside of the application directory on
-  // Windows and Mac OS X so it also needs to be removed.
-  if (IS_WIN || IS_MACOSX) {
+  // Windows, Mac OS X, and GONK and needs to be removed.
+  if (IS_WIN || IS_MACOSX || IS_TOOLKIT_GONK) {
     let updatesDir = getMockUpdRootD();
     // Try to remove the directory used to apply updates. Since the test has
     // already finished this is non-fatal for the test.
@@ -928,6 +970,9 @@ function cleanupTestCommon() {
             } catch (e) {
               logTestInfo("non-fatal error removing directory. Path: " +
                           updatesDir.path + ", Exception: " + e);
+              if (e == Cr.NS_ERROR_FILE_DIR_NOT_EMPTY) {
+                break;
+              }
             }
           }
           updatesDir = updatesDir.parent;
@@ -1018,7 +1063,12 @@ function setDefaultPrefs() {
   if (DEBUG_AUS_TEST) {
     // Enable Update logging
     Services.prefs.setBoolPref(PREF_APP_UPDATE_LOG, true);
+  } else {
+    // Some apps (e.g. gonk) set this preference to true by default
+    Services.prefs.setBoolPref(PREF_APP_UPDATE_LOG, false);
   }
+  // In case telemetry is enabled for xpcshell tests.
+  Services.prefs.setBoolPref(PREF_TOOLKIT_TELEMETRY_ENABLED, false);
 }
 
 /**
@@ -1099,9 +1149,11 @@ function checkPostUpdateRunningFile(aShouldExist) {
   }
   let postUpdateRunningFile = getPostUpdateFile(".running");
   if (aShouldExist) {
-    Assert.ok(postUpdateRunningFile.exists(), MSG_SHOULD_EXIST);
+    Assert.ok(postUpdateRunningFile.exists(),
+              MSG_SHOULD_EXIST + getMsgPath(postUpdateRunningFile.path));
   } else {
-    Assert.ok(!postUpdateRunningFile.exists(), MSG_SHOULD_NOT_EXIST);
+    Assert.ok(!postUpdateRunningFile.exists(),
+              MSG_SHOULD_NOT_EXIST + getMsgPath(postUpdateRunningFile.path));
   }
 }
 
@@ -1111,7 +1163,6 @@ function checkPostUpdateRunningFile(aShouldExist) {
  */
 function standardInit() {
   createAppInfo("xpcshell@tests.mozilla.org", APP_INFO_NAME, "1.0", "2.0");
-  setDefaultPrefs();
   // Initialize the update service stub component
   initUpdateServiceStub();
 }
@@ -1145,7 +1196,8 @@ function getAppVersion() {
     iniFile = gGREBinDirOrig.clone();
     iniFile.append(FILE_APPLICATION_INI);
   }
-  Assert.ok(iniFile.exists(), MSG_SHOULD_EXIST);
+  Assert.ok(iniFile.exists(),
+            MSG_SHOULD_EXIST + getMsgPath(iniFile.path));
   let iniParser = Cc["@mozilla.org/xpcom/ini-parser-factory;1"].
                   getService(Ci.nsIINIParserFactory).
                   createINIParser(iniFile);
@@ -1230,7 +1282,8 @@ function getStageDirFile(aRelPath, aAllowNonexistent) {
       }
     }
     if (!aAllowNonexistent) {
-      Assert.ok(file.exists(), MSG_SHOULD_EXIST);
+      Assert.ok(file.exists(),
+                MSG_SHOULD_EXIST + getMsgPath(file.path));
     }
     return file;
   }
@@ -1304,6 +1357,15 @@ function getMaintSvcDir() {
   return maintSvcDir;
 }
 
+/**
+ * Get the nsILocalFile for a Windows special folder determined by the CSIDL
+ * passed.
+ *
+ * @param   aCSIDL
+ *          The CSIDL for the Windows special folder.
+ * @return  The nsILocalFile for the Windows special folder.
+ * @throws  If called from a platform other than Windows.
+ */
 function getSpecialFolderDir(aCSIDL) {
   if (!IS_WIN) {
     do_throw("Windows only function called by a different platform!");
@@ -1406,6 +1468,12 @@ function getMockUpdRootD() {
     return getMockUpdRootDMac();
   }
 
+  // The gonk updates directory is under /data/local but for the updater tests
+  // we use the following directory so the tests can run in parallel.
+  if (IS_TOOLKIT_GONK) {
+    return do_get_file(gTestID + "/", true);
+  }
+
   return getApplyDirFile(DIR_MACOS, true);
 }
 
@@ -1501,64 +1569,58 @@ function getMockUpdRootDMac() {
   return updatesDir;
 }
 
-const kLockFileName = "updated.update_in_progress.lock";
 /**
- * Helper function for locking a directory on Windows.
+ * Creates an update in progress lock file in the specified directory on
+ * Windows.
  *
  * @param   aDir
- *          The nsIFile for the directory to lock.
+ *          The nsIFile for the directory where the lock file should be created.
  */
-function lockDirectory(aDir) {
+function createUpdateInProgressLockFile(aDir) {
   if (!IS_WIN) {
     do_throw("Windows only function called by a different platform!");
   }
 
   let file = aDir.clone();
-  file.append(kLockFileName);
+  file.append(FILE_UPDATE_IN_PROGRESS_LOCK);
   file.create(file.NORMAL_FILE_TYPE, 0o444);
   file.QueryInterface(Ci.nsILocalFileWin);
   file.fileAttributesWin |= file.WFA_READONLY;
   file.fileAttributesWin &= ~file.WFA_READWRITE;
-  Assert.ok(file.exists(), MSG_SHOULD_EXIST);
+  Assert.ok(file.exists(),
+            MSG_SHOULD_EXIST + getMsgPath(file.path));
   Assert.ok(!file.isWritable(),
             "the lock file should not be writeable");
 }
+
 /**
- * Helper function for unlocking a directory on Windows.
+ * Removes an update in progress lock file in the specified directory on
+ * Windows.
  *
  * @param   aDir
- *          The nsIFile for the directory to unlock.
+ *          The nsIFile for the directory where the lock file is located.
  */
-function unlockDirectory(aDir) {
+function removeUpdateInProgressLockFile(aDir) {
   if (!IS_WIN) {
     do_throw("Windows only function called by a different platform!");
   }
+
   let file = aDir.clone();
-  file.append(kLockFileName);
+  file.append(FILE_UPDATE_IN_PROGRESS_LOCK);
   file.QueryInterface(Ci.nsILocalFileWin);
   file.fileAttributesWin |= file.WFA_READWRITE;
   file.fileAttributesWin &= ~file.WFA_READONLY;
   file.remove(false);
-  Assert.ok(!file.exists(), MSG_SHOULD_NOT_EXIST);
+  Assert.ok(!file.exists(),
+            MSG_SHOULD_NOT_EXIST + getMsgPath(file.path));
 }
 
 /**
- * Helper function for updater tests for launching the updater binary to apply
- * a mar file.
+ * Gets the test updater from the test data direcory.
  *
- * @param   aExpectedExitValue
- *          The expected exit value from the updater binary.
- * @param   aExpectedStatus
- *          The expected value of update.status when the test finishes.
- * @param   aCallback (optional)
- *          A callback function that will be called when this function finishes.
- *          If null no function will be called when this function finishes.
- *          If not specified the checkUpdateApplied function will be called when
- *          this function finishes.
+ * @return  nsIFIle for the test updater.
  */
-function runUpdate(aExpectedExitValue, aExpectedStatus, aCallback) {
-  // Copy the updater binary to the updates directory.
-  let binDir = gGREBinDirOrig.clone();
+function getTestUpdater() {
   let updater = getTestDirFile("updater.app", true);
   if (!updater.exists()) {
     updater = getTestDirFile(FILE_UPDATER_BIN);
@@ -1566,23 +1628,130 @@ function runUpdate(aExpectedExitValue, aExpectedStatus, aCallback) {
       do_throw("Unable to find the updater binary!");
     }
   }
-  Assert.ok(updater.exists(), MSG_SHOULD_EXIST);
+  Assert.ok(updater.exists(),
+            MSG_SHOULD_EXIST + getMsgPath(updater.path));
+  return updater;
+}
+
+/**
+ * Copies the test updater to the GRE binary directory and returns the nsIFile
+ * for the copied test updater.
+ *
+ * @return  nsIFIle for the copied test updater.
+ */
+function copyTestUpdaterToBinDir() {
+  let testUpdater = getTestUpdater();
+  let updater = getGREBinDir();
+  updater.append(testUpdater.leafName);
+  if (!updater.exists()) {
+    testUpdater.copyToFollowingLinks(updater.parent, updater.leafName);
+  }
+  return updater;
+}
+
+/**
+ * Copies the test updater to the location where it will be launched to apply an
+ * update and returns the nsIFile for the copied test updater.
+ *
+ * @return  nsIFIle for the copied test updater.
+ */
+function copyTestUpdaterForRunUsingUpdater() {
+  if (IS_WIN) {
+    return copyTestUpdaterToBinDir();
+  }
+
+  let testUpdater = getTestUpdater();
+  let updater = getUpdatesPatchDir();
+  updater.append(testUpdater.leafName);
+  if (!updater.exists()) {
+    testUpdater.copyToFollowingLinks(updater.parent, updater.leafName);
+  }
+
+  if (IS_MACOSX) {
+    updater.append("Contents");
+    updater.append("MacOS");
+    updater.append("org.mozilla.updater");
+  }
+  return updater;
+}
+
+/**
+ * Logs the contents of an update log.
+ *
+ * @param   aLogLeafName
+ *          The leaf name of the log.
+ */
+function logUpdateLog(aLogLeafName) {
+  let updateLog = getUpdateLog(aLogLeafName);
+  if (updateLog.exists()) {
+    // xpcshell tests won't display the entire contents so log each line.
+    let updateLogContents = readFileBytes(updateLog).replace(/\r\n/g, "\n");
+    updateLogContents = replaceLogPaths(updateLogContents);
+    let aryLogContents = updateLogContents.split("\n");
+    logTestInfo("contents of " + updateLog.path + ":");
+    aryLogContents.forEach(function RU_LC_FE(aLine) {
+      logTestInfo(aLine);
+    });
+  } else {
+    logTestInfo("update log doesn't exist, path: " + updateLog.path);
+  }
+}
+
+/**
+ * Launches the updater binary or the service to apply an update for updater
+ * tests. For non-service tests runUpdateUsingUpdater will be called and for
+ * service tests runUpdateUsingService will be called.
+ *
+ * @param   aExpectedStatus
+ *          The expected value of update.status when the test finishes. For
+ *          service tests passing STATE_PENDING or STATE_APPLIED will change the
+ *          value to STATE_PENDING_SVC and STATE_APPLIED_SVC respectively.
+ * @param   aSwitchApp
+ *          If true the update should switch the application with an updated
+ *          staged application and if false the update should be applied to the
+ *          installed application.
+ * @param   aExpectedExitValue
+ *          The expected exit value from the updater binary for non-service
+ *          tests.
+ * @param   aCheckSvcLog
+ *          Whether the service log should be checked for service tests.
+ */
+function runUpdate(aExpectedStatus, aSwitchApp, aExpectedExitValue,
+                   aCheckSvcLog) {
+  if (IS_SERVICE_TEST) {
+    let expectedStatus = aExpectedStatus;
+    if (aExpectedStatus == STATE_PENDING) {
+      expectedStatus = STATE_PENDING_SVC;
+    } else if (aExpectedStatus == STATE_APPLIED) {
+      expectedStatus = STATE_APPLIED_SVC;
+    }
+    runUpdateUsingService(expectedStatus, aSwitchApp, aCheckSvcLog);
+  } else {
+    runUpdateUsingUpdater(aExpectedStatus, aSwitchApp, aExpectedExitValue);
+  }
+}
+
+/**
+ * Launches the updater binary or the service to apply an update for updater
+ * tests. When completed runUpdateFinished will be called.
+ *
+ * @param   aExpectedStatus
+ *          The expected value of update.status when the test finishes.
+ * @param   aSwitchApp
+ *          If true the update should switch the application with an updated
+ *          staged application and if false the update should be applied to the
+ *          installed application.
+ * @param   aExpectedExitValue
+ *          The expected exit value from the updater binary.
+ */
+function runUpdateUsingUpdater(aExpectedStatus, aSwitchApp, aExpectedExitValue) {
+  // Copy the updater binary to the directory where it will apply updates.
+  let updateBin = copyTestUpdaterForRunUsingUpdater();
+  Assert.ok(updateBin.exists(),
+            MSG_SHOULD_EXIST + getMsgPath(updateBin.path));
 
   let updatesDir = getUpdatesPatchDir();
-  let updateBin;
-  if (IS_WIN) {
-    updateBin = updater.clone();
-  } else {
-    updater.copyToFollowingLinks(updatesDir, updater.leafName);
-    updateBin = updatesDir.clone();
-    updateBin.append(updater.leafName);
-    if (updateBin.leafName == "updater.app") {
-      updateBin.append("Contents");
-      updateBin.append("MacOS");
-      updateBin.append("org.mozilla.updater");
-    }
-  }
-  Assert.ok(updateBin.exists(), MSG_SHOULD_EXIST);
+  let updatesDirPath = updatesDir.path;
 
   let applyToDir = getApplyDirFile(null, true);
   let applyToDirPath = applyToDir.path;
@@ -1592,6 +1761,7 @@ function runUpdate(aExpectedExitValue, aExpectedStatus, aCallback) {
 
   if (IS_WIN) {
     // Convert to native path
+    updatesDirPath = updatesDirPath.replace(/\//g, "\\");
     applyToDirPath = applyToDirPath.replace(/\//g, "\\");
     stageDirPath = stageDirPath.replace(/\//g, "\\");
   }
@@ -1599,21 +1769,18 @@ function runUpdate(aExpectedExitValue, aExpectedStatus, aCallback) {
   let callbackApp = getApplyDirFile(DIR_RESOURCES + gCallbackBinFile);
   callbackApp.permissions = PERMS_DIRECTORY;
 
-  let args = [updatesDir.path, applyToDirPath];
-  if (gStageUpdate) {
+  setAppBundleModTime();
+
+  let args = [updatesDirPath, applyToDirPath];
+  if (aSwitchApp) {
     args[2] = stageDirPath;
-    args[3] = -1;
+    args[3] = "0/replace";
   } else {
-    if (gSwitchApp) {
-      args[2] = stageDirPath;
-      args[3] = "0/replace";
-    } else {
-      args[2] = applyToDirPath;
-      args[3] = "0";
-    }
-    args = args.concat([callbackApp.parent.path, callbackApp.path]);
-    args = args.concat(gCallbackArgs);
+    args[2] = applyToDirPath;
+    args[3] = "0";
   }
+  args = args.concat([callbackApp.parent.path, callbackApp.path]);
+  args = args.concat(gCallbackArgs);
   debugDump("running the updater: " + updateBin.path + " " + args.join(" "));
 
   let process = Cc["@mozilla.org/process/util;1"].
@@ -1625,67 +1792,210 @@ function runUpdate(aExpectedExitValue, aExpectedStatus, aCallback) {
   if (process.exitValue != aExpectedExitValue || status != aExpectedStatus) {
     if (process.exitValue != aExpectedExitValue) {
       logTestInfo("updater exited with unexpected value! Got: " +
-                  process.exitValue + ", Expected: " +  aExpectedExitValue);
+                  process.exitValue + ", Expected: " + aExpectedExitValue);
     }
     if (status != aExpectedStatus) {
       logTestInfo("update status is not the expected status! Got: " + status +
-                  ", Expected: " +  aExpectedStatus);
+                  ", Expected: " + aExpectedStatus);
     }
-    let updateLog = getUpdatesPatchDir();
-    updateLog.append(FILE_UPDATE_LOG);
-    // xpcshell tests won't display the entire contents so log each line.
-    let updateLogContents = readFileBytes(updateLog).replace(/\r\n/g, "\n");
-    updateLogContents = replaceLogPaths(updateLogContents);
-    let aryLogContents = updateLogContents.split("\n");
-    logTestInfo("contents of " + updateLog.path + ":");
-    aryLogContents.forEach(function RU_LC_FE(aLine) {
-      logTestInfo(aLine);
-    });
+    logUpdateLog(FILE_LAST_UPDATE_LOG);
   }
   Assert.equal(process.exitValue, aExpectedExitValue,
                "the process exit value" + MSG_SHOULD_EQUAL);
   Assert.equal(status, aExpectedStatus,
                "the update status" + MSG_SHOULD_EQUAL);
 
-  if (aCallback !== null) {
-    if (typeof(aCallback) == typeof(Function)) {
-      aCallback();
-    } else {
-      checkUpdateApplied();
-    }
-  }
+  do_execute_soon(runUpdateFinished);
 }
 
 /**
- * Helper function for updater tests to stage an update.
+ * Launches the helper binary synchronously with the specified arguments for
+ * updater tests.
+ *
+ * @param   aArgs
+ *          The arguments to pass to the helper binary.
+ * @return  the process exit value returned by the helper binary.
+ */
+function runTestHelperSync(aArgs) {
+  let helperBin = getTestDirFile(FILE_HELPER_BIN);
+  let process = Cc["@mozilla.org/process/util;1"].
+                createInstance(Ci.nsIProcess);
+  process.init(helperBin);
+  debugDump("Running " + helperBin.path + " " + aArgs.join(" "));
+  process.run(true, aArgs, aArgs.length);
+  return process.exitValue;
+}
+
+/**
+ * Creates a symlink for updater tests.
+ */
+function createSymlink() {
+  let args = ["setup-symlink", "moz-foo", "moz-bar", "target",
+              getApplyDirFile().path + "/" + DIR_RESOURCES + "link"];
+  let exitValue = runTestHelperSync(args);
+  Assert.equal(exitValue, 0,
+               "the helper process exit value should be 0");
+  getApplyDirFile(DIR_RESOURCES + "link", false).permissions = 0o666;
+  args = ["setup-symlink", "moz-foo2", "moz-bar2", "target2",
+          getApplyDirFile().path +"/" + DIR_RESOURCES + "link2", "change-perm"];
+  exitValue = runTestHelperSync(args);
+  Assert.equal(exitValue, 0,
+               "the helper process exit value should be 0");
+}
+
+/**
+ * Removes a symlink for updater tests.
+ */
+function removeSymlink() {
+  let args = ["remove-symlink", "moz-foo", "moz-bar", "target",
+              getApplyDirFile().path + "/" + DIR_RESOURCES + "link"];
+  let exitValue = runTestHelperSync(args);
+  Assert.equal(exitValue, 0,
+               "the helper process exit value should be 0");
+  args = ["remove-symlink", "moz-foo2", "moz-bar2", "target2",
+          getApplyDirFile().path + "/" + DIR_RESOURCES + "link2"];
+  exitValue = runTestHelperSync(args);
+  Assert.equal(exitValue, 0,
+               "the helper process exit value should be 0");
+}
+
+/**
+ * Checks a symlink for updater tests.
+ */
+function checkSymlink() {
+  let args = ["check-symlink",
+              getApplyDirFile().path + "/" + DIR_RESOURCES + "link"];
+  let exitValue = runTestHelperSync(args);
+  Assert.equal(exitValue, 0,
+               "the helper process exit value should be 0");
+}
+
+/**
+ * Sets the active update and related information for updater tests.
+ */
+function setupActiveUpdate() {
+  let state = IS_SERVICE_TEST ? STATE_PENDING_SVC : STATE_PENDING;
+  let channel = gDefaultPrefBranch.getCharPref(PREF_APP_UPDATE_CHANNEL);
+  let patches = getLocalPatchString(null, null, null, null, null, "true",
+                                    state);
+  let updates = getLocalUpdateString(patches, null, null, null, null, null,
+                                     null, null, null, null, null, null,
+                                     "true", channel);
+  writeUpdatesToXMLFile(getLocalUpdatesXMLString(updates), true);
+  writeVersionFile(DEFAULT_UPDATE_VERSION);
+  writeStatusFile(state);
+  reloadUpdateManagerData();
+  Assert.ok(!!gUpdateManager.activeUpdate,
+            "the active update should be defined");
+}
+
+/**
+ * Gets the specified update log.
+ *
+ * @param   aLogLeafName
+ *          The leaf name of the log to get.
+ * @return  nsIFile for the update log.
+ */
+function getUpdateLog(aLogLeafName) {
+  let updateLog = getUpdatesDir();
+  if (aLogLeafName == FILE_UPDATE_LOG) {
+    updateLog.append(DIR_PATCH);
+  }
+  updateLog.append(aLogLeafName);
+  return updateLog;
+}
+
+/**
+ * Stages an update using nsIUpdateProcessor:processUpdate for updater tests.
  */
 function stageUpdate() {
   debugDump("start - attempting to stage update");
+
+  if (IS_TOOLKIT_GONK) {
+    copyTestUpdaterToBinDir();
+  }
+
   Services.obs.addObserver(gUpdateStagedObserver, "update-staged", false);
 
+  setAppBundleModTime();
   setEnvironment();
   // Stage the update.
   Cc["@mozilla.org/updates/update-processor;1"].
     createInstance(Ci.nsIUpdateProcessor).
     processUpdate(gUpdateManager.activeUpdate);
-  resetEnvironment();
+
+  // The environment is not reset here because processUpdate in
+  // nsIUpdateProcessor uses a new thread and clearing the environment
+  // immediately after calling processUpdate can clear the environment before
+  // the updater is launched. Instead it is reset after the update-staged
+  // observer topic.
 
   debugDump("finish - attempting to stage update");
 }
 
+/**
+ * Checks that the update state is correct as well as the expected files are
+ * present after staging and update for updater tests and then calls
+ * stageUpdateFinished.
+ *
+ * @param   aUpdateState
+ *          The update state received by the observer notification.
+ */
+function checkUpdateStagedState(aUpdateState) {
+  if (IS_WIN) {
+    waitForApplicationStop(FILE_UPDATER_BIN);
+  }
+
+  Assert.equal(aUpdateState, STATE_AFTER_STAGE,
+               "the notified state" + MSG_SHOULD_EQUAL);
+
+  Assert.equal(gUpdateManager.activeUpdate.state, STATE_AFTER_STAGE,
+               "the update state" + MSG_SHOULD_EQUAL);
+
+  Assert.equal(readStatusState(), STATE_AFTER_STAGE,
+               "the status file state" + MSG_SHOULD_EQUAL);
+
+  let log = getUpdateLog(FILE_LAST_UPDATE_LOG);
+  Assert.ok(log.exists(),
+            MSG_SHOULD_EXIST + getMsgPath(log.path));
+
+  log = getUpdateLog(FILE_UPDATE_LOG);
+  Assert.ok(!log.exists(),
+            MSG_SHOULD_NOT_EXIST + getMsgPath(log.path));
+
+  log = getUpdateLog(FILE_BACKUP_UPDATE_LOG);
+  Assert.ok(!log.exists(),
+            MSG_SHOULD_NOT_EXIST + getMsgPath(log.path));
+
+  let stageDir = getStageDirFile(null, true);
+  if (STATE_AFTER_STAGE == STATE_APPLIED ||
+      STATE_AFTER_STAGE == STATE_APPLIED_SVC) {
+    Assert.ok(stageDir.exists(),
+              MSG_SHOULD_EXIST + getMsgPath(stageDir.path));
+  } else {
+    Assert.ok(!stageDir.exists(),
+              MSG_SHOULD_NOT_EXIST + getMsgPath(stageDir.path));
+  }
+
+  do_execute_soon(stageUpdateFinished);
+}
+
 /**
  * Helper function to check whether the maintenance service updater tests should
  * run. See bug 711660 for more details.
  *
- * @param  aFirstTest
- *         Whether this is the first test within the test.
  * @return true if the test should run and false if it shouldn't.
  */
-function shouldRunServiceTest(aFirstTest) {
+function shouldRunServiceTest() {
+  if (!IS_WIN) {
+    do_throw("Windows only function called by a different platform!");
+  }
+
   let binDir = getGREBinDir();
   let updaterBin = binDir.clone();
   updaterBin.append(FILE_UPDATER_BIN);
-  Assert.ok(updaterBin.exists(), MSG_SHOULD_EXIST);
+  Assert.ok(updaterBin.exists(),
+            MSG_SHOULD_EXIST + ", leafName: " + updaterBin.leafName);
 
   let updaterBinPath = updaterBin.path;
   if (/ /.test(updaterBinPath)) {
@@ -1718,22 +2028,10 @@ function shouldRunServiceTest(aFirstTest) {
   }
 
   // Check to make sure the service is installed
-  let helperBin = getTestDirFile(FILE_HELPER_BIN);
   let args = ["wait-for-service-stop", "MozillaMaintenance", "10"];
-  let process = Cc["@mozilla.org/process/util;1"].
-                createInstance(Ci.nsIProcess);
-  process.init(helperBin);
-  process.run(true, args, args.length);
-  Assert.notEqual(process.exitValue, 0xEE, "the maintenance service should " +
-                  "be installed (if not, build system configuration bug?)");
-
-  // If this is the first test in the series, then there is no reason the
-  // service should be anything but stopped, so be strict here and fail the
-  // test.
-  if (aFirstTest) {
-    Assert.equal(process.exitValue, 0,
-                 "the service should not be running for the first test");
-  }
+  let exitValue = runTestHelperSync(args);
+  Assert.notEqual(exitValue, 0xEE, "the maintenance service should be " +
+                  "installed (if not, build system configuration bug?)");
 
   if (IS_AUTHENTICODE_CHECK_ENABLED) {
     // The test registry key exists and IS_AUTHENTICODE_CHECK_ENABLED is true
@@ -1753,19 +2051,16 @@ function shouldRunServiceTest(aFirstTest) {
 /**
  * Helper function to check whether the a binary is signed.
  *
- * @param  aBinPath The path to the file to check if it is signed.
- * @return true if the file is signed and false if it isn't.
+ * @param   aBinPath
+ *          The path to the file to check if it is signed.
+ * @return  true if the file is signed and false if it isn't.
  */
 function isBinarySigned(aBinPath) {
-  let helperBin = getTestDirFile(FILE_HELPER_BIN);
   let args = ["check-signature", aBinPath];
-  let process = Cc["@mozilla.org/process/util;1"].
-                createInstance(Ci.nsIProcess);
-  process.init(helperBin);
-  process.run(true, args, args.length);
-  if (process.exitValue != 0) {
+  let exitValue = runTestHelperSync(args);
+  if (exitValue != 0) {
     logTestInfo("binary is not signed. " + FILE_HELPER_BIN + " returned " +
-                process.exitValue + " for file " + aBinPath);
+                exitValue + " for file " + aBinPath);
     return false;
   }
   return true;
@@ -1776,7 +2071,8 @@ function isBinarySigned(aBinPath) {
  * to launch the application for the updater tests by either copying or creating
  * symlinks for the files. This is needed for Windows debug builds which can
  * lock a file that is being copied so that the tests can run in parallel. After
- * the files have been copied the setupAppFilesFinished function will be called.
+ * the files have been copied the setupUpdaterTestFinished function will be
+ * called.
  */
 function setupAppFilesAsync() {
   gTimeoutRuns++;
@@ -1787,11 +2083,11 @@ function setupAppFilesAsync() {
       do_throw("Exceeded MAX_TIMEOUT_RUNS while trying to setup application " +
                "files! Exception: " + e);
     }
-    do_timeout(TEST_CHECK_TIMEOUT, setupAppFilesAsync);
+    do_execute_soon(setupAppFilesAsync);
     return;
   }
 
-  setupAppFilesFinished();
+  do_execute_soon(setupUpdaterTestFinished);
 }
 
 /**
@@ -1833,35 +2129,26 @@ function setupAppFiles() {
   // into the array.
   let deplibsFile = gGREDirOrig.clone();
   deplibsFile.append("dependentlibs.list");
-  let istream = Cc["@mozilla.org/network/file-input-stream;1"].
-                createInstance(Ci.nsIFileInputStream);
-  istream.init(deplibsFile, 0x01, 0o444, 0);
-  istream.QueryInterface(Ci.nsILineInputStream);
+  let fis = Cc["@mozilla.org/network/file-input-stream;1"].
+            createInstance(Ci.nsIFileInputStream);
+  fis.init(deplibsFile, 0x01, 0o444, Ci.nsIFileInputStream.CLOSE_ON_EOF);
+  fis.QueryInterface(Ci.nsILineInputStream);
 
   let hasMore;
   let line = {};
   do {
-    hasMore = istream.readLine(line);
+    hasMore = fis.readLine(line);
     appFiles.push( { relPath  : line.value,
                      inGreDir : false } );
-  } while(hasMore);
+  } while (hasMore);
 
-  istream.close();
+  fis.close();
 
   appFiles.forEach(function CMAF_FLN_FE(aAppFile) {
     copyFileToTestAppDir(aAppFile.relPath, aAppFile.inGreDir);
   });
 
-  // Copy the xpcshell updater binary
-  let updater = getTestDirFile("updater.app", true);
-  if (!updater.exists()) {
-    updater = getTestDirFile(FILE_UPDATER_BIN);
-    if (!updater.exists()) {
-      do_throw("Unable to find the updater binary!");
-    }
-  }
-  let testBinDir = getGREBinDir();
-  updater.copyToFollowingLinks(testBinDir, updater.leafName);
+  copyTestUpdaterToBinDir();
 
   debugDump("finish - copying or creating symlinks to application files " +
             "for the test");
@@ -1871,15 +2158,15 @@ function setupAppFiles() {
  * Copies the specified files from the dist/bin directory into the test's
  * application directory.
  *
- * @param  aFileRelPath
- *         The relative path to the source and the destination of the file to
- *         copy.
- * @param  aInGreDir
- *         Whether the file is located in the GRE directory which is
- *         <bundle>/Contents/Resources on Mac OS X and is the installation
- *         directory on all other platforms. If false the file must be in the
- *         GRE Binary directory which is <bundle>/Contents/MacOS on Mac OS X and
- *         is the installation directory on on all other platforms.
+ * @param   aFileRelPath
+ *          The relative path to the source and the destination of the file to
+ *          copy.
+ * @param   aInGreDir
+ *          Whether the file is located in the GRE directory which is
+ *          <bundle>/Contents/Resources on Mac OS X and is the installation
+ *          directory on all other platforms. If false the file must be in the
+ *          GRE Binary directory which is <bundle>/Contents/MacOS on Mac OS X
+ *          and is the installation directory on on all other platforms.
  */
 function copyFileToTestAppDir(aFileRelPath, aInGreDir) {
   // gGREDirOrig and gGREBinDirOrig must always be cloned when changing its
@@ -1910,7 +2197,6 @@ function copyFileToTestAppDir(aFileRelPath, aInGreDir) {
     }
     fileRelPath = fileRelPath + ".app";
   }
-
   Assert.ok(srcFile.exists(),
             MSG_SHOULD_EXIST + ", leafName: " + srcFile.leafName);
 
@@ -1950,7 +2236,7 @@ function copyFileToTestAppDir(aFileRelPath, aInGreDir) {
       let args = ["-s", srcFile.path, destFile.path];
       process.run(true, args, args.length);
       Assert.ok(destFile.isSymlink(),
-                "the file should be a symlink");
+                destFile.leafName + " should be a symlink");
     } catch (e) {
       do_throw("Unable to create symlink for file! Path: " + srcFile.path +
                ", Exception: " + e);
@@ -1963,13 +2249,23 @@ function copyFileToTestAppDir(aFileRelPath, aInGreDir) {
  * This is useful for XP where we have permission to upgrade in case an
  * older service installer exists.  Also if the user manually installed into
  * a unprivileged location.
+ *
+ * @return true if the installed service is from this build. If the installed
+ *         service is not from this build the test will fail instead of
+ *         returning false.
  */
 function attemptServiceInstall() {
+  if (!IS_WIN) {
+    do_throw("Windows only function called by a different platform!");
+  }
+
   let maintSvcDir = getMaintSvcDir();
-  Assert.ok(maintSvcDir.exists(), MSG_SHOULD_EXIST);
+  Assert.ok(maintSvcDir.exists(),
+            MSG_SHOULD_EXIST + ", leafName: " + maintSvcDir.leafName);
   let oldMaintSvcBin = maintSvcDir.clone();
   oldMaintSvcBin.append(FILE_MAINTENANCE_SERVICE_BIN);
-  Assert.ok(oldMaintSvcBin.exists(), MSG_SHOULD_EXIST);
+  Assert.ok(oldMaintSvcBin.exists(),
+            MSG_SHOULD_EXIST + ", leafName: " + oldMaintSvcBin.leafName);
   let buildMaintSvcBin = getGREBinDir();
   buildMaintSvcBin.append(FILE_MAINTENANCE_SERVICE_BIN);
   if (readFileBytes(oldMaintSvcBin) == readFileBytes(buildMaintSvcBin)) {
@@ -2004,17 +2300,109 @@ function attemptServiceInstall() {
 }
 
 /**
- * Helper function for updater tests for launching the updater using the
- * maintenance service to apply a mar file.
- *
- * @param aInitialStatus
- *        The initial value of update.status.
- * @param aExpectedStatus
- *        The expected value of update.status when the test finishes.
- * @param aCheckSvcLog (optional)
- *        Whether the service log should be checked.
+ * Waits for the applications that are launched by the maintenance service to
+ * stop.
  */
-function runUpdateUsingService(aInitialStatus, aExpectedStatus, aCheckSvcLog) {
+function waitServiceApps() {
+  if (!IS_WIN) {
+    do_throw("Windows only function called by a different platform!");
+  }
+
+  // maintenanceservice_installer.exe is started async during updates.
+  waitForApplicationStop("maintenanceservice_installer.exe");
+  // maintenanceservice_tmp.exe is started async from the service installer.
+  waitForApplicationStop("maintenanceservice_tmp.exe");
+  // In case the SCM thinks the service is stopped, but process still exists.
+  waitForApplicationStop("maintenanceservice.exe");
+}
+
+/**
+ * Waits for the maintenance service to stop.
+ */
+function waitForServiceStop(aFailTest) {
+  if (!IS_WIN) {
+    do_throw("Windows only function called by a different platform!");
+  }
+
+  waitServiceApps();
+  debugDump("waiting for the maintenance service to stop if necessary");
+  // Use the helper bin to ensure the service is stopped. If not stopped, then
+  // wait for the service to stop (at most 120 seconds).
+  let args = ["wait-for-service-stop", "MozillaMaintenance", "120"];
+  let exitValue = runTestHelperSync(args);
+  Assert.notEqual(exitValue, 0xEE,
+                  "the maintenance service should exist");
+  if (exitValue != 0) {
+    if (aFailTest) {
+      Assert.ok(false, "the maintenance service should stop, process exit " +
+                "value: " + exitValue);
+    }
+    logTestInfo("maintenance service did not stop which may cause test " +
+                "failures later, process exit value: " + exitValue);
+  } else {
+    debugDump("service stopped");
+  }
+  waitServiceApps();
+}
+
+/**
+ * Waits for the specified application to stop.
+ *
+ * @param   aApplication
+ *          The application binary name to wait until it has stopped.
+ */
+function waitForApplicationStop(aApplication) {
+  if (!IS_WIN) {
+    do_throw("Windows only function called by a different platform!");
+  }
+
+  debugDump("waiting for " + aApplication + " to stop if necessary");
+  // Use the helper bin to ensure the application is stopped. If not stopped,
+  // then wait for it to stop (at most 120 seconds).
+  let args = ["wait-for-application-exit", aApplication, "120"];
+  let exitValue = runTestHelperSync(args);
+  Assert.equal(exitValue, 0,
+               "the process should have stopped, process name: " +
+               aApplication);
+}
+
+/**
+ * Checks if an application is running.
+ *
+ * @param   aApplication
+ *          The application binary name to check if it is running.
+ */
+function isProcessRunning(aApplication) {
+  if (!IS_WIN) {
+    do_throw("Windows only function called by a different platform!");
+  }
+
+  debugDump("checking if " + aApplication + " is running");
+  // Use the helper bin to ensure the application is stopped. If not stopped,
+  // then wait for it to stop (at most 120 seconds).
+  let args = ["is-process-running", aApplication];
+  let exitValue = runTestHelperSync(args);
+  return exitValue;
+}
+/**
+ * Helper function for updater tests for launching the updater using the
+ * maintenance service to apply a mar file. When complete runUpdateFinished
+ * will be called.
+ *
+ * @param   aExpectedStatus
+ *          The expected value of update.status when the test finishes.
+ * @param   aSwitchApp
+ *          If true the update should switch the application with an updated
+ *          staged application and if false the update should be applied to the
+ *          installed application.
+ * @param   aCheckSvcLog
+ *          Whether the service log should be checked.
+ */
+function runUpdateUsingService(aExpectedStatus, aSwitchApp, aCheckSvcLog) {
+  if (!IS_WIN) {
+    do_throw("Windows only function called by a different platform!");
+  }
+
   // Check the service logs for a successful update
   function checkServiceLogs(aOriginalContents) {
     let contents = readServiceLogFile();
@@ -2025,66 +2413,61 @@ function runUpdateUsingService(aInitialStatus, aExpectedStatus, aCheckSvcLog) {
                     "the contents of the maintenanceservice.log should " +
                     "contain the successful launch string");
   }
+
   function readServiceLogFile() {
     let file = getMaintSvcDir();
     file.append("logs");
     file.append("maintenanceservice.log");
     return readFile(file);
   }
-  function waitServiceApps() {
-    // maintenanceservice_installer.exe is started async during updates.
-    waitForApplicationStop("maintenanceservice_installer.exe");
-    // maintenanceservice_tmp.exe is started async from the service installer.
-    waitForApplicationStop("maintenanceservice_tmp.exe");
-    // In case the SCM thinks the service is stopped, but process still exists.
-    waitForApplicationStop("maintenanceservice.exe");
-  }
-  function waitForServiceStop(aFailTest) {
-    waitServiceApps();
-    debugDump("waiting for service to stop if necessary...");
-    // Use the helper bin to ensure the service is stopped. If not
-    // stopped then wait for the service to be stopped (at most 120 seconds)
-    let helperBin = getTestDirFile(FILE_HELPER_BIN);
-    let helperBinArgs = ["wait-for-service-stop",
-                         "MozillaMaintenance",
-                         "120"];
-    let helperBinProcess = Cc["@mozilla.org/process/util;1"].
-                           createInstance(Ci.nsIProcess);
-    helperBinProcess.init(helperBin);
-    debugDump("stopping service...");
-    helperBinProcess.run(true, helperBinArgs, helperBinArgs.length);
-    Assert.notEqual(helperBinProcess.exitValue, 0xEE,
-                    "the maintenance service should exist");
 
-    if (helperBinProcess.exitValue != 0) {
-      if (aFailTest) {
-        Assert.ok(false, "the maintenance service should stop, process exit " +
-                  "value: " + helperBinProcess.exitValue);
-      }
-
-      logTestInfo("maintenance service did not stop which may cause test " +
-                  "failures later, process exit value: " +
-                  helperBinProcess.exitValue);
-    } else {
-      debugDump("service stopped");
+  function checkServiceUpdateFinished() {
+    if (isProcessRunning(FILE_MAINTENANCE_SERVICE_BIN)) {
+      do_execute_soon(checkServiceUpdateFinished);
+      return;
     }
-    waitServiceApps();
-  }
-  function waitForApplicationStop(aApplication) {
-    debugDump("waiting for " + aApplication + " to stop if necessary");
-    // Use the helper bin to ensure the application is stopped.
-    // If not, then wait for it to be stopped (at most 120 seconds)
-    let helperBin = getTestDirFile(FILE_HELPER_BIN);
-    let helperBinArgs = ["wait-for-application-exit",
-                         aApplication,
-                         "120"];
-    let helperBinProcess = Cc["@mozilla.org/process/util;1"].
-                           createInstance(Ci.nsIProcess);
-    helperBinProcess.init(helperBin);
-    helperBinProcess.run(true, helperBinArgs, helperBinArgs.length);
-    Assert.equal(helperBinProcess.exitValue, 0,
-                 "the process should have stopped, process name: " +
-                 aApplication);
+
+    if (isProcessRunning(FILE_UPDATER_BIN)) {
+      do_execute_soon(checkServiceUpdateFinished);
+      return;
+    }
+
+    // Wait for the expected status
+    let status;
+    try {
+      status = readStatusFile();
+    } catch (e) {
+      do_execute_soon(checkServiceUpdateFinished);
+      return;
+    }
+    // The status will probably always be equal to STATE_APPLYING but there is a
+    // race condition where it would be possible on slower machines where status
+    // could be equal to STATE_PENDING_SVC.
+    if (status == STATE_APPLYING) {
+      debugDump("still waiting to see the " + aExpectedStatus +
+                " status, got " + status + " for now...");
+      do_execute_soon(checkServiceUpdateFinished);
+      return;
+    }
+
+    // Make sure all of the logs are written out.
+    waitForServiceStop(false);
+    resetEnvironment();
+
+    if (status != aExpectedStatus) {
+      logTestInfo("update status is not the expected status! Got: " + status +
+                  ", Expected: " + aExpectedStatus);
+      logTestInfo("update.status contents: " + readStatusFile());
+      logUpdateLog(FILE_UPDATE_LOG);
+    }
+    Assert.equal(status, aExpectedStatus,
+                 "the update status" + MSG_SHOULD_EQUAL);
+
+    if (aCheckSvcLog) {
+      checkServiceLogs(svcOriginalLog);
+    }
+
+    do_execute_soon(runUpdateFinished);
   }
 
   // Make sure the service from the previous test is already stopped.
@@ -2107,23 +2490,13 @@ function runUpdateUsingService(aInitialStatus, aExpectedStatus, aCheckSvcLog) {
   }
 
   let svcOriginalLog;
-  // Default to checking the service log if the parameter is not specified.
-  if (aCheckSvcLog === undefined || aCheckSvcLog) {
+  if (aCheckSvcLog) {
     svcOriginalLog = readServiceLogFile();
   }
 
   let appArgsLogPath = getAppArgsLogPath();
   gServiceLaunchedCallbackLog = appArgsLogPath.replace(/^"|"$/g, "");
 
-  let updatesDir = getUpdatesPatchDir();
-  writeStatusFile(aInitialStatus);
-
-  // sanity check
-  Assert.equal(readStatusState(), aInitialStatus,
-               "the update status state" + MSG_SHOULD_EQUAL);
-
-  writeVersionFile(DEFAULT_UPDATE_VERSION);
-
   gServiceLaunchedCallbackArgs = [
     "-no-remote",
     "-test-process-updates",
@@ -2131,7 +2504,7 @@ function runUpdateUsingService(aInitialStatus, aExpectedStatus, aCheckSvcLog) {
     appArgsLogPath
   ];
 
-  if (gSwitchApp) {
+  if (aSwitchApp) {
     // We want to set the env vars again
     gShouldResetEnv = undefined;
   }
@@ -2166,54 +2539,7 @@ function runUpdateUsingService(aInitialStatus, aExpectedStatus, aCheckSvcLog) {
   // to stop to know the service command is done.
   process.run(true, args, args.length);
 
-  resetEnvironment();
-
-  function timerCallback(aTimer) {
-    // Wait for the expected status
-    let status = readStatusFile();
-    // status will probably always be equal to STATE_APPLYING but there is a
-    // race condition where it would be possible on slower machines where status
-    // could be equal to STATE_PENDING_SVC.
-    if (status == STATE_APPLYING ||
-        status == STATE_PENDING_SVC) {
-      debugDump("still waiting to see the " + aExpectedStatus +
-                " status, got " + status + " for now...");
-      return;
-    }
-
-    // Make sure all of the logs are written out.
-    waitForServiceStop(false);
-
-    aTimer.cancel();
-    aTimer = null;
-
-    if (status != aExpectedStatus) {
-      logTestInfo("update status is not the expected status! Got: " + status +
-                  ", Expected: " +  aExpectedStatus);
-      logTestInfo("update.status contents: " + readStatusFile());
-      let updateLog = getUpdatesPatchDir();
-      updateLog.append(FILE_UPDATE_LOG);
-      // xpcshell tests won't display the entire contents so log each line.
-      let updateLogContents = readFileBytes(updateLog).replace(/\r\n/g, "\n");
-      updateLogContents = replaceLogPaths(updateLogContents);
-      let aryLogContents = updateLogContents.split("\n");
-      logTestInfo("contents of " + updateLog.path + ":");
-      aryLogContents.forEach(function RUUS_TC_LC_FE(aLine) {
-        logTestInfo(aLine);
-      });
-    }
-    Assert.equal(status, aExpectedStatus,
-                 "the update status" + MSG_SHOULD_EQUAL);
-
-    if (aCheckSvcLog) {
-      checkServiceLogs(svcOriginalLog);
-    }
-
-    checkUpdateFinished();
-  }
-
-  let timer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer);
-  timer.initWithCallback(timerCallback, 1000, timer.TYPE_REPEATING_SLACK);
+  do_execute_soon(checkServiceUpdateFinished);
 }
 
 /**
@@ -2222,7 +2548,7 @@ function runUpdateUsingService(aInitialStatus, aExpectedStatus, aCheckSvcLog) {
  * etc.). A shell is used so debug console output can be redirected to a file so
  * it doesn't end up in the test log.
  *
- * @return  nsIFile for the shell binary to launch using nsIProcess.
+ * @return nsIFile for the shell binary to launch using nsIProcess.
  */
 function getLaunchBin() {
   let launchBin;
@@ -2235,14 +2561,107 @@ function getLaunchBin() {
                 createInstance(Ci.nsILocalFile);
     launchBin.initWithPath("/bin/sh");
   }
-  Assert.ok(launchBin.exists(), MSG_SHOULD_EXIST);
+  Assert.ok(launchBin.exists(),
+            MSG_SHOULD_EXIST + getMsgPath(launchBin.path));
 
   return launchBin;
 }
 
+
+/**
+ * Locks a Windows directory.
+ *
+ * @param   aDirPath
+ *          The test file object that describes the file to make in use.
+ */
+function lockDirectory(aDirPath) {
+  if (!IS_WIN) {
+    do_throw("Windows only function called by a different platform!");
+  }
+
+  debugDump("start - locking installation directory");
+  const LPCWSTR = ctypes.char16_t.ptr;
+  const DWORD = ctypes.uint32_t;
+  const LPVOID = ctypes.voidptr_t;
+  const GENERIC_READ = 0x80000000;
+  const FILE_SHARE_READ = 1;
+  const FILE_SHARE_WRITE = 2;
+  const OPEN_EXISTING = 3;
+  const FILE_FLAG_BACKUP_SEMANTICS = 0x02000000;
+  const INVALID_HANDLE_VALUE = LPVOID(0xffffffff);
+  let kernel32 = ctypes.open("kernel32");
+  let CreateFile = kernel32.declare("CreateFileW", ctypes.default_abi,
+                                    LPVOID, LPCWSTR, DWORD, DWORD,
+                                    LPVOID, DWORD, DWORD, LPVOID);
+  gHandle = CreateFile(aDirPath, GENERIC_READ,
+                       FILE_SHARE_READ | FILE_SHARE_WRITE, LPVOID(0),
+                       OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, LPVOID(0));
+  Assert.notEqual(gHandle.toString(), INVALID_HANDLE_VALUE.toString(),
+                  "the handle should not equal INVALID_HANDLE_VALUE");
+  kernel32.close();
+  debugDump("finish - locking installation directory");
+}
+
+/**
+ * Launches the test helper binary to make it in use for updater tests and then
+ * calls waitForHelperSleep.
+ *
+ * @param   aTestFile
+ *          The test file object that describes the file to make in use.
+ */
+function runHelperFileInUse(aRelPath, aCopyTestHelper) {
+  logTestInfo("aRelPath: " + aRelPath);
+  // Launch an existing file so it is in use during the update.
+  let helperBin = getTestDirFile(FILE_HELPER_BIN);
+  let fileInUseBin = getApplyDirFile(aRelPath);
+  if (aCopyTestHelper) {
+    fileInUseBin.remove(false);
+    helperBin.copyTo(fileInUseBin.parent, fileInUseBin.leafName);
+  }
+  fileInUseBin.permissions = PERMS_DIRECTORY;
+  let args = [getApplyDirPath() + DIR_RESOURCES, "input", "output", "-s",
+              HELPER_SLEEP_TIMEOUT];
+  let fileInUseProcess = Cc["@mozilla.org/process/util;1"].
+                         createInstance(Ci.nsIProcess);
+  fileInUseProcess.init(fileInUseBin);
+  fileInUseProcess.run(false, args, args.length);
+
+  do_execute_soon(waitForHelperSleep);
+}
+
+/**
+ * Launches the test helper binary and locks a file specified on the command
+ * line for updater tests and then calls waitForHelperSleep.
+ *
+ * @param   aTestFile
+ *          The test file object that describes the file to lock.
+ */
+function runHelperLockFile(aTestFile) {
+  // Exclusively lock an existing file so it is in use during the update.
+  let helperBin = getTestDirFile(FILE_HELPER_BIN);
+  let helperDestDir = getApplyDirFile(DIR_RESOURCES);
+  helperBin.copyTo(helperDestDir, FILE_HELPER_BIN);
+  helperBin = getApplyDirFile(DIR_RESOURCES + FILE_HELPER_BIN);
+  // Strip off the first two directories so the path has to be from the helper's
+  // working directory.
+  let lockFileRelPath = aTestFile.relPathDir.split("/");
+  if (IS_MACOSX) {
+    lockFileRelPath = lockFileRelPath.slice(2);
+  }
+  lockFileRelPath = lockFileRelPath.join("/") + "/" + aTestFile.fileName;
+  let args = [getApplyDirPath() + DIR_RESOURCES, "input", "output", "-s",
+              HELPER_SLEEP_TIMEOUT, lockFileRelPath];
+  let helperProcess = Cc["@mozilla.org/process/util;1"].
+                        createInstance(Ci.nsIProcess);
+  helperProcess.init(helperBin);
+  helperProcess.run(false, args, args.length);
+
+  do_execute_soon(waitForHelperSleep);
+}
+
 /**
  * Helper function that waits until the helper has completed its operations and
- * is in a sleep state before performing an update by calling doUpdate.
+ * calls waitForHelperSleepFinished when it is finished.
  */
 function waitForHelperSleep() {
   gTimeoutRuns++;
@@ -2254,22 +2673,21 @@ function waitForHelperSleep() {
       do_throw("Exceeded MAX_TIMEOUT_RUNS while waiting for the helper to " +
                "finish its operation. Path: " + output.path);
     }
-    do_timeout(TEST_HELPER_TIMEOUT, waitForHelperSleep);
+    do_execute_soon(waitForHelperSleep);
     return;
   }
   try {
     output.remove(false);
-  }
-  catch (e) {
+  } catch (e) {
     if (gTimeoutRuns > MAX_TIMEOUT_RUNS) {
       do_throw("Exceeded MAX_TIMEOUT_RUNS while waiting for the helper " +
                "message file to no longer be in use. Path: " + output.path);
     }
     debugDump("failed to remove file. Path: " + output.path);
-    do_timeout(TEST_HELPER_TIMEOUT, waitForHelperSleep);
+    do_execute_soon(waitForHelperSleep);
     return;
   }
-  doUpdate();
+  waitForHelperSleepFinished();
 }
 
 /**
@@ -2282,7 +2700,7 @@ function waitForHelperFinished() {
   // this test can fail intermittently on Windows debug builds.
   let output = getApplyDirFile(DIR_RESOURCES + "output", true);
   if (readFile(output) != "finished\n") {
-    do_timeout(TEST_HELPER_TIMEOUT, waitForHelperFinished);
+    do_execute_soon(waitForHelperFinished);
     return;
   }
   // Give the lock file process time to unlock the file before deleting the
@@ -2292,7 +2710,7 @@ function waitForHelperFinished() {
 
 /**
  * Helper function that waits until the helper's input and output files are no
- * longer in use before calling checkUpdate.
+ * longer in use before calling waitForHelperExitFinished.
  */
 function waitForHelperFinishFileUnlock() {
   try {
@@ -2307,16 +2725,16 @@ function waitForHelperFinishFileUnlock() {
   } catch (e) {
     // Give the lock file process time to unlock the file before deleting the
     // input and output files.
-    do_timeout(TEST_HELPER_TIMEOUT, waitForHelperFinishFileUnlock);
+    do_execute_soon(waitForHelperFinishFileUnlock);
     return;
   }
-  checkUpdate();
+  do_execute_soon(waitForHelperExitFinished);
 }
 
 /**
  * Helper function to tell the helper to finish and exit its sleep state.
  */
-function setupHelperFinish() {
+function waitForHelperExit() {
   let input = getApplyDirFile(DIR_RESOURCES + "input", true);
   writeFile(input, "finish\n");
   waitForHelperFinished();
@@ -2328,17 +2746,21 @@ function setupHelperFinish() {
  *
  * @param   aMarFile
  *          The mar file for the update test.
+ * @param   aPostUpdateAsync
+ *          When null the updater.ini is not created otherwise this parameter
+ *          is passed to createUpdaterINI.
  */
-function setupUpdaterTest(aMarFile) {
+function setupUpdaterTest(aMarFile, aPostUpdateAsync) {
   let updatesPatchDir = getUpdatesPatchDir();
   if (!updatesPatchDir.exists()) {
     updatesPatchDir.create(Ci.nsIFile.DIRECTORY_TYPE, PERMS_DIRECTORY);
   }
   // Copy the mar that will be applied
   let mar = getTestDirFile(aMarFile);
-  mar.copyToFollowingLinks(updatesPatchDir, FILE_UPDATE_ARCHIVE);
+  mar.copyToFollowingLinks(updatesPatchDir, FILE_UPDATE_MAR);
 
   let helperBin = getTestDirFile(FILE_HELPER_BIN);
+  helperBin.permissions = PERMS_DIRECTORY;
   let afterApplyBinDir = getApplyDirFile(DIR_RESOURCES, true);
   helperBin.copyToFollowingLinks(afterApplyBinDir, gCallbackBinFile);
   helperBin.copyToFollowingLinks(afterApplyBinDir, gPostUpdateBinFile);
@@ -2409,6 +2831,19 @@ function setupUpdaterTest(aMarFile) {
       });
     }
   });
+
+  setupActiveUpdate();
+
+  if (aPostUpdateAsync !== null) {
+    createUpdaterINI(aPostUpdateAsync);
+  }
+
+  if (IS_TOOLKIT_GONK) {
+    // Gonk doesn't use the app files in any of the tests.
+    do_execute_soon(setupUpdaterTestFinished);
+  } else {
+    setupAppFilesAsync();
+  }
 }
 
 /**
@@ -2416,13 +2851,8 @@ function setupUpdaterTest(aMarFile) {
  * file.
  */
 function createUpdateSettingsINI() {
-  let updateSettingsIni = getApplyDirFile(null, true);
-  if (IS_MACOSX) {
-    updateSettingsIni.append("Contents");
-    updateSettingsIni.append("Resources");
-  }
-  updateSettingsIni.append(FILE_UPDATE_SETTINGS_INI);
-  writeFile(updateSettingsIni, UPDATE_SETTINGS_CONTENTS);
+  let ini = getApplyDirFile(DIR_RESOURCES + FILE_UPDATE_SETTINGS_INI, true);
+  writeFile(ini, UPDATE_SETTINGS_CONTENTS);
 }
 
 /**
@@ -2462,6 +2892,18 @@ function createUpdaterINI(aIsExeAsync) {
   writeFile(updaterIni, updaterIniContents);
 }
 
+/**
+ * Gets the message log path used for assert checks to lessen the length printed
+ * to the log file.
+ *
+ * @param   aPath
+ *          The path to shorten for the log file.
+ * @return  the message including the shortened path for the log file.
+ */
+function getMsgPath(aPath) {
+  return ", path: " + replaceLogPaths(aPath);
+}
+
 /**
  * Helper function that replaces the common part of paths in the update log's
  * contents with <test_dir_path> for paths to the the test directory and
@@ -2503,18 +2945,23 @@ function replaceLogPaths(aLogContents) {
  *
  * @param   aCompareLogFile
  *          The log file to compare the update log with.
- * @param   aExcludeDistributionDir
+ * @param   aStaged
+ *          If the update log file is for a staged update.
+ * @param   aReplace
+ *          If the update log file is for a replace update.
+ * @param   aExcludeDistDir
  *          Removes lines containing the distribution directory from the log
  *          file to compare the update log with.
  */
-function checkUpdateLogContents(aCompareLogFile, aExcludeDistributionDir) {
+function checkUpdateLogContents(aCompareLogFile, aStaged = false,
+                                aReplace = false, aExcludeDistDir = false) {
   if (IS_UNIX && !IS_MACOSX) {
-    // Sorting on Linux is different so skip checking the logs for now.
+    // The order that files are returned when enumerating the file system on
+    // Linux is not deterministic so skip checking the logs.
     return;
   }
 
-  let updateLog = getUpdatesPatchDir();
-  updateLog.append(FILE_UPDATE_LOG);
+  let updateLog = getUpdateLog(FILE_LAST_UPDATE_LOG);
   let updateLogContents = readFileBytes(updateLog);
 
   // The channel-prefs.js is defined in gTestFilesCommon which will always be
@@ -2524,31 +2971,37 @@ function checkUpdateLogContents(aCompareLogFile, aExcludeDistributionDir) {
       !gTestFiles[gTestFiles.length - 1].originalContents) {
     updateLogContents = updateLogContents.replace(/.*defaults\/.*/g, "");
   }
+
   if (gTestFiles.length > 2 &&
       gTestFiles[gTestFiles.length - 2].fileName == FILE_UPDATE_SETTINGS_INI &&
       !gTestFiles[gTestFiles.length - 2].originalContents) {
     updateLogContents = updateLogContents.replace(/.*update-settings.ini.*/g, "");
   }
-  if (gStageUpdate) {
-    // Skip the staged update messages
-    updateLogContents = updateLogContents.replace(/Performing a staged update/, "");
-  } else if (gSwitchApp) {
-    // Skip the switch app request messages
-    updateLogContents = updateLogContents.replace(/Performing a staged update/, "");
-    updateLogContents = updateLogContents.replace(/Performing a replace request/, "");
-  }
+
   // Skip the source/destination lines since they contain absolute paths.
+  // These could be changed to relative paths using <test_dir_path> and
+  // <update_dir_path>
   updateLogContents = updateLogContents.replace(/PATCH DIRECTORY.*/g, "");
   updateLogContents = updateLogContents.replace(/INSTALLATION DIRECTORY.*/g, "");
   updateLogContents = updateLogContents.replace(/WORKING DIRECTORY.*/g, "");
   // Skip lines that log failed attempts to open the callback executable.
   updateLogContents = updateLogContents.replace(/NS_main: callback app file .*/g, "");
+
   if (IS_MACOSX) {
     // Skip lines that log moving the distribution directory for Mac v2 signing.
     updateLogContents = updateLogContents.replace(/Moving old [^\n]*\nrename_file: .*/g, "");
     updateLogContents = updateLogContents.replace(/New distribution directory .*/g, "");
   }
-  if (gSwitchApp) {
+
+  if (IS_WIN) {
+    // The FindFile results when enumerating the filesystem on Windows is not
+    // determistic so the results matching the following need to be fixed.
+    let re = new RegExp("([^\n]* 7\/7text1[^\n]*)\n" +
+                        "([^\n]* 7\/7text0[^\n]*)\n", "g");
+    updateLogContents = updateLogContents.replace(re, "$2\n$1\n");
+  }
+
+  if (aReplace) {
     // Remove the lines which contain absolute paths
     updateLogContents = updateLogContents.replace(/^Begin moving.*$/mg, "");
     updateLogContents = updateLogContents.replace(/^ensure_remove: failed to remove file: .*$/mg, "");
@@ -2556,27 +3009,29 @@ function checkUpdateLogContents(aCompareLogFile, aExcludeDistributionDir) {
     updateLogContents = updateLogContents.replace(/^Removing tmpDir failed, err: -1$/mg, "");
     updateLogContents = updateLogContents.replace(/^remove_recursive_on_reboot: .*$/mg, "");
   }
+
+  // Remove carriage returns.
   updateLogContents = updateLogContents.replace(/\r/g, "");
   // Replace error codes since they are different on each platform.
   updateLogContents = updateLogContents.replace(/, err:.*\n/g, "\n");
   // Replace to make the log parsing happy.
   updateLogContents = updateLogContents.replace(/non-fatal error /g, "");
-  // The FindFile results when enumerating the filesystem on Windows is not
-  // determistic so the results matching the following need to be ignored.
-  updateLogContents = updateLogContents.replace(/.*7\/7text.*\n/g, "");
   // Remove consecutive newlines
   updateLogContents = updateLogContents.replace(/\n+/g, "\n");
   // Remove leading and trailing newlines
   updateLogContents = updateLogContents.replace(/^\n|\n$/g, "");
+  // Replace the log paths with <test_dir_path> and <update_dir_path>
   updateLogContents = replaceLogPaths(updateLogContents);
 
   let compareLogContents = "";
   if (aCompareLogFile) {
     compareLogContents = readFileBytes(getTestDirFile(aCompareLogFile));
   }
-  if (gSwitchApp) {
-    compareLogContents += LOG_SWITCH_SUCCESS;
+
+  if (aStaged) {
+    compareLogContents = PERFORMING_STAGED_UPDATE + "\n" + compareLogContents;
   }
+
   // The channel-prefs.js is defined in gTestFilesCommon which will always be
   // located to the end of gTestFiles.
   if (gTestFiles.length > 1 &&
@@ -2584,14 +3039,17 @@ function checkUpdateLogContents(aCompareLogFile, aExcludeDistributionDir) {
       !gTestFiles[gTestFiles.length - 1].originalContents) {
     compareLogContents = compareLogContents.replace(/.*defaults\/.*/g, "");
   }
+
   if (gTestFiles.length > 2 &&
       gTestFiles[gTestFiles.length - 2].fileName == FILE_UPDATE_SETTINGS_INI &&
       !gTestFiles[gTestFiles.length - 2].originalContents) {
     compareLogContents = compareLogContents.replace(/.*update-settings.ini.*/g, "");
   }
-  if (aExcludeDistributionDir) {
+
+  if (aExcludeDistDir) {
     compareLogContents = compareLogContents.replace(/.*distribution\/.*/g, "");
   }
+
   // Remove leading and trailing newlines
   compareLogContents = compareLogContents.replace(/\n+/g, "\n");
   // Remove leading and trailing newlines
@@ -2603,14 +3061,15 @@ function checkUpdateLogContents(aCompareLogFile, aExcludeDistributionDir) {
     Assert.ok(true, "the update log contents" + MSG_SHOULD_EQUAL);
   } else {
     logTestInfo("the update log contents are not correct");
+    logUpdateLog(FILE_LAST_UPDATE_LOG);
     let aryLog = updateLogContents.split("\n");
     let aryCompare = compareLogContents.split("\n");
     // Pushing an empty string to both arrays makes it so either array's length
     // can be used in the for loop below without going out of bounds.
     aryLog.push("");
     aryCompare.push("");
-    // xpcshell tests won't display the entire contents so log the incorrect
-    // line.
+    // xpcshell tests won't display the entire contents so log the first
+    // incorrect line.
     for (let i = 0; i < aryLog.length; ++i) {
       if (aryLog[i] != aryCompare[i]) {
         logTestInfo("the first incorrect line in the update log is: " +
@@ -2631,9 +3090,8 @@ function checkUpdateLogContents(aCompareLogFile, aExcludeDistributionDir) {
  *          The string to check if the update log contains.
  */
 function checkUpdateLogContains(aCheckString) {
-  let updateLog = getUpdatesPatchDir();
-  updateLog.append(FILE_UPDATE_LOG);
-  let updateLogContents = readFileBytes(updateLog);
+  let updateLog = getUpdateLog(FILE_LAST_UPDATE_LOG);
+  let updateLogContents = readFileBytes(updateLog).replace(/\r\n/g, "\n");
   updateLogContents = replaceLogPaths(updateLogContents);
   Assert.notEqual(updateLogContents.indexOf(aCheckString), -1,
                   "the update log contents should contain value: " +
@@ -2644,25 +3102,26 @@ function checkUpdateLogContains(aCheckString) {
  * Helper function for updater binary tests for verifying the state of files and
  * directories after a successful update.
  *
- * @param  aGetFileFunc
- *         The function used to get the files in the directory to be checked.
- * @param  aStageDirExists
- *         If true the staging directory will be tested for existence and if
- *         false the staging directory will be tested for non-existence.
- * @param  aToBeDeletedDirExists
- *         On Windows, if true the tobedeleted directory will be tested for
- *         existence and if false the tobedeleted directory will be tested for
- *         non-existence. On all othere platforms it will be tested for
- *         non-existence.
+ * @param   aGetFileFunc
+ *          The function used to get the files in the directory to be checked.
+ * @param   aStageDirExists
+ *          If true the staging directory will be tested for existence and if
+ *          false the staging directory will be tested for non-existence.
+ * @param   aToBeDeletedDirExists
+ *          On Windows, if true the tobedeleted directory will be tested for
+ *          existence and if false the tobedeleted directory will be tested for
+ *          non-existence. On all othere platforms it will be tested for
+ *          non-existence.
  */
-function checkFilesAfterUpdateSuccess(aGetFileFunc, aStageDirExists,
-                                      aToBeDeletedDirExists) {
+function checkFilesAfterUpdateSuccess(aGetFileFunc, aStageDirExists = false,
+                                      aToBeDeletedDirExists = false) {
   debugDump("testing contents of files after a successful update");
   gTestFiles.forEach(function CFAUS_TF_FE(aTestFile) {
     let testFile = aGetFileFunc(aTestFile.relPathDir + aTestFile.fileName, true);
     debugDump("testing file: " + testFile.path);
     if (aTestFile.compareFile || aTestFile.compareContents) {
-      Assert.ok(testFile.exists(), MSG_SHOULD_EXIST);
+      Assert.ok(testFile.exists(),
+                MSG_SHOULD_EXIST + getMsgPath(testFile.path));
 
       // Skip these tests on Windows since chmod doesn't really set permissions
       // on Windows.
@@ -2686,7 +3145,8 @@ function checkFilesAfterUpdateSuccess(aGetFileFunc, aStageDirExists,
                      "the file contents" + MSG_SHOULD_EQUAL);
       }
     } else {
-      Assert.ok(!testFile.exists(), MSG_SHOULD_NOT_EXIST);
+      Assert.ok(!testFile.exists(),
+                MSG_SHOULD_NOT_EXIST + getMsgPath(testFile.path));
     }
   });
 
@@ -2696,17 +3156,21 @@ function checkFilesAfterUpdateSuccess(aGetFileFunc, aStageDirExists,
     let testDir = aGetFileFunc(aTestDir.relPathDir, true);
     debugDump("testing directory: " + testDir.path);
     if (aTestDir.dirRemoved) {
-      Assert.ok(!testDir.exists(), MSG_SHOULD_NOT_EXIST);
+      Assert.ok(!testDir.exists(),
+                MSG_SHOULD_NOT_EXIST + getMsgPath(testDir.path));
     } else {
-      Assert.ok(testDir.exists(), MSG_SHOULD_EXIST);
+      Assert.ok(testDir.exists(),
+                MSG_SHOULD_EXIST + getMsgPath(testDir.path));
 
       if (aTestDir.files) {
         aTestDir.files.forEach(function CFAUS_TD_F_FE(aTestFile) {
           let testFile = aGetFileFunc(aTestDir.relPathDir + aTestFile, true);
           if (aTestDir.filesRemoved) {
-            Assert.ok(!testFile.exists(), MSG_SHOULD_NOT_EXIST);
+            Assert.ok(!testFile.exists(),
+                      MSG_SHOULD_NOT_EXIST + getMsgPath(testFile.path));
           } else {
-            Assert.ok(testFile.exists(), MSG_SHOULD_EXIST);
+            Assert.ok(testFile.exists(),
+                      MSG_SHOULD_EXIST + getMsgPath(testFile.path));
           }
         });
       }
@@ -2714,12 +3178,14 @@ function checkFilesAfterUpdateSuccess(aGetFileFunc, aStageDirExists,
       if (aTestDir.subDirs) {
         aTestDir.subDirs.forEach(function CFAUS_TD_SD_FE(aSubDir) {
           let testSubDir = aGetFileFunc(aTestDir.relPathDir + aSubDir, true);
-          Assert.ok(testSubDir.exists(), MSG_SHOULD_EXIST);
+          Assert.ok(testSubDir.exists(),
+                    MSG_SHOULD_EXIST + getMsgPath(testSubDir.path));
           if (aTestDir.subDirFiles) {
             aTestDir.subDirFiles.forEach(function CFAUS_TD_SDF_FE(aTestFile) {
               let testFile = aGetFileFunc(aTestDir.relPathDir +
                                           aSubDir + aTestFile, true);
-              Assert.ok(testFile.exists(), MSG_SHOULD_EXIST);
+              Assert.ok(testFile.exists(),
+                        MSG_SHOULD_EXIST + getMsgPath(testFile.path));
             });
           }
         });
@@ -2735,25 +3201,26 @@ function checkFilesAfterUpdateSuccess(aGetFileFunc, aStageDirExists,
  * Helper function for updater binary tests for verifying the state of files and
  * directories after a failed update.
  *
- * @param aGetFileFunc
- *        the function used to get the files in the directory to be checked.
- * @param  aStageDirExists
- *         If true the staging directory will be tested for existence and if
- *         false the staging directory will be tested for non-existence.
- * @param  aToBeDeletedDirExists
- *         On Windows, if true the tobedeleted directory will be tested for
- *         existence and if false the tobedeleted directory will be tested for
- *         non-existence. On all othere platforms it will be tested for
- *         non-existence.
+ * @param   aGetFileFunc
+ *          The function used to get the files in the directory to be checked.
+ * @param   aStageDirExists
+ *          If true the staging directory will be tested for existence and if
+ *          false the staging directory will be tested for non-existence.
+ * @param   aToBeDeletedDirExists
+ *          On Windows, if true the tobedeleted directory will be tested for
+ *          existence and if false the tobedeleted directory will be tested for
+ *          non-existence. On all othere platforms it will be tested for
+ *          non-existence.
  */
-function checkFilesAfterUpdateFailure(aGetFileFunc, aStageDirExists,
-                                      aToBeDeletedDirExists) {
+function checkFilesAfterUpdateFailure(aGetFileFunc, aStageDirExists = false,
+                                      aToBeDeletedDirExists = false) {
   debugDump("testing contents of files after a failed update");
   gTestFiles.forEach(function CFAUF_TF_FE(aTestFile) {
     let testFile = aGetFileFunc(aTestFile.relPathDir + aTestFile.fileName, true);
     debugDump("testing file: " + testFile.path);
     if (aTestFile.compareFile || aTestFile.compareContents) {
-      Assert.ok(testFile.exists(), MSG_SHOULD_EXIST);
+      Assert.ok(testFile.exists(),
+                MSG_SHOULD_EXIST + getMsgPath(testFile.path));
 
       // Skip these tests on Windows since chmod doesn't really set permissions
       // on Windows.
@@ -2777,7 +3244,8 @@ function checkFilesAfterUpdateFailure(aGetFileFunc, aStageDirExists,
                      "the file contents" + MSG_SHOULD_EQUAL);
       }
     } else {
-      Assert.ok(!testFile.exists(), MSG_SHOULD_NOT_EXIST);
+      Assert.ok(!testFile.exists(),
+                MSG_SHOULD_NOT_EXIST + getMsgPath(testFile.path));
     }
   });
 
@@ -2785,24 +3253,28 @@ function checkFilesAfterUpdateFailure(aGetFileFunc, aStageDirExists,
             "performed after a failed update");
   gTestDirs.forEach(function CFAUF_TD_FE(aTestDir) {
     let testDir = aGetFileFunc(aTestDir.relPathDir, true);
-    Assert.ok(testDir.exists(), MSG_SHOULD_EXIST);
+    Assert.ok(testDir.exists(),
+              MSG_SHOULD_EXIST + getMsgPath(testDir.path));
 
     if (aTestDir.files) {
       aTestDir.files.forEach(function CFAUS_TD_F_FE(aTestFile) {
         let testFile = aGetFileFunc(aTestDir.relPathDir + aTestFile, true);
-        Assert.ok(testFile.exists(), MSG_SHOULD_EXIST);
+        Assert.ok(testFile.exists(),
+                  MSG_SHOULD_EXIST + getMsgPath(testFile.path));
       });
     }
 
     if (aTestDir.subDirs) {
       aTestDir.subDirs.forEach(function CFAUS_TD_SD_FE(aSubDir) {
         let testSubDir = aGetFileFunc(aTestDir.relPathDir + aSubDir, true);
-        Assert.ok(testSubDir.exists(), MSG_SHOULD_EXIST);
+        Assert.ok(testSubDir.exists(),
+                  MSG_SHOULD_EXIST + getMsgPath(testSubDir.path));
         if (aTestDir.subDirFiles) {
           aTestDir.subDirFiles.forEach(function CFAUS_TD_SDF_FE(aTestFile) {
             let testFile = aGetFileFunc(aTestDir.relPathDir +
                                         aSubDir + aTestFile, true);
-            Assert.ok(testFile.exists(), MSG_SHOULD_EXIST);
+            Assert.ok(testFile.exists(),
+                      MSG_SHOULD_EXIST + getMsgPath(testFile.path));
           });
         }
       });
@@ -2817,42 +3289,48 @@ function checkFilesAfterUpdateFailure(aGetFileFunc, aStageDirExists,
  * Helper function for updater binary tests for verifying the state of common
  * files and directories after a successful or failed update.
  *
- * @param aGetFileFunc
- *        the function used to get the files in the directory to be checked.
- * @param  aStageDirExists
- *         If true the staging directory will be tested for existence and if
- *         false the staging directory will be tested for non-existence.
- * @param  aToBeDeletedDirExists
- *         On Windows, if true the tobedeleted directory will be tested for
- *         existence and if false the tobedeleted directory will be tested for
- *         non-existence. On all othere platforms it will be tested for
- *         non-existence.
+ * @param   aGetFileFunc
+ *          the function used to get the files in the directory to be checked.
+ * @param   aStageDirExists
+ *          If true the staging directory will be tested for existence and if
+ *          false the staging directory will be tested for non-existence.
+ * @param   aToBeDeletedDirExists
+ *          On Windows, if true the tobedeleted directory will be tested for
+ *          existence and if false the tobedeleted directory will be tested for
+ *          non-existence. On all othere platforms it will be tested for
+ *          non-existence.
  */
 function checkFilesAfterUpdateCommon(aGetFileFunc, aStageDirExists,
                                      aToBeDeletedDirExists) {
   debugDump("testing extra directories");
   let stageDir = getStageDirFile(null, true);
   if (aStageDirExists) {
-    Assert.ok(stageDir.exists(), MSG_SHOULD_EXIST);
+    Assert.ok(stageDir.exists(),
+              MSG_SHOULD_EXIST + getMsgPath(stageDir.path));
   } else {
-    Assert.ok(!stageDir.exists(), MSG_SHOULD_NOT_EXIST);
+    Assert.ok(!stageDir.exists(),
+              MSG_SHOULD_NOT_EXIST + getMsgPath(stageDir.path));
   }
 
   let toBeDeletedDirExists = IS_WIN ? aToBeDeletedDirExists : false;
   let toBeDeletedDir = getApplyDirFile(DIR_TOBEDELETED, true);
   if (toBeDeletedDirExists) {
-    Assert.ok(toBeDeletedDir.exists(), MSG_SHOULD_EXIST);
+    Assert.ok(toBeDeletedDir.exists(),
+              MSG_SHOULD_EXIST + getMsgPath(toBeDeletedDir.path));
   } else {
-    Assert.ok(!toBeDeletedDir.exists(), MSG_SHOULD_NOT_EXIST);
+    Assert.ok(!toBeDeletedDir.exists(),
+              MSG_SHOULD_NOT_EXIST + getMsgPath(toBeDeletedDir.path));
   }
 
   let updatingDir = getApplyDirFile("updating", true);
-  Assert.ok(!updatingDir.exists(), MSG_SHOULD_NOT_EXIST);
+  Assert.ok(!updatingDir.exists(),
+            MSG_SHOULD_NOT_EXIST + getMsgPath(updatingDir.path));
 
   if (stageDir.exists()) {
     updatingDir = stageDir.clone();
     updatingDir.append("updating");
-    Assert.ok(!updatingDir.exists(), MSG_SHOULD_NOT_EXIST);
+    Assert.ok(!updatingDir.exists(),
+              MSG_SHOULD_NOT_EXIST + getMsgPath(updatingDir.path));
   }
 
   debugDump("testing backup files should not be left behind in the " +
@@ -2873,7 +3351,19 @@ function checkFilesAfterUpdateCommon(aGetFileFunc, aStageDirExists,
   while (entries.hasMoreElements()) {
     let entry = entries.getNext().QueryInterface(Ci.nsIFile);
     Assert.notEqual(getFileExtension(entry), "patch",
-                    "the file's extension should not equal patch");
+                    "the file's extension should not equal patch" +
+                    getMsgPath(entry.path));
+  }
+}
+
+/**
+ * Calls the appropriate callback log check for service and non-service tests.
+ */
+function checkCallbackLog() {
+  if (IS_SERVICE_TEST) {
+    checkCallbackServiceLog();
+  } else {
+    checkCallbackAppLog();
   }
 }
 
@@ -2885,7 +3375,7 @@ function checkFilesAfterUpdateCommon(aGetFileFunc, aStageDirExists,
 function checkCallbackAppLog() {
   let appLaunchLog = getApplyDirFile(DIR_RESOURCES + gCallbackArgs[1], true);
   if (!appLaunchLog.exists()) {
-    do_timeout(TEST_HELPER_TIMEOUT, checkCallbackAppLog);
+    do_execute_soon(checkCallbackAppLog);
     return;
   }
 
@@ -2921,7 +3411,7 @@ function checkCallbackAppLog() {
       // This should never happen!
       do_throw("Unable to find incorrect callback log contents!");
     }
-    do_timeout(TEST_HELPER_TIMEOUT, checkCallbackAppLog);
+    do_execute_soon(checkCallbackAppLog);
     return;
   }
   Assert.ok(true, "the callback log contents" + MSG_SHOULD_EQUAL);
@@ -2942,41 +3432,44 @@ function getPostUpdateFile(aSuffix) {
 }
 
 /**
- * Helper function for updater binary tests for verifying the contents of the
- * updater post update binary log.
+ * Checks the contents of the updater post update binary log. When completed
+ * checkPostUpdateAppLogFinished will be called.
  */
 function checkPostUpdateAppLog() {
-  gTimeoutRuns++;
-  let postUpdateLog = getPostUpdateFile(".log");
-  if (!postUpdateLog.exists()) {
-    debugDump("postUpdateLog does not exist. Path: " + postUpdateLog.path);
-    if (gTimeoutRuns > MAX_TIMEOUT_RUNS) {
-      do_throw("Exceeded MAX_TIMEOUT_RUNS while waiting for the post update " +
-               "process to create the post update log. Path: " +
-               postUpdateLog.path);
+  // Only Mac OS X and Windows support post update.
+  if (IS_MACOSX || IS_WIN) {
+    gTimeoutRuns++;
+    let postUpdateLog = getPostUpdateFile(".log");
+    if (!postUpdateLog.exists()) {
+      debugDump("postUpdateLog does not exist. Path: " + postUpdateLog.path);
+      if (gTimeoutRuns > MAX_TIMEOUT_RUNS) {
+        do_throw("Exceeded MAX_TIMEOUT_RUNS while waiting for the post update " +
+                 "process to create the post update log. Path: " +
+                 postUpdateLog.path);
+      }
+      do_execute_soon(checkPostUpdateAppLog);
+      return;
     }
-    do_timeout(TEST_HELPER_TIMEOUT, checkPostUpdateAppLog);
-    return;
+
+    let logContents = readFile(postUpdateLog);
+    // It is possible for the log file contents check to occur before the log file
+    // contents are completely written so wait until the contents are the expected
+    // value. If the contents are never the expected value then the test will
+    // fail by timing out after gTimeoutRuns is greater than MAX_TIMEOUT_RUNS or
+    // the test harness times out the test.
+    if (logContents != "post-update\n") {
+      if (gTimeoutRuns > MAX_TIMEOUT_RUNS) {
+        do_throw("Exceeded MAX_TIMEOUT_RUNS while waiting for the post update " +
+                 "process to create the expected contents in the post update log. Path: " +
+                 postUpdateLog.path);
+      }
+      do_execute_soon(checkPostUpdateAppLog);
+      return;
+    }
+    Assert.ok(true, "the post update log contents" + MSG_SHOULD_EQUAL);
   }
 
-  let logContents = readFile(postUpdateLog);
-  // It is possible for the log file contents check to occur before the log file
-  // contents are completely written so wait until the contents are the expected
-  // value. If the contents are never the expected value then the test will
-  // fail by timing out after gTimeoutRuns is greater than MAX_TIMEOUT_RUNS or
-  // the test harness times out the test.
-  if (logContents != "post-update\n") {
-    if (gTimeoutRuns > MAX_TIMEOUT_RUNS) {
-      do_throw("Exceeded MAX_TIMEOUT_RUNS while waiting for the post update " +
-               "process to create the expected contents in the post update log. Path: " +
-               postUpdateLog.path);
-    }
-    do_timeout(TEST_HELPER_TIMEOUT, checkPostUpdateAppLog);
-    return;
-  }
-  Assert.ok(true, "the post update log contents" + MSG_SHOULD_EQUAL);
-
-  gCheckFunc();
+  do_execute_soon(checkPostUpdateAppLogFinished);
 }
 
 /**
@@ -3020,7 +3513,7 @@ function checkCallbackServiceLog() {
       // This should never happen!
       do_throw("Unable to find incorrect service callback log contents!");
     }
-    do_timeout(TEST_HELPER_TIMEOUT, checkCallbackServiceLog);
+    do_execute_soon(checkCallbackServiceLog);
     return;
   }
   Assert.ok(true, "the callback service log contents" + MSG_SHOULD_EQUAL);
@@ -3029,15 +3522,22 @@ function checkCallbackServiceLog() {
 }
 
 // Waits until files that are in use that break tests are no longer in use and
-// then calls do_test_finished.
+// then calls doTestFinish to end the test.
 function waitForFilesInUse() {
   if (IS_WIN) {
+    if (isProcessRunning(FILE_UPDATER_BIN)) {
+      do_execute_soon(waitForFilesInUse);
+      return;
+    }
+    if (isProcessRunning(FILE_MAINTENANCE_SERVICE_INSTALLER_BIN)) {
+      do_execute_soon(waitForFilesInUse);
+      return;
+    }
+
     let appBin = getApplyDirFile(FILE_APP_BIN, true);
     let maintSvcInstaller = getApplyDirFile(FILE_MAINTENANCE_SERVICE_INSTALLER_BIN, true);
     let helper = getApplyDirFile("uninstall/helper.exe", true);
-    let updater = getUpdatesPatchDir();
-    updater.append(FILE_UPDATER_BIN);
-
+    let updater = getApplyDirFile(FILE_UPDATER_BIN, true);
     let files = [appBin, updater, maintSvcInstaller, helper];
 
     for (let i = 0; i < files.length; ++i) {
@@ -3052,19 +3552,19 @@ function waitForFilesInUse() {
           file.copyTo(fileBak.parent, fileBak.leafName);
           file.remove(false);
           fileBak.moveTo(file.parent, file.leafName);
-          debugDump("file is not in use. Path: " + file.path);
+          debugDump("file is not in use, path: " + file.path);
         } catch (e) {
-          debugDump("file in use, will try again after " + TEST_CHECK_TIMEOUT +
-                    " ms, Path: " + file.path + ", Exception: " + e);
+          debugDump("will try again to remove file in use, path: " +
+                    file.path + ", exception: " + e);
           try {
             if (fileBak.exists()) {
               fileBak.remove(false);
             }
           } catch (e) {
-            logTestInfo("unable to remove file, this should never happen! " +
-                        "Path: " + fileBak.path + ", Exception: " + e);
+            logTestInfo("unable to remove backup file, path: " +
+                        fileBak.path + ", exception: " + e);
           }
-          do_timeout(TEST_CHECK_TIMEOUT, waitForFilesInUse);
+          do_execute_soon(waitForFilesInUse);
           return;
         }
       }
@@ -3084,7 +3584,8 @@ function waitForFilesInUse() {
  */
 function checkForBackupFiles(aFile) {
   Assert.notEqual(getFileExtension(aFile), "moz-backup",
-                  "the file's extension should not equal moz-backup");
+                  "the file's extension should not equal moz-backup" +
+                  getMsgPath(aFile.path));
 }
 
 /**
@@ -3107,10 +3608,12 @@ function checkFilesInDirRecursive(aDir, aCallback) {
   while (dirEntries.hasMoreElements()) {
     let entry = dirEntries.getNext().QueryInterface(Ci.nsIFile);
 
-    if (entry.isDirectory()) {
-      checkFilesInDirRecursive(entry, aCallback);
-    } else {
-      aCallback(entry);
+    if (entry.exists()) {
+      if (entry.isDirectory()) {
+        checkFilesInDirRecursive(entry, aCallback);
+      } else {
+        aCallback(entry);
+      }
     }
   }
 }
@@ -3135,7 +3638,6 @@ function overrideXHR(aCallback) {
   MockRegistrar.register("@mozilla.org/xmlextras/xmlhttprequest;1", xhr, [aCallback]);
 }
 
-
 /**
  * Bare bones XMLHttpRequest implementation for testing onprogress, onerror,
  * and onload nsIDomEventListener handleEvent.
@@ -3428,8 +3930,7 @@ function getProcessArgs(aExtraArgs) {
  * @return  the file for the application to dump its arguments into.
  */
 function getAppArgsLogPath() {
-  let appArgsLog = do_get_file("/", true);
-  appArgsLog.append(gTestID + "_app_args_log");
+  let appArgsLog = do_get_file("/" + gTestID + "_app_args_log", true);
   if (appArgsLog.exists()) {
     appArgsLog.remove(false);
   }
@@ -3447,8 +3948,7 @@ function getAppArgsLogPath() {
  * @return  the nsIFile for the shell script to launch the application.
  */
 function getLaunchScript() {
-  let launchScript = do_get_file("/", true);
-  launchScript.append(gTestID + "_launch.sh");
+  let launchScript = do_get_file("/" + gTestID + "_launch.sh", true);
   if (launchScript.exists()) {
     launchScript.remove(false);
   }
@@ -3545,17 +4045,82 @@ function adjustGeneralPaths() {
 
 
 /**
- * Helper function for launching the application to apply an update.
+ * Launches an application to apply an update.
  */
-function launchAppToApplyUpdate() {
+function runUpdateUsingApp(aExpectedStatus) {
+  /**
+   * The observer for the call to nsIProcess:runAsync. When completed
+   * runUpdateFinished will be called.
+   */
+  const processObserver = {
+    observe: function PO_observe(aSubject, aTopic, aData) {
+      debugDump("topic: " + aTopic + ", process exitValue: " +
+                gProcess.exitValue);
+      resetEnvironment();
+      if (gAppTimer) {
+        gAppTimer.cancel();
+        gAppTimer = null;
+      }
+      Assert.equal(gProcess.exitValue, 0,
+                   "the application process exit value should be 0");
+      Assert.equal(aTopic, "process-finished",
+                   "the application process observer topic should be " +
+                   "process-finished");
+
+      if (IS_SERVICE_TEST) {
+        waitForServiceStop();
+      }
+
+      do_execute_soon(afterAppExits);
+    },
+    QueryInterface: XPCOMUtils.generateQI([Ci.nsIObserver])
+  };
+
+  function afterAppExits() {
+    gTimeoutRuns++;
+
+    if (IS_WIN) {
+      waitForApplicationStop(FILE_UPDATER_BIN);
+    }
+
+    let status;
+    try {
+      status = readStatusFile();
+    } catch (e) {
+      logTestInfo("error reading status file, exception: "+ e);
+    }
+    // Don't proceed until the update's status is the expected value.
+    if (status != aExpectedStatus) {
+      if (gTimeoutRuns > MAX_TIMEOUT_RUNS) {
+        logUpdateLog(FILE_UPDATE_LOG);
+        do_throw("Exceeded MAX_TIMEOUT_RUNS while waiting for the update " +
+                 "status to equal: " +
+                 aExpectedStatus +
+                 ", current status: " + status);
+      } else {
+        do_execute_soon(afterAppExits);
+      }
+      return;
+    }
+
+    // Don't proceed until the update log has been created.
+    let log = getUpdateLog(FILE_UPDATE_LOG);
+    if (!log.exists()) {
+      if (gTimeoutRuns > MAX_TIMEOUT_RUNS) {
+        do_throw("Exceeded MAX_TIMEOUT_RUNS while waiting for the update log " +
+                 "to be created. Path: " + log.path);
+      }
+      do_execute_soon(afterAppExits);
+      return;
+    }
+
+    do_execute_soon(runUpdateFinished);
+  }
+
   debugDump("start - launching application to apply update");
 
   let appBin = getApplyDirFile(DIR_MACOS + FILE_APP_BIN, false);
 
-  if (typeof(customLaunchAppToApplyUpdate) == typeof(Function)) {
-    customLaunchAppToApplyUpdate();
-  }
-
   let launchBin = getLaunchBin();
   let args = getProcessArgs();
   debugDump("launching " + launchBin.path + " " + args.join(" "));
@@ -3565,42 +4130,20 @@ function launchAppToApplyUpdate() {
   gProcess.init(launchBin);
 
   gAppTimer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer);
-  gAppTimer.initWithCallback(gTimerCallback, APP_TIMER_TIMEOUT,
+  gAppTimer.initWithCallback(gAppTimerCallback, APP_TIMER_TIMEOUT,
                              Ci.nsITimer.TYPE_ONE_SHOT);
 
   setEnvironment();
   debugDump("launching application");
-  gProcess.runAsync(args, args.length, gProcessObserver);
-  resetEnvironment();
+  gProcess.runAsync(args, args.length, processObserver);
 
   debugDump("finish - launching application to apply update");
 }
 
-/**
- * The observer for the call to nsIProcess:runAsync.
- */
-const gProcessObserver = {
-  observe: function PO_observe(aSubject, aTopic, aData) {
-    debugDump("topic: " + aTopic + ", process exitValue: " +
-              gProcess.exitValue);
-    if (gAppTimer) {
-      gAppTimer.cancel();
-      gAppTimer = null;
-    }
-    Assert.equal(gProcess.exitValue, 0,
-                 "the application process exit value should be 0");
-    Assert.equal(aTopic, "process-finished",
-                 "the application process observer topic should be " +
-                 "process-finished");
-    do_timeout(TEST_CHECK_TIMEOUT, checkUpdateFinished);
-  },
-  QueryInterface: XPCOMUtils.generateQI([Ci.nsIObserver])
-};
-
 /**
  * The timer callback to kill the process if it takes too long.
  */
-const gTimerCallback = {
+const gAppTimerCallback = {
   notify: function TC_notify(aTimer) {
     gAppTimer = null;
     if (gProcess.isRunning) {
@@ -3617,9 +4160,15 @@ const gTimerCallback = {
  */
 const gUpdateStagedObserver = {
   observe: function(aSubject, aTopic, aData) {
+    debugDump("observe called with topic: " + aTopic + ", data: " + aData);
     if (aTopic == "update-staged") {
+      // The environment is reset after the update-staged observer topic because
+      // processUpdate in nsIUpdateProcessor uses a new thread and clearing the
+      // environment immediately after calling processUpdate can clear the
+      // environment before the updater is launched.
+      resetEnvironment();
       Services.obs.removeObserver(gUpdateStagedObserver, "update-staged");
-      checkUpdateApplied();
+      checkUpdateStagedState(aData);
     }
   },
   QueryInterface: XPCOMUtils.generateQI([Ci.nsIObserver])
@@ -3637,13 +4186,11 @@ function setEnvironment() {
 
   gShouldResetEnv = true;
 
-  let env = Cc["@mozilla.org/process/environment;1"].
-            getService(Ci.nsIEnvironment);
-  if (IS_WIN && !env.exists("XRE_NO_WINDOWS_CRASH_DIALOG")) {
+  if (IS_WIN && !gEnv.exists("XRE_NO_WINDOWS_CRASH_DIALOG")) {
     gAddedEnvXRENoWindowsCrashDialog = true;
     debugDump("setting the XRE_NO_WINDOWS_CRASH_DIALOG environment " +
               "variable to 1... previously it didn't exist");
-    env.set("XRE_NO_WINDOWS_CRASH_DIALOG", "1");
+    gEnv.set("XRE_NO_WINDOWS_CRASH_DIALOG", "1");
   }
 
   if (IS_UNIX) {
@@ -3652,8 +4199,8 @@ function setEnvironment() {
                        createInstance(Ci.nsILocalFile);
     let shouldSetEnv = true;
     if (IS_MACOSX) {
-      if (env.exists("DYLD_LIBRARY_PATH")) {
-        gEnvDyldLibraryPath = env.get("DYLD_LIBRARY_PATH");
+      if (gEnv.exists("DYLD_LIBRARY_PATH")) {
+        gEnvDyldLibraryPath = gEnv.get("DYLD_LIBRARY_PATH");
         envGreBinDir.initWithPath(gEnvDyldLibraryPath);
         if (envGreBinDir.path == appGreBinDir.path) {
           gEnvDyldLibraryPath = null;
@@ -3664,11 +4211,11 @@ function setEnvironment() {
       if (shouldSetEnv) {
         debugDump("setting DYLD_LIBRARY_PATH environment variable value to " +
                   appGreBinDir.path);
-        env.set("DYLD_LIBRARY_PATH", appGreBinDir.path);
+        gEnv.set("DYLD_LIBRARY_PATH", appGreBinDir.path);
       }
     } else {
-      if (env.exists("LD_LIBRARY_PATH")) {
-        gEnvLdLibraryPath = env.get("LD_LIBRARY_PATH");
+      if (gEnv.exists("LD_LIBRARY_PATH")) {
+        gEnvLdLibraryPath = gEnv.get("LD_LIBRARY_PATH");
         envGreBinDir.initWithPath(gEnvLdLibraryPath);
         if (envGreBinDir.path == appGreBinDir.path) {
           gEnvLdLibraryPath = null;
@@ -3679,20 +4226,20 @@ function setEnvironment() {
       if (shouldSetEnv) {
         debugDump("setting LD_LIBRARY_PATH environment variable value to " +
                   appGreBinDir.path);
-        env.set("LD_LIBRARY_PATH", appGreBinDir.path);
+        gEnv.set("LD_LIBRARY_PATH", appGreBinDir.path);
       }
     }
   }
 
-  if (env.exists("XPCOM_MEM_LEAK_LOG")) {
-    gEnvXPCOMMemLeakLog = env.get("XPCOM_MEM_LEAK_LOG");
+  if (gEnv.exists("XPCOM_MEM_LEAK_LOG")) {
+    gEnvXPCOMMemLeakLog = gEnv.get("XPCOM_MEM_LEAK_LOG");
     debugDump("removing the XPCOM_MEM_LEAK_LOG environment variable... " +
               "previous value " + gEnvXPCOMMemLeakLog);
-    env.set("XPCOM_MEM_LEAK_LOG", "");
+    gEnv.set("XPCOM_MEM_LEAK_LOG", "");
   }
 
-  if (env.exists("XPCOM_DEBUG_BREAK")) {
-    gEnvXPCOMDebugBreak = env.get("XPCOM_DEBUG_BREAK");
+  if (gEnv.exists("XPCOM_DEBUG_BREAK")) {
+    gEnvXPCOMDebugBreak = gEnv.get("XPCOM_DEBUG_BREAK");
     debugDump("setting the XPCOM_DEBUG_BREAK environment variable to " +
               "warn... previous value " + gEnvXPCOMDebugBreak);
   } else {
@@ -3700,15 +4247,10 @@ function setEnvironment() {
               "warn... previously it didn't exist");
   }
 
-  env.set("XPCOM_DEBUG_BREAK", "warn");
-
-  if (gStageUpdate) {
-    debugDump("setting the MOZ_UPDATE_STAGING environment variable to 1");
-    env.set("MOZ_UPDATE_STAGING", "1");
-  }
+  gEnv.set("XPCOM_DEBUG_BREAK", "warn");
 
   debugDump("setting MOZ_NO_SERVICE_FALLBACK environment variable to 1");
-  env.set("MOZ_NO_SERVICE_FALLBACK", "1");
+  gEnv.set("MOZ_NO_SERVICE_FALLBACK", "1");
 }
 
 /**
@@ -3723,22 +4265,19 @@ function resetEnvironment() {
 
   gShouldResetEnv = false;
 
-  let env = Cc["@mozilla.org/process/environment;1"].
-            getService(Ci.nsIEnvironment);
-
   if (gEnvXPCOMMemLeakLog) {
     debugDump("setting the XPCOM_MEM_LEAK_LOG environment variable back to " +
               gEnvXPCOMMemLeakLog);
-    env.set("XPCOM_MEM_LEAK_LOG", gEnvXPCOMMemLeakLog);
+    gEnv.set("XPCOM_MEM_LEAK_LOG", gEnvXPCOMMemLeakLog);
   }
 
   if (gEnvXPCOMDebugBreak) {
     debugDump("setting the XPCOM_DEBUG_BREAK environment variable back to " +
               gEnvXPCOMDebugBreak);
-    env.set("XPCOM_DEBUG_BREAK", gEnvXPCOMDebugBreak);
-  } else {
+    gEnv.set("XPCOM_DEBUG_BREAK", gEnvXPCOMDebugBreak);
+  } else if (gEnv.exists("XPCOM_DEBUG_BREAK")) {
     debugDump("clearing the XPCOM_DEBUG_BREAK environment variable");
-    env.set("XPCOM_DEBUG_BREAK", "");
+    gEnv.set("XPCOM_DEBUG_BREAK", "");
   }
 
   if (IS_UNIX) {
@@ -3746,19 +4285,19 @@ function resetEnvironment() {
       if (gEnvDyldLibraryPath) {
         debugDump("setting DYLD_LIBRARY_PATH environment variable value " +
                   "back to " + gEnvDyldLibraryPath);
-        env.set("DYLD_LIBRARY_PATH", gEnvDyldLibraryPath);
-      } else {
+        gEnv.set("DYLD_LIBRARY_PATH", gEnvDyldLibraryPath);
+      } else if (gEnvDyldLibraryPath !== null) {
         debugDump("removing DYLD_LIBRARY_PATH environment variable");
-        env.set("DYLD_LIBRARY_PATH", "");
+        gEnv.set("DYLD_LIBRARY_PATH", "");
       }
     } else {
       if (gEnvLdLibraryPath) {
         debugDump("setting LD_LIBRARY_PATH environment variable value back " +
                   "to " + gEnvLdLibraryPath);
-        env.set("LD_LIBRARY_PATH", gEnvLdLibraryPath);
-      } else {
+        gEnv.set("LD_LIBRARY_PATH", gEnvLdLibraryPath);
+      } else if (gEnvLdLibraryPath !== null) {
         debugDump("removing LD_LIBRARY_PATH environment variable");
-        env.set("LD_LIBRARY_PATH", "");
+        gEnv.set("LD_LIBRARY_PATH", "");
       }
     }
   }
@@ -3766,14 +4305,9 @@ function resetEnvironment() {
   if (IS_WIN && gAddedEnvXRENoWindowsCrashDialog) {
     debugDump("removing the XRE_NO_WINDOWS_CRASH_DIALOG environment " +
               "variable");
-    env.set("XRE_NO_WINDOWS_CRASH_DIALOG", "");
-  }
-
-  if (gStageUpdate) {
-    debugDump("removing the MOZ_UPDATE_STAGING environment variable");
-    env.set("MOZ_UPDATE_STAGING", "");
+    gEnv.set("XRE_NO_WINDOWS_CRASH_DIALOG", "");
   }
 
   debugDump("removing MOZ_NO_SERVICE_FALLBACK environment variable");
-  env.set("MOZ_NO_SERVICE_FALLBACK", "");
+  gEnv.set("MOZ_NO_SERVICE_FALLBACK", "");
 }
diff --git a/toolkit/mozapps/update/tests/moz.build b/toolkit/mozapps/update/tests/moz.build
index 13ec7845ff47..b303789bfee8 100644
--- a/toolkit/mozapps/update/tests/moz.build
+++ b/toolkit/mozapps/update/tests/moz.build
@@ -70,8 +70,10 @@ FINAL_TARGET_FILES += [
     'data/complete.exe',
     'data/complete.mar',
     'data/complete.png',
-    'data/complete_log_success',
+    'data/complete_log_success_gonk',
+    'data/complete_log_success_gonk_stage',
     'data/complete_log_success_mac',
+    'data/complete_log_success_win',
     'data/complete_mac.mar',
     'data/complete_precomplete',
     'data/complete_precomplete_mac',
@@ -82,16 +84,20 @@ FINAL_TARGET_FILES += [
     'data/partial.exe',
     'data/partial.mar',
     'data/partial.png',
-    'data/partial_log_failure',
+    'data/partial_log_failure_gonk',
     'data/partial_log_failure_mac',
-    'data/partial_log_success',
+    'data/partial_log_failure_win',
+    'data/partial_log_success_gonk',
+    'data/partial_log_success_gonk_stage',
     'data/partial_log_success_mac',
+    'data/partial_log_success_win',
     'data/partial_mac.mar',
     'data/partial_precomplete',
     'data/partial_precomplete_mac',
     'data/partial_removed-files',
     'data/partial_removed-files_mac',
     'data/partial_update_manifest',
+    'data/replace_log_success',
     'data/shared.js',
     'data/sharedUpdateXML.js',
     'data/simple.mar',
diff --git a/toolkit/mozapps/update/tests/unit_aus_update/cleanupSuccessLogMove.js b/toolkit/mozapps/update/tests/unit_aus_update/cleanupSuccessLogMove.js
index ec53d149e4c4..d683b9931c35 100644
--- a/toolkit/mozapps/update/tests/unit_aus_update/cleanupSuccessLogMove.js
+++ b/toolkit/mozapps/update/tests/unit_aus_update/cleanupSuccessLogMove.js
@@ -15,27 +15,22 @@ function run_test() {
   writeUpdatesToXMLFile(getLocalUpdatesXMLString(updates), true);
   writeStatusFile(STATE_SUCCEEDED);
 
-  let dir = getUpdatesDir();
-  let log = dir.clone();
-  log.append(DIR_PATCH);
-  log.append(FILE_UPDATE_LOG);
+  let log = getUpdateLog(FILE_UPDATE_LOG);
   writeFile(log, "Last Update Log");
 
   standardInit();
 
   Assert.ok(!log.exists(), MSG_SHOULD_NOT_EXIST);
 
-  log = dir.clone();
-  log.append(FILE_LAST_LOG);
+  log = getUpdateLog(FILE_LAST_UPDATE_LOG);
   Assert.ok(log.exists(), MSG_SHOULD_EXIST);
   Assert.equal(readFile(log), "Last Update Log",
                "the last update log contents" + MSG_SHOULD_EQUAL);
 
-  log = dir.clone();
-  log.append(FILE_BACKUP_LOG);
+  log = getUpdateLog(FILE_BACKUP_UPDATE_LOG);
   Assert.ok(!log.exists(), MSG_SHOULD_NOT_EXIST);
 
-  dir.append(DIR_PATCH);
+  let dir = getUpdatesPatchDir();
   Assert.ok(dir.exists(), MSG_SHOULD_EXIST);
 
   doTestFinish();
diff --git a/toolkit/mozapps/update/tests/unit_aus_update/cleanupSuccessLogsFIFO.js b/toolkit/mozapps/update/tests/unit_aus_update/cleanupSuccessLogsFIFO.js
index cfd005d4866b..8be93d0ff591 100644
--- a/toolkit/mozapps/update/tests/unit_aus_update/cleanupSuccessLogsFIFO.js
+++ b/toolkit/mozapps/update/tests/unit_aus_update/cleanupSuccessLogsFIFO.js
@@ -15,37 +15,30 @@ function run_test() {
   writeUpdatesToXMLFile(getLocalUpdatesXMLString(updates), true);
   writeStatusFile(STATE_SUCCEEDED);
 
-  let dir = getUpdatesDir();
-  let log = dir.clone();
-  log.append(FILE_LAST_LOG);
+  let log = getUpdateLog(FILE_LAST_UPDATE_LOG);
   writeFile(log, "Backup Update Log");
 
-  log = dir.clone();
-  log.append(FILE_BACKUP_LOG);
+  log = getUpdateLog(FILE_BACKUP_UPDATE_LOG);
   writeFile(log, "To Be Deleted Backup Update Log");
 
-  log = dir.clone();
-  log.append(DIR_PATCH);
-  log.append(FILE_UPDATE_LOG);
+  log = getUpdateLog(FILE_UPDATE_LOG);
   writeFile(log, "Last Update Log");
 
   standardInit();
 
   Assert.ok(!log.exists(), MSG_SHOULD_NOT_EXIST);
 
-  log = dir.clone();
-  log.append(FILE_LAST_LOG);
+  log = getUpdateLog(FILE_LAST_UPDATE_LOG);
   Assert.ok(log.exists(), MSG_SHOULD_EXIST);
   Assert.equal(readFile(log), "Last Update Log",
                "the last update log contents" + MSG_SHOULD_EQUAL);
 
-  log = dir.clone();
-  log.append(FILE_BACKUP_LOG);
+  log = getUpdateLog(FILE_BACKUP_UPDATE_LOG);
   Assert.ok(log.exists(), MSG_SHOULD_EXIST);
   Assert.equal(readFile(log), "Backup Update Log",
                "the backup update log contents" + MSG_SHOULD_EQUAL);
 
-  dir.append(DIR_PATCH);
+  let dir = getUpdatesPatchDir();
   Assert.ok(dir.exists(), MSG_SHOULD_EXIST);
 
   doTestFinish();
diff --git a/toolkit/mozapps/update/tests/unit_aus_update/downloadInterruptedRecovery.js b/toolkit/mozapps/update/tests/unit_aus_update/downloadInterruptedRecovery.js
index dac705cb4285..0c3c9a9df40a 100644
--- a/toolkit/mozapps/update/tests/unit_aus_update/downloadInterruptedRecovery.js
+++ b/toolkit/mozapps/update/tests/unit_aus_update/downloadInterruptedRecovery.js
@@ -227,8 +227,8 @@ function run_test_pt1() {
 // Test disconnecting during an update
 function run_test_pt2() {
   gIncrementalDownloadErrorType = 0;
-  Services.prefs.setIntPref(PREF_APP_UPDATE_SOCKET_ERRORS, 2);
-  Services.prefs.setIntPref(PREF_APP_UPDATE_RETRY_TIMEOUT, 0);
+  Services.prefs.setIntPref(PREF_APP_UPDATE_SOCKET_MAXERRORS, 2);
+  Services.prefs.setIntPref(PREF_APP_UPDATE_RETRYTIMEOUT, 0);
   setResponseBody("MD5", MD5_HASH_SIMPLE_MAR);
 
   let expectedResult;
diff --git a/toolkit/mozapps/update/tests/unit_aus_update/head_update.js b/toolkit/mozapps/update/tests/unit_aus_update/head_update.js
index 2db27288e643..36e398b4a910 100644
--- a/toolkit/mozapps/update/tests/unit_aus_update/head_update.js
+++ b/toolkit/mozapps/update/tests/unit_aus_update/head_update.js
@@ -2,4 +2,6 @@
  * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
+const IS_SERVICE_TEST = false;
+
 load("../data/xpcshellUtilsAUS.js");
diff --git a/toolkit/mozapps/update/tests/unit_aus_update/updateManagerXML.js b/toolkit/mozapps/update/tests/unit_aus_update/updateManagerXML.js
index 9221d97eb6d0..f6cea4bb2c5e 100644
--- a/toolkit/mozapps/update/tests/unit_aus_update/updateManagerXML.js
+++ b/toolkit/mozapps/update/tests/unit_aus_update/updateManagerXML.js
@@ -6,7 +6,7 @@
 function run_test() {
   setupTestCommon();
 
-  debugDump("testing addition of a successful update to " + FILE_UPDATES_DB +
+  debugDump("testing addition of a successful update to " + FILE_UPDATES_XML +
             " and verification of update properties including the format " +
             "prior to bug 530872");
 
diff --git a/toolkit/mozapps/update/tests/unit_aus_update/urlConstruction.js b/toolkit/mozapps/update/tests/unit_aus_update/urlConstruction.js
index 3c2d55124cf5..d6f5cebf9a62 100644
--- a/toolkit/mozapps/update/tests/unit_aus_update/urlConstruction.js
+++ b/toolkit/mozapps/update/tests/unit_aus_update/urlConstruction.js
@@ -171,9 +171,9 @@ function run_test_pt7() {
   let url = URL_PREFIX + "%CHANNEL%/";
   debugDump("testing url constructed with %CHANNEL% - " + url);
   setUpdateURLOverride(url);
-  gDefaultPrefBranch.setCharPref(PREF_APP_PARTNER_BRANCH + "test_partner1",
+  gDefaultPrefBranch.setCharPref(PREFBRANCH_APP_PARTNER + "test_partner1",
                                  "test_partner1");
-  gDefaultPrefBranch.setCharPref(PREF_APP_PARTNER_BRANCH + "test_partner2",
+  gDefaultPrefBranch.setCharPref(PREFBRANCH_APP_PARTNER + "test_partner2",
                                  "test_partner2");
   gUpdateChecker.checkForUpdates(updateCheckListener, true);
 }
diff --git a/toolkit/mozapps/update/tests/unit_aus_update/xpcshell.ini b/toolkit/mozapps/update/tests/unit_aus_update/xpcshell.ini
index bede703ed9ba..9b268c68b6f9 100644
--- a/toolkit/mozapps/update/tests/unit_aus_update/xpcshell.ini
+++ b/toolkit/mozapps/update/tests/unit_aus_update/xpcshell.ini
@@ -31,8 +31,6 @@ skip-if = toolkit != 'gonk'
 [uiSilentPref.js]
 skip-if = toolkit == 'gonk'
 reason = custom nsIUpdatePrompt
-;skip-if = toolkit == 'gonk'
-;reason = custom nsIUpdatePrompt
 [uiUnsupportedAlreadyNotified.js]
 skip-if = toolkit == 'gonk'
 reason = custom nsIUpdatePrompt
diff --git a/toolkit/mozapps/update/tests/unit_base_updater/head_update.js b/toolkit/mozapps/update/tests/unit_base_updater/head_update.js
index 2db27288e643..36e398b4a910 100644
--- a/toolkit/mozapps/update/tests/unit_base_updater/head_update.js
+++ b/toolkit/mozapps/update/tests/unit_base_updater/head_update.js
@@ -2,4 +2,6 @@
  * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
+const IS_SERVICE_TEST = false;
+
 load("../data/xpcshellUtilsAUS.js");
diff --git a/toolkit/mozapps/update/tests/unit_base_updater/marAppApplyDirLockedStageFailure_win.js b/toolkit/mozapps/update/tests/unit_base_updater/marAppApplyDirLockedStageFailure_win.js
index 2abce35a7ad4..92e437f04edd 100644
--- a/toolkit/mozapps/update/tests/unit_base_updater/marAppApplyDirLockedStageFailure_win.js
+++ b/toolkit/mozapps/update/tests/unit_base_updater/marAppApplyDirLockedStageFailure_win.js
@@ -7,79 +7,36 @@
  * apply it.
  */
 
-const START_STATE = STATE_PENDING;
-const END_STATE = STATE_PENDING;
+const STATE_AFTER_STAGE = STATE_PENDING;
 
 function run_test() {
-  if (MOZ_APP_NAME == "xulrunner") {
-    logTestInfo("Unable to run this test on xulrunner");
+  if (!setupTestCommon()) {
     return;
   }
 
-  setupTestCommon();
   gTestFiles = gTestFilesCompleteSuccess;
   gTestDirs = gTestDirsCompleteSuccess;
   setTestFilesAndDirsForFailure();
-  setupUpdaterTest(FILE_COMPLETE_MAR);
-
-  createUpdaterINI(false);
-
-  if (IS_WIN) {
-    Services.prefs.setBoolPref(PREF_APP_UPDATE_SERVICE_ENABLED, false);
-  }
-
-  let channel = Services.prefs.getCharPref(PREF_APP_UPDATE_CHANNEL);
-  let patches = getLocalPatchString(null, null, null, null, null, "true",
-                                    START_STATE);
-  let updates = getLocalUpdateString(patches, null, null, null, null, null,
-                                     null, null, null, null, null, null,
-                                     "true", channel);
-  writeUpdatesToXMLFile(getLocalUpdatesXMLString(updates), true);
-  writeVersionFile(getAppVersion());
-  writeStatusFile(START_STATE);
-
-  reloadUpdateManagerData();
-  Assert.ok(!!gUpdateManager.activeUpdate,
-            "the active update should be defined");
-
-  lockDirectory(getAppBaseDir());
-
-  setupAppFilesAsync();
-}
-
-function setupAppFilesFinished() {
-  stageUpdate();
-}
-
-function end_test() {
-  resetEnvironment();
+  createUpdateInProgressLockFile(getAppBaseDir());
+  setupUpdaterTest(FILE_COMPLETE_MAR, false);
 }
 
 /**
- * Checks if staging the update has failed.
+ * Called after the call to setupUpdaterTest finishes.
  */
-function checkUpdateApplied() {
-  // Don't proceed until the update has failed, and reset to pending.
-  if (gUpdateManager.activeUpdate.state != END_STATE) {
-    if (++gTimeoutRuns > MAX_TIMEOUT_RUNS) {
-      do_throw("Exceeded MAX_TIMEOUT_RUNS while waiting for the " +
-               "active update status state to equal: " +
-               END_STATE +
-               ", current state: " + gUpdateManager.activeUpdate.state);
-    }
-    do_timeout(TEST_CHECK_TIMEOUT, checkUpdateApplied);
-    return;
-  }
-
-  do_timeout(TEST_CHECK_TIMEOUT, finishTest);
+function setupUpdaterTestFinished() {
+  stageUpdate();
 }
 
-function finishTest() {
-  checkPostUpdateRunningFile(false);
-  Assert.equal(readStatusState(), END_STATE,
-               "the status state" + MSG_SHOULD_EQUAL);
-  checkFilesAfterUpdateFailure(getApplyDirFile, false, false);
-  unlockDirectory(getAppBaseDir());
+/**
+ * Called after the call to stageUpdate finishes.
+ */
+function stageUpdateFinished() {
+  removeUpdateInProgressLockFile(getAppBaseDir());
   standardInit();
+  checkPostUpdateRunningFile(false);
+  checkFilesAfterUpdateFailure(getApplyDirFile);
+  checkUpdateLogContains(PERFORMING_STAGED_UPDATE);
+  checkUpdateLogContains(ERR_UPDATE_IN_PROGRESS);
   waitForFilesInUse();
 }
diff --git a/toolkit/mozapps/update/tests/unit_base_updater/marAppApplyUpdateAppBinInUseStageSuccess_win.js b/toolkit/mozapps/update/tests/unit_base_updater/marAppApplyUpdateAppBinInUseStageSuccess_win.js
index 5a7a56f8a70b..2a93272f0568 100644
--- a/toolkit/mozapps/update/tests/unit_base_updater/marAppApplyUpdateAppBinInUseStageSuccess_win.js
+++ b/toolkit/mozapps/update/tests/unit_base_updater/marAppApplyUpdateAppBinInUseStageSuccess_win.js
@@ -7,244 +7,69 @@
  * apply it.
  */
 
-const START_STATE = STATE_PENDING;
-const END_STATE = STATE_APPLIED;
+const STATE_AFTER_STAGE = IS_SERVICE_TEST ? STATE_APPLIED_SVC : STATE_APPLIED;
 
 function run_test() {
-  if (MOZ_APP_NAME == "xulrunner") {
-    logTestInfo("Unable to run this test on xulrunner");
+  if (!setupTestCommon()) {
     return;
   }
 
-  setupTestCommon();
   gTestFiles = gTestFilesCompleteSuccess;
   gTestDirs = gTestDirsCompleteSuccess;
-  setupUpdaterTest(FILE_COMPLETE_MAR);
-
-  createUpdaterINI(true);
-
-  if (IS_WIN) {
-    Services.prefs.setBoolPref(PREF_APP_UPDATE_SERVICE_ENABLED, false);
-  }
-
-  let channel = Services.prefs.getCharPref(PREF_APP_UPDATE_CHANNEL);
-  let patches = getLocalPatchString(null, null, null, null, null, "true",
-                                    START_STATE);
-  let updates = getLocalUpdateString(patches, null, null, null, null, null,
-                                     null, null, null, null, null, null,
-                                     "true", channel);
-  writeUpdatesToXMLFile(getLocalUpdatesXMLString(updates), true);
-  writeVersionFile(getAppVersion());
-  writeStatusFile(START_STATE);
-
-  reloadUpdateManagerData();
-  Assert.ok(!!gUpdateManager.activeUpdate,
-            "the active update should be defined");
-
-  setupAppFilesAsync();
+  setupUpdaterTest(FILE_COMPLETE_MAR, undefined);
 }
 
-function setupAppFilesFinished() {
-  setAppBundleModTime();
+/**
+ * Called after the call to setupUpdaterTest finishes.
+ */
+function setupUpdaterTestFinished() {
   stageUpdate();
 }
 
-function customLaunchAppToApplyUpdate() {
-  debugDump("start - locking installation directory");
-  const LPCWSTR = ctypes.char16_t.ptr;
-  const DWORD = ctypes.uint32_t;
-  const LPVOID = ctypes.voidptr_t;
-  const GENERIC_READ = 0x80000000;
-  const FILE_SHARE_READ = 1;
-  const FILE_SHARE_WRITE = 2;
-  const OPEN_EXISTING = 3;
-  const FILE_FLAG_BACKUP_SEMANTICS = 0x02000000;
-  const INVALID_HANDLE_VALUE = LPVOID(0xffffffff);
-  let kernel32 = ctypes.open("kernel32");
-  let CreateFile = kernel32.declare("CreateFileW", ctypes.default_abi,
-                                    LPVOID, LPCWSTR, DWORD, DWORD,
-                                    LPVOID, DWORD, DWORD, LPVOID);
-  gHandle = CreateFile(getAppBaseDir().path, GENERIC_READ,
-                       FILE_SHARE_READ | FILE_SHARE_WRITE, LPVOID(0),
-                       OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, LPVOID(0));
-  Assert.notEqual(gHandle.toString(), INVALID_HANDLE_VALUE.toString(),
-                  "the handle should not equal INVALID_HANDLE_VALUE");
-  kernel32.close();
-  debugDump("finish - locking installation directory");
-}
-
 /**
- * Checks if the update has finished being staged.
+ * Called after the call to stageUpdate finishes.
  */
-function checkUpdateApplied() {
-  gTimeoutRuns++;
-  // Don't proceed until the active update's state is the expected value.
-  if (gUpdateManager.activeUpdate.state != END_STATE) {
-    if (gTimeoutRuns > MAX_TIMEOUT_RUNS) {
-      do_throw("Exceeded MAX_TIMEOUT_RUNS while waiting for the " +
-               "active update status state to equal: " +
-               END_STATE +
-               ", current state: " + gUpdateManager.activeUpdate.state);
-    }
-    do_timeout(TEST_CHECK_TIMEOUT, checkUpdateApplied);
-    return;
-  }
-
-  // Don't proceed until the update's status state is the expected value.
-  let state = readStatusState();
-  if (state != END_STATE) {
-    if (gTimeoutRuns > MAX_TIMEOUT_RUNS) {
-      do_throw("Exceeded MAX_TIMEOUT_RUNS while waiting for the update" +
-               "status file state to equal: " +
-               END_STATE +
-               ", current status state: " + state);
-    }
-    do_timeout(TEST_CHECK_TIMEOUT, checkUpdateApplied);
-    return;
-  }
-
-  // Don't proceed until the last update log has been created.
-  let log;
-  if (IS_WIN || IS_MACOSX) {
-    log = getUpdatesDir();
-  } else {
-    log = getStageDirFile(null, true);
-    log.append(DIR_UPDATES);
-  }
-  log.append(FILE_LAST_LOG);
-  if (!log.exists()) {
-    if (gTimeoutRuns > MAX_TIMEOUT_RUNS) {
-      do_throw("Exceeded MAX_TIMEOUT_RUNS while waiting for the update log " +
-               "to be created. Path: " + log.path);
-    }
-    do_timeout(TEST_CHECK_TIMEOUT, checkUpdateApplied);
-    return;
-  }
-
+function stageUpdateFinished() {
   checkPostUpdateRunningFile(false);
   checkFilesAfterUpdateSuccess(getStageDirFile, true, false);
-
-  log = getUpdatesPatchDir();
-  log.append(FILE_UPDATE_LOG);
-  Assert.ok(!log.exists(), MSG_SHOULD_NOT_EXIST);
-
-  log = getUpdatesDir();
-  log.append(FILE_LAST_LOG);
-  if (IS_WIN || IS_MACOSX) {
-    Assert.ok(log.exists(), MSG_SHOULD_EXIST);
-  } else {
-    Assert.ok(!log.exists(), MSG_SHOULD_NOT_EXIST);
-  }
-
-  log = getUpdatesDir();
-  log.append(FILE_BACKUP_LOG);
-  Assert.ok(!log.exists(), MSG_SHOULD_NOT_EXIST);
-
-  let updatesDir = getStageDirFile(DIR_UPDATES + "/" + DIR_PATCH, true);
-  Assert.ok(!updatesDir.exists(), MSG_SHOULD_NOT_EXIST);
-
-  log = getStageDirFile(DIR_UPDATES + "/" + FILE_LAST_LOG, true);
-  if (IS_WIN || IS_MACOSX) {
-    Assert.ok(!log.exists(), MSG_SHOULD_NOT_EXIST);
-  } else {
-    Assert.ok(log.exists(), MSG_SHOULD_EXIST);
-  }
-
-  log = getStageDirFile(DIR_UPDATES + "/" + FILE_BACKUP_LOG, true);
-  Assert.ok(!log.exists(), MSG_SHOULD_NOT_EXIST);
-
-  // Switch the application to the staged application that was updated by
-  // launching the application.
-  do_timeout(TEST_CHECK_TIMEOUT, launchAppToApplyUpdate);
+  checkUpdateLogContents(LOG_COMPLETE_SUCCESS_STAGE, true);
+  lockDirectory(getAppBaseDir().path);
+  // Switch the application to the staged application that was updated.
+  runUpdateUsingApp(STATE_SUCCEEDED);
 }
 
 /**
- * Checks if the post update binary was properly launched for the platforms that
- * support launching post update process.
+ * Called after the call to runUpdateUsingApp finishes.
  */
-function checkUpdateFinished() {
-  if (IS_WIN || IS_MACOSX) {
-    gCheckFunc = finishCheckUpdateFinished;
-    checkPostUpdateAppLog();
-  } else {
-    finishCheckUpdateFinished();
-  }
+function runUpdateFinished() {
+  checkPostUpdateAppLog();
 }
 
 /**
- * Checks if the update has finished and if it has finished performs checks for
- * the test.
+ * Called after the call to checkPostUpdateAppLog finishes.
  */
-function finishCheckUpdateFinished() {
-  gTimeoutRuns++;
-  // Don't proceed until the update's status state is the expected value.
-  let state = readStatusState();
-  if (state != STATE_SUCCEEDED) {
-    if (gTimeoutRuns > MAX_TIMEOUT_RUNS) {
-      do_throw("Exceeded MAX_TIMEOUT_RUNS while waiting for the " +
-               "update status file state to equal: " +
-               STATE_SUCCEEDED +
-               ", current status state: " + state);
-    }
-    do_timeout(TEST_CHECK_TIMEOUT, checkUpdateFinished);
-    return;
-  }
-
-  // Don't proceed until the application was switched out with the staged update
-  // successfully.
-  let updatedDir = getStageDirFile(null, true);
-  if (updatedDir.exists()) {
-    if (gTimeoutRuns > MAX_TIMEOUT_RUNS) {
-      do_throw("Exceeded MAX_TIMEOUT_RUNS while waiting for the updated " +
-               "directory to not exist. Path: " + updatedDir.path);
-    }
-    do_timeout(TEST_CHECK_TIMEOUT, checkUpdateFinished);
-    return;
-  }
-
-  if (IS_WIN) {
-    // Don't proceed until the updater binary is no longer in use.
-    let updater = getUpdatesPatchDir();
-    updater.append(FILE_UPDATER_BIN);
-    if (updater.exists()) {
-      if (gTimeoutRuns > MAX_TIMEOUT_RUNS) {
-        do_throw("Exceeded MAX_TIMEOUT_RUNS while waiting for the " +
-                 "updater binary to no longer be in use");
-      }
-      try {
-        updater.remove(false);
-      } catch (e) {
-        do_timeout(TEST_CHECK_TIMEOUT, checkUpdateFinished);
-        return;
-      }
-    }
-  }
-
-  checkPostUpdateRunningFile(true);
+function checkPostUpdateAppLogFinished() {
   checkAppBundleModTime();
-  checkFilesAfterUpdateSuccess(getApplyDirFile, false, false);
+  standardInit();
+  checkPostUpdateRunningFile(true);
+  checkFilesAfterUpdateSuccess(getApplyDirFile);
   checkUpdateLogContents(LOG_COMPLETE_SUCCESS);
 
-  standardInit();
-
-  let update = gUpdateManager.getUpdateAt(0);
-  Assert.equal(update.state, STATE_SUCCEEDED,
-               "the update state" + MSG_SHOULD_EQUAL);
-
   let updatesDir = getUpdatesPatchDir();
-  Assert.ok(updatesDir.exists(), MSG_SHOULD_EXIST);
+  Assert.ok(updatesDir.exists(),
+            MSG_SHOULD_EXIST + getMsgPath(updatesDir.path));
 
-  let log = getUpdatesPatchDir();
-  log.append(FILE_UPDATE_LOG);
-  Assert.ok(!log.exists(), MSG_SHOULD_NOT_EXIST);
+  let log = getUpdateLog(FILE_UPDATE_LOG);
+  Assert.ok(!log.exists(),
+            MSG_SHOULD_NOT_EXIST + getMsgPath(log.path));
 
-  log = getUpdatesDir();
-  log.append(FILE_LAST_LOG);
-  Assert.ok(log.exists(), MSG_SHOULD_EXIST);
+  log = getUpdateLog(FILE_LAST_UPDATE_LOG);
+  Assert.ok(log.exists(),
+            MSG_SHOULD_EXIST + getMsgPath(log.path));
 
-  log = getUpdatesDir();
-  log.append(FILE_BACKUP_LOG);
-  Assert.ok(log.exists(), MSG_SHOULD_EXIST);
+  log = getUpdateLog(FILE_BACKUP_UPDATE_LOG);
+  Assert.ok(log.exists(),
+            MSG_SHOULD_EXIST + getMsgPath(log.path));
 
   waitForFilesInUse();
 }
diff --git a/toolkit/mozapps/update/tests/unit_base_updater/marAppApplyUpdateStageSuccess.js b/toolkit/mozapps/update/tests/unit_base_updater/marAppApplyUpdateStageSuccess.js
index 13486c3dbb77..cc7a099386eb 100644
--- a/toolkit/mozapps/update/tests/unit_base_updater/marAppApplyUpdateStageSuccess.js
+++ b/toolkit/mozapps/update/tests/unit_base_updater/marAppApplyUpdateStageSuccess.js
@@ -7,226 +7,68 @@
  * apply it.
  */
 
-const START_STATE = STATE_PENDING;
-const END_STATE = STATE_APPLIED;
+const STATE_AFTER_STAGE = IS_SERVICE_TEST ? STATE_APPLIED_SVC : STATE_APPLIED;
 
 function run_test() {
-  if (MOZ_APP_NAME == "xulrunner") {
-    logTestInfo("Unable to run this test on xulrunner");
+  if (!setupTestCommon()) {
     return;
   }
 
-  setupTestCommon();
   gTestFiles = gTestFilesCompleteSuccess;
   gTestDirs = gTestDirsCompleteSuccess;
-  setupUpdaterTest(FILE_COMPLETE_MAR);
-
-  createUpdaterINI(false);
-
-  if (IS_WIN) {
-    Services.prefs.setBoolPref(PREF_APP_UPDATE_SERVICE_ENABLED, false);
-  }
-
-  let channel = Services.prefs.getCharPref(PREF_APP_UPDATE_CHANNEL);
-  let patches = getLocalPatchString(null, null, null, null, null, "true",
-                                    START_STATE);
-  let updates = getLocalUpdateString(patches, null, null, null, null, null,
-                                     null, null, null, null, null, null,
-                                     "true", channel);
-  writeUpdatesToXMLFile(getLocalUpdatesXMLString(updates), true);
-  writeVersionFile(getAppVersion());
-  writeStatusFile(START_STATE);
-
-  reloadUpdateManagerData();
-  Assert.ok(!!gUpdateManager.activeUpdate,
-            "the active update should be defined");
-
-  setupAppFilesAsync();
+  setupUpdaterTest(FILE_COMPLETE_MAR, true);
 }
 
-function setupAppFilesFinished() {
-  setAppBundleModTime();
+/**
+ * Called after the call to setupUpdaterTest finishes.
+ */
+function setupUpdaterTestFinished() {
   stageUpdate();
 }
 
 /**
- * Checks if the update has finished being staged.
+ * Called after the call to stageUpdate finishes.
  */
-function checkUpdateApplied() {
-  gTimeoutRuns++;
-  // Don't proceed until the active update's state is the expected value.
-  if (gUpdateManager.activeUpdate.state != END_STATE) {
-    if (gTimeoutRuns > MAX_TIMEOUT_RUNS) {
-      do_throw("Exceeded MAX_TIMEOUT_RUNS while waiting for the " +
-               "active update status state to equal: " +
-               END_STATE +
-               ", current state: " + gUpdateManager.activeUpdate.state);
-    }
-    do_timeout(TEST_CHECK_TIMEOUT, checkUpdateApplied);
-    return;
-  }
-
-  // Don't proceed until the update's status state is the expected value.
-  let state = readStatusState();
-  if (state != END_STATE) {
-    if (gTimeoutRuns > MAX_TIMEOUT_RUNS) {
-      do_throw("Exceeded MAX_TIMEOUT_RUNS while waiting for the update " +
-               "status state to equal: " +
-               END_STATE +
-               ", current status state: " + state);
-    }
-    do_timeout(TEST_CHECK_TIMEOUT, checkUpdateApplied);
-    return;
-  }
-
-  // Don't proceed until the last update log has been created.
-  let log;
-  if (IS_WIN || IS_MACOSX) {
-    log = getUpdatesDir();
-  } else {
-    log = getStageDirFile(null, true);
-    log.append(DIR_UPDATES);
-  }
-  log.append(FILE_LAST_LOG);
-  if (!log.exists()) {
-    if (gTimeoutRuns > MAX_TIMEOUT_RUNS) {
-      do_throw("Exceeded MAX_TIMEOUT_RUNS while waiting for the update log " +
-               "to be created. Path: " + log.path);
-    }
-    do_timeout(TEST_CHECK_TIMEOUT, checkUpdateApplied);
-    return;
-  }
-
+function stageUpdateFinished() {
   checkPostUpdateRunningFile(false);
-  checkFilesAfterUpdateSuccess(getStageDirFile, true, false);
-
-  log = getUpdatesPatchDir();
-  log.append(FILE_UPDATE_LOG);
-  Assert.ok(!log.exists(), MSG_SHOULD_NOT_EXIST);
-
-  log = getUpdatesDir();
-  log.append(FILE_LAST_LOG);
-  if (IS_WIN || IS_MACOSX) {
-    Assert.ok(log.exists(), MSG_SHOULD_EXIST);
-  } else {
-    Assert.ok(!log.exists(), MSG_SHOULD_NOT_EXIST);
-  }
-
-  log = getUpdatesDir();
-  log.append(FILE_BACKUP_LOG);
-  Assert.ok(!log.exists(), MSG_SHOULD_NOT_EXIST);
-
-  let updatesDir = getStageDirFile(DIR_UPDATES + "/" + DIR_PATCH, true);
-  Assert.ok(!updatesDir.exists(), MSG_SHOULD_NOT_EXIST);
-
-  log = getStageDirFile(DIR_UPDATES + "/" + FILE_LAST_LOG, true);
-  if (IS_WIN || IS_MACOSX) {
-    Assert.ok(!log.exists(), MSG_SHOULD_NOT_EXIST);
-  } else {
-    Assert.ok(log.exists(), MSG_SHOULD_EXIST);
-  }
-
-  log = getStageDirFile(DIR_UPDATES + "/" + FILE_BACKUP_LOG, true);
-  Assert.ok(!log.exists(), MSG_SHOULD_NOT_EXIST);
-
-  // Switch the application to the staged application that was updated by
-  // launching the application.
-  do_timeout(TEST_CHECK_TIMEOUT, launchAppToApplyUpdate);
+  checkFilesAfterUpdateSuccess(getStageDirFile, true);
+  checkUpdateLogContents(LOG_COMPLETE_SUCCESS_STAGE, true);
+  // Switch the application to the staged application that was updated.
+  runUpdateUsingApp(STATE_SUCCEEDED);
 }
 
 /**
- * Checks if the post update binary was properly launched for the platforms that
- * support launching post update process.
+ * Called after the call to runUpdateUsingApp finishes.
  */
-function checkUpdateFinished() {
-  if (IS_WIN || IS_MACOSX) {
-    gCheckFunc = finishCheckUpdateApplied;
-    checkPostUpdateAppLog();
-  } else {
-    finishCheckUpdateApplied();
-  }
+function runUpdateFinished() {
+  checkPostUpdateAppLog();
 }
 
 /**
- * Checks if the update has finished and if it has finished performs checks for
- * the test.
+ * Called after the call to checkPostUpdateAppLog finishes.
  */
-function finishCheckUpdateApplied() {
-  gTimeoutRuns++;
-  // Don't proceed until the update's status state is the expected value.
-  let state = readStatusState();
-  if (state != STATE_SUCCEEDED) {
-    if (gTimeoutRuns > MAX_TIMEOUT_RUNS) {
-      do_throw("Exceeded MAX_TIMEOUT_RUNS while waiting for the " +
-               "update status file state to equal: " +
-               STATE_SUCCEEDED +
-               ", current status state: " + state);
-    }
-    do_timeout(TEST_CHECK_TIMEOUT, checkUpdateFinished);
-    return;
-  }
-
-  // Don't proceed until the application was switched out with the staged update
-  // successfully.
-  let updatedDir = getStageDirFile(null, true);
-  if (updatedDir.exists()) {
-    if (gTimeoutRuns > MAX_TIMEOUT_RUNS) {
-      do_throw("Exceeded MAX_TIMEOUT_RUNS while waiting for the updated " +
-               "directory to not exist. Path: " + updatedDir.path);
-    }
-    do_timeout(TEST_CHECK_TIMEOUT, checkUpdateFinished);
-    return;
-  }
-
-  if (IS_WIN) {
-    // Don't proceed until the updater binary is no longer in use.
-    let updater = getUpdatesPatchDir();
-    updater.append(FILE_UPDATER_BIN);
-    if (updater.exists()) {
-      if (gTimeoutRuns > MAX_TIMEOUT_RUNS) {
-        do_throw("Exceeded MAX_TIMEOUT_RUNS while waiting for the " +
-                 "updater binary to no longer be in use");
-      }
-      try {
-        updater.remove(false);
-      } catch (e) {
-        do_timeout(TEST_CHECK_TIMEOUT, checkUpdateFinished);
-        return;
-      }
-    }
-  }
-
-  checkPostUpdateRunningFile(true);
+function checkPostUpdateAppLogFinished() {
   checkAppBundleModTime();
-  checkFilesAfterUpdateSuccess(getApplyDirFile, false, true);
-  gSwitchApp = true;
-  checkUpdateLogContents();
-  gSwitchApp = false;
-
   standardInit();
-
-  let update = gUpdateManager.getUpdateAt(0);
-  Assert.equal(update.state, STATE_SUCCEEDED,
-               "the update state" + MSG_SHOULD_EQUAL);
+  checkPostUpdateRunningFile(true);
+  checkFilesAfterUpdateSuccess(getApplyDirFile, false, true);
+  checkUpdateLogContents(LOG_REPLACE_SUCCESS, false, true);
 
   let updatesDir = getUpdatesPatchDir();
-  Assert.ok(updatesDir.exists(), MSG_SHOULD_EXIST);
+  Assert.ok(updatesDir.exists(),
+            MSG_SHOULD_EXIST + getMsgPath(updatesDir.path));
 
-  let log = getUpdatesPatchDir();
-  log.append(FILE_UPDATE_LOG);
-  Assert.ok(!log.exists(), MSG_SHOULD_NOT_EXIST);
+  let log = getUpdateLog(FILE_UPDATE_LOG);
+  Assert.ok(!log.exists(),
+            MSG_SHOULD_NOT_EXIST + getMsgPath(log.path));
 
-  log = getUpdatesDir();
-  log.append(FILE_LAST_LOG);
-  Assert.ok(log.exists(), MSG_SHOULD_EXIST);
+  log = getUpdateLog(FILE_LAST_UPDATE_LOG);
+  Assert.ok(log.exists(),
+            MSG_SHOULD_EXIST + getMsgPath(log.path));
 
-  log = getUpdatesDir();
-  log.append(FILE_BACKUP_LOG);
-  if (IS_WIN || IS_MACOSX) {
-    Assert.ok(log.exists(), MSG_SHOULD_EXIST);
-  } else {
-    Assert.ok(!log.exists(), MSG_SHOULD_NOT_EXIST);
-  }
+  log = getUpdateLog(FILE_BACKUP_UPDATE_LOG);
+  Assert.ok(log.exists(),
+            MSG_SHOULD_EXIST + getMsgPath(log.path));
 
   waitForFilesInUse();
 }
diff --git a/toolkit/mozapps/update/tests/unit_base_updater/marAppApplyUpdateSuccess.js b/toolkit/mozapps/update/tests/unit_base_updater/marAppApplyUpdateSuccess.js
index 350523bb477b..a44264fac843 100644
--- a/toolkit/mozapps/update/tests/unit_base_updater/marAppApplyUpdateSuccess.js
+++ b/toolkit/mozapps/update/tests/unit_base_updater/marAppApplyUpdateSuccess.js
@@ -7,126 +7,55 @@
  * apply it.
  */
 
-const START_STATE = STATE_PENDING;
-const END_STATE = STATE_SUCCEEDED;
-
 function run_test() {
-  if (MOZ_APP_NAME == "xulrunner") {
-    logTestInfo("Unable to run this test on xulrunner");
+  if (!setupTestCommon()) {
     return;
   }
 
-  setupTestCommon();
   gTestFiles = gTestFilesCompleteSuccess;
   gTestDirs = gTestDirsCompleteSuccess;
-  setupUpdaterTest(FILE_COMPLETE_MAR);
-
-  createUpdaterINI();
-  setAppBundleModTime();
-
-  let channel = Services.prefs.getCharPref(PREF_APP_UPDATE_CHANNEL);
-  let patches = getLocalPatchString(null, null, null, null, null, "true",
-                                    START_STATE);
-  let updates = getLocalUpdateString(patches, null, null, null, null, null,
-                                     null, null, null, null, null, null,
-                                     "true", channel);
-  writeUpdatesToXMLFile(getLocalUpdatesXMLString(updates), true);
-  writeVersionFile(getAppVersion());
-  writeStatusFile(START_STATE);
-
-  setupAppFilesAsync();
-}
-
-function setupAppFilesFinished() {
-  do_timeout(TEST_CHECK_TIMEOUT, launchAppToApplyUpdate);
+  setupUpdaterTest(FILE_COMPLETE_MAR, undefined);
 }
 
 /**
- * Checks if the post update binary was properly launched for the platforms that
- * support launching post update process.
+ * Called after the call to setupUpdaterTest finishes.
  */
-function checkUpdateFinished() {
-  if (IS_WIN || IS_MACOSX) {
-    gCheckFunc = finishCheckUpdateFinished;
-    checkPostUpdateAppLog();
-  } else {
-    finishCheckUpdateFinished();
-  }
+function setupUpdaterTestFinished() {
+  runUpdateUsingApp(STATE_SUCCEEDED);
 }
 
 /**
- * Checks if the update has finished and if it has finished performs checks for
- * the test.
+ * Called after the call to runUpdateUsingApp finishes.
  */
-function finishCheckUpdateFinished() {
-  gTimeoutRuns++;
-  // Don't proceed until the update's status state is the expected value.
-  let state = readStatusState();
-  if (state != END_STATE) {
-    if (gTimeoutRuns > MAX_TIMEOUT_RUNS) {
-      do_throw("Exceeded MAX_TIMEOUT_RUNS while waiting for the update " +
-               "status state to equal: " + END_STATE +
-               ", current status state: " + state);
-    } else {
-      do_timeout(TEST_CHECK_TIMEOUT, checkUpdateFinished);
-    }
-    return;
-  }
-
-  // Don't proceed until the update log has been created.
-  let log = getUpdatesPatchDir();
-  log.append(FILE_UPDATE_LOG);
-  if (!log.exists()) {
-    if (gTimeoutRuns > MAX_TIMEOUT_RUNS) {
-      do_throw("Exceeded MAX_TIMEOUT_RUNS while waiting for the update log " +
-               "to be created. Path: " + log.path);
-    }
-    do_timeout(TEST_CHECK_TIMEOUT, checkUpdateFinished);
-    return;
-  }
-
-  if (IS_WIN) {
-    // Don't proceed until the updater binary is no longer in use.
-    let updater = getUpdatesPatchDir();
-    updater.append(FILE_UPDATER_BIN);
-    if (updater.exists()) {
-      if (gTimeoutRuns > MAX_TIMEOUT_RUNS) {
-        do_throw("Exceeded while waiting for updater binary to no longer be " +
-                 "in use");
-      }
-      try {
-        updater.remove(false);
-      } catch (e) {
-        do_timeout(TEST_CHECK_TIMEOUT, checkUpdateFinished);
-        return;
-      }
-    }
-  }
+function runUpdateFinished() {
+  checkPostUpdateAppLog();
+}
 
+/**
+ * Called after the call to checkPostUpdateAppLog finishes.
+ */
+function checkPostUpdateAppLogFinished() {
   checkAppBundleModTime();
-  checkFilesAfterUpdateSuccess(getApplyDirFile, false, false);
+  standardInit();
+  checkPostUpdateRunningFile(true);
+  checkFilesAfterUpdateSuccess(getApplyDirFile);
   checkUpdateLogContents(LOG_COMPLETE_SUCCESS);
 
-  standardInit();
-
-  let update = gUpdateManager.getUpdateAt(0);
-  Assert.equal(update.state, END_STATE,
-               "the update state" + MSG_SHOULD_EQUAL);
-
   let updatesDir = getUpdatesPatchDir();
-  Assert.ok(updatesDir.exists(), MSG_SHOULD_EXIST);
+  Assert.ok(updatesDir.exists(),
+            MSG_SHOULD_EXIST + getMsgPath(updatesDir.path));
 
-  log = getUpdatesPatchDir();
-  log.append(FILE_UPDATE_LOG);
-  Assert.ok(!log.exists(), MSG_SHOULD_NOT_EXIST);
+  let log = getUpdateLog(FILE_UPDATE_LOG);
+  Assert.ok(!log.exists(),
+            MSG_SHOULD_NOT_EXIST + getMsgPath(log.path));
 
-  log = getUpdatesDir();
-  log.append(FILE_LAST_LOG);
-  Assert.ok(log.exists(), MSG_SHOULD_EXIST);
+  log = getUpdateLog(FILE_LAST_UPDATE_LOG);
+  Assert.ok(log.exists(),
+            MSG_SHOULD_EXIST + getMsgPath(log.path));
 
-  log = getUpdatesDir();
-  log.append(FILE_BACKUP_LOG);
-  Assert.ok(!log.exists(), MSG_SHOULD_NOT_EXIST);
+  log = getUpdateLog(FILE_BACKUP_UPDATE_LOG);
+  Assert.ok(!log.exists(),
+            MSG_SHOULD_NOT_EXIST + getMsgPath(log.path));
 
   waitForFilesInUse();
 }
diff --git a/toolkit/mozapps/update/tests/unit_base_updater/marAppInUseStageFailureComplete_win.js b/toolkit/mozapps/update/tests/unit_base_updater/marAppInUseStageFailureComplete_win.js
index 1558c6b1f89e..e3f4008ca09f 100644
--- a/toolkit/mozapps/update/tests/unit_base_updater/marAppInUseStageFailureComplete_win.js
+++ b/toolkit/mozapps/update/tests/unit_base_updater/marAppInUseStageFailureComplete_win.js
@@ -4,46 +4,59 @@
 
 /* Application in use complete MAR file staged patch apply failure test */
 
-const START_STATE = STATE_APPLIED;
-const END_STATE = STATE_PENDING;
+const STATE_AFTER_STAGE = IS_SERVICE_TEST ? STATE_APPLIED_SVC : STATE_APPLIED;
 
 function run_test() {
-  gStageUpdate = true;
-  setupTestCommon();
+  if (!setupTestCommon()) {
+    return;
+  }
   gTestFiles = gTestFilesCompleteSuccess;
   gTestDirs = gTestDirsCompleteSuccess;
-  setTestFilesAndDirsForFailure();
-  setupUpdaterTest(FILE_COMPLETE_MAR);
-
-  // Launch the callback helper application so it is in use during the update.
-  let callbackApp = getApplyDirFile(DIR_RESOURCES + gCallbackBinFile);
-  let args = [getApplyDirPath() + DIR_RESOURCES, "input", "output", "-s",
-              HELPER_SLEEP_TIMEOUT];
-  let callbackAppProcess = Cc["@mozilla.org/process/util;1"].
-                           createInstance(Ci.nsIProcess);
-  callbackAppProcess.init(callbackApp);
-  callbackAppProcess.run(false, args, args.length);
-
-  do_timeout(TEST_HELPER_TIMEOUT, waitForHelperSleep);
+  createUpdaterINI(false);
+  setupUpdaterTest(FILE_COMPLETE_MAR, false);
 }
 
-function doUpdate() {
-  runUpdate(0, START_STATE, null);
+/**
+ * Called after the call to setupUpdaterTest finishes.
+ */
+function setupUpdaterTestFinished() {
+  runHelperFileInUse(DIR_RESOURCES + gCallbackBinFile, false);
+}
 
+/**
+ * Called after the call to waitForHelperSleep finishes.
+ */
+function waitForHelperSleepFinished() {
+  stageUpdate();
+}
+
+/**
+ * Called after the call to stageUpdate finishes.
+ */
+function stageUpdateFinished() {
+  checkPostUpdateRunningFile(false);
+  checkFilesAfterUpdateSuccess(getStageDirFile, true);
+  checkUpdateLogContents(LOG_COMPLETE_SUCCESS_STAGE, true);
   // Switch the application to the staged application that was updated.
-  gStageUpdate = false;
-  gSwitchApp = true;
-  runUpdate(1, END_STATE, checkUpdateApplied);
+  runUpdate(STATE_PENDING, true, 1, false);
 }
 
-function checkUpdateApplied() {
-  setupHelperFinish();
+/**
+ * Called after the call to runUpdate finishes.
+ */
+function runUpdateFinished() {
+  waitForHelperExit();
 }
 
-function checkUpdate() {
-  checkFilesAfterUpdateFailure(getApplyDirFile, false, false);
+/**
+ * Called after the call to waitForHelperExit finishes.
+ */
+function waitForHelperExitFinished() {
+  standardInit();
+  checkPostUpdateRunningFile(false);
+  setTestFilesAndDirsForFailure();
+  checkFilesAfterUpdateFailure(getApplyDirFile);
   checkUpdateLogContains(ERR_RENAME_FILE);
   checkUpdateLogContains(ERR_MOVE_DESTDIR_7);
-  standardInit();
-  checkCallbackAppLog();
+  checkCallbackLog();
 }
diff --git a/toolkit/mozapps/update/tests/unit_base_updater/marAppInUseStageSuccessComplete_unix.js b/toolkit/mozapps/update/tests/unit_base_updater/marAppInUseStageSuccessComplete_unix.js
index 4866ece05c70..7313ae342f8e 100644
--- a/toolkit/mozapps/update/tests/unit_base_updater/marAppInUseStageSuccessComplete_unix.js
+++ b/toolkit/mozapps/update/tests/unit_base_updater/marAppInUseStageSuccessComplete_unix.js
@@ -4,19 +4,78 @@
 
 /* Application in use complete MAR file staged patch apply success test */
 
+const START_STATE = STATE_PENDING;
+const STATE_AFTER_STAGE = STATE_APPLIED;
+
 function run_test() {
-  gStageUpdate = true;
-  setupTestCommon();
+  if (!setupTestCommon()) {
+    return;
+  }
   gTestFiles = gTestFilesCompleteSuccess;
   gTestFiles[gTestFiles.length - 1].originalContents = null;
   gTestFiles[gTestFiles.length - 1].compareContents = "FromComplete\n";
   gTestFiles[gTestFiles.length - 1].comparePerms = 0o644;
   gTestDirs = gTestDirsCompleteSuccess;
-  setupUpdaterTest(FILE_COMPLETE_MAR);
+  setupUpdaterTest(FILE_COMPLETE_MAR, true);
+}
 
-  createUpdaterINI(false);
-  setAppBundleModTime();
+/**
+ * Called after the call to setupUpdaterTest finishes.
+ */
+function setupUpdaterTestFinished() {
+  setupSymLinks();
+  runHelperFileInUse(DIR_RESOURCES + gCallbackBinFile, false);
+}
 
+/**
+ * Called after the call to waitForHelperSleep finishes.
+ */
+function waitForHelperSleepFinished() {
+  stageUpdate();
+}
+
+/**
+ * Called after the call to stageUpdate finishes.
+ */
+function stageUpdateFinished() {
+  checkPostUpdateRunningFile(false);
+  checkFilesAfterUpdateSuccess(getStageDirFile, true);
+  checkUpdateLogContents(LOG_COMPLETE_SUCCESS_STAGE, true);
+  // Switch the application to the staged application that was updated.
+  runUpdate(STATE_SUCCEEDED, true, 0, true);
+}
+
+/**
+ * Called after the call to runUpdate finishes.
+ */
+function runUpdateFinished() {
+  waitForHelperExit();
+}
+
+/**
+ * Called after the call to waitForHelperExit finishes.
+ */
+function waitForHelperExitFinished() {
+  checkPostUpdateAppLog();
+}
+
+/**
+ * Called after the call to checkPostUpdateAppLog finishes.
+ */
+function checkPostUpdateAppLogFinished() {
+  checkAppBundleModTime();
+  checkSymLinks();
+  checkPostUpdateRunningFile(true);
+  checkFilesAfterUpdateSuccess(getApplyDirFile);
+  standardInit();
+  checkUpdateLogContents(LOG_REPLACE_SUCCESS, false, true);
+  checkCallbackLog();
+}
+
+/**
+ * Setup symlinks for the test.
+ */
+function setupSymLinks() {
   // The tests don't support symlinks on gonk.
   if (IS_UNIX && !IS_TOOLKIT_GONK) {
     removeSymlink();
@@ -35,101 +94,14 @@ function run_test() {
       comparePerms     : 0o666
     });
   }
-
-  // Launch the callback helper application so it is in use during the update
-  let callbackApp = getApplyDirFile(DIR_RESOURCES + gCallbackBinFile);
-  callbackApp.permissions = PERMS_DIRECTORY;
-  let args = [getApplyDirPath() + DIR_RESOURCES, "input", "output", "-s",
-              HELPER_SLEEP_TIMEOUT];
-  let callbackAppProcess = Cc["@mozilla.org/process/util;1"].
-                           createInstance(Ci.nsIProcess);
-  callbackAppProcess.init(callbackApp);
-  callbackAppProcess.run(false, args, args.length);
-
-  do_timeout(TEST_HELPER_TIMEOUT, waitForHelperSleep);
-}
-
-function doUpdate() {
-  runUpdate(0, STATE_APPLIED, null);
-
-  checkFilesAfterUpdateSuccess(getStageDirFile, true, false);
-  checkUpdateLogContents(LOG_COMPLETE_SUCCESS);
-  checkPostUpdateRunningFile(false);
-
-  // Switch the application to the staged application that was updated.
-  gStageUpdate = false;
-  gSwitchApp = true;
-  do_timeout(TEST_CHECK_TIMEOUT, function() {
-    runUpdate(0, STATE_SUCCEEDED, checkUpdateApplied);
-  });
 }
 
 /**
- * Checks if the post update binary was properly launched for the platforms that
- * support launching post update process.
+ * Checks the state of the symlinks for the test.
  */
-function checkUpdateApplied() {
-  if (IS_WIN || IS_MACOSX) {
-    gCheckFunc = finishCheckUpdateApplied;
-    checkPostUpdateAppLog();
-  } else {
-    finishCheckUpdateApplied();
-  }
-}
-
-/**
- * Checks if the update has finished and if it has finished performs checks for
- * the test.
- */
-function finishCheckUpdateApplied() {
-  checkAppBundleModTime();
-  checkFilesAfterUpdateSuccess(getApplyDirFile, false, false);
-  setupHelperFinish();
-}
-
-function checkUpdate() {
+function checkSymLinks() {
   // The tests don't support symlinks on gonk.
   if (IS_UNIX && !IS_TOOLKIT_GONK) {
     checkSymlink();
   }
-  checkUpdateLogContents(LOG_COMPLETE_SUCCESS);
-  standardInit();
-  checkCallbackAppLog();
-}
-
-function runHelperProcess(args) {
-  let helperBin = getTestDirFile(FILE_HELPER_BIN);
-  let process = Cc["@mozilla.org/process/util;1"].
-                createInstance(Ci.nsIProcess);
-  process.init(helperBin);
-  debugDump("Running " + helperBin.path + " " + args.join(" "));
-  process.run(true, args, args.length);
-  Assert.equal(process.exitValue, 0,
-               "the helper process exit value should be 0");
-}
-
-function createSymlink() {
-  let args = ["setup-symlink", "moz-foo", "moz-bar", "target",
-              getApplyDirFile().path + "/" + DIR_RESOURCES + "link"];
-  runHelperProcess(args);
-  getApplyDirFile(DIR_RESOURCES + "link", false).permissions = 0o666;
-
-  args = ["setup-symlink", "moz-foo2", "moz-bar2", "target2",
-          getApplyDirFile().path +"/" + DIR_RESOURCES + "link2", "change-perm"];
-  runHelperProcess(args);
-}
-
-function removeSymlink() {
-  let args = ["remove-symlink", "moz-foo", "moz-bar", "target",
-              getApplyDirFile().path + "/" + DIR_RESOURCES + "link"];
-  runHelperProcess(args);
-  args = ["remove-symlink", "moz-foo2", "moz-bar2", "target2",
-          getApplyDirFile().path + "/" + DIR_RESOURCES + "link2"];
-  runHelperProcess(args);
-}
-
-function checkSymlink() {
-  let args = ["check-symlink",
-              getApplyDirFile().path + "/" + DIR_RESOURCES + "link"];
-  runHelperProcess(args);
 }
diff --git a/toolkit/mozapps/update/tests/unit_base_updater/marAppInUseSuccessComplete.js b/toolkit/mozapps/update/tests/unit_base_updater/marAppInUseSuccessComplete.js
index 7ff11811e9b5..9f726597bece 100644
--- a/toolkit/mozapps/update/tests/unit_base_updater/marAppInUseSuccessComplete.js
+++ b/toolkit/mozapps/update/tests/unit_base_updater/marAppInUseSuccessComplete.js
@@ -5,37 +5,50 @@
 /* Application in use complete MAR file patch apply success test */
 
 function run_test() {
-  setupTestCommon();
+  if (!setupTestCommon()) {
+    return;
+  }
   gTestFiles = gTestFilesCompleteSuccess;
   gTestDirs = gTestDirsCompleteSuccess;
-  setupUpdaterTest(FILE_COMPLETE_MAR);
-
-  // Launch the callback helper application so it is in use during the update.
-  let callbackApp = getApplyDirFile(DIR_RESOURCES + gCallbackBinFile);
-  callbackApp.permissions = PERMS_DIRECTORY;
-  let args = [getApplyDirPath() + DIR_RESOURCES, "input", "output", "-s",
-              HELPER_SLEEP_TIMEOUT];
-  let callbackAppProcess = Cc["@mozilla.org/process/util;1"].
-                           createInstance(Ci.nsIProcess);
-  callbackAppProcess.init(callbackApp);
-  callbackAppProcess.run(false, args, args.length);
-
-  do_timeout(TEST_HELPER_TIMEOUT, waitForHelperSleep);
+  setupUpdaterTest(FILE_COMPLETE_MAR, false);
 }
 
-function doUpdate() {
-  setAppBundleModTime();
-  runUpdate(0, STATE_SUCCEEDED, checkUpdateFinished);
+/**
+ * Called after the call to setupUpdaterTest finishes.
+ */
+function setupUpdaterTestFinished() {
+  runHelperFileInUse(DIR_RESOURCES + gCallbackBinFile, false);
 }
 
-function checkUpdateFinished() {
-  setupHelperFinish();
+/**
+ * Called after the call to waitForHelperSleep finishes.
+ */
+function waitForHelperSleepFinished() {
+  runUpdate(STATE_SUCCEEDED, false, 0, true);
 }
 
-function checkUpdate() {
+/**
+ * Called after the call to runUpdate finishes.
+ */
+function runUpdateFinished() {
+  waitForHelperExit();
+}
+
+/**
+ * Called after the call to waitForHelperExit finishes.
+ */
+function waitForHelperExitFinished() {
+  checkPostUpdateAppLog();
+}
+
+/**
+ * Called after the call to checkPostUpdateAppLog finishes.
+ */
+function checkPostUpdateAppLogFinished() {
   checkAppBundleModTime();
-  checkFilesAfterUpdateSuccess(getApplyDirFile, false, false);
-  checkUpdateLogContents(LOG_COMPLETE_SUCCESS);
   standardInit();
-  checkCallbackAppLog();
+  checkPostUpdateRunningFile(true);
+  checkFilesAfterUpdateSuccess(getApplyDirFile);
+  checkUpdateLogContents(LOG_COMPLETE_SUCCESS);
+  checkCallbackLog();
 }
diff --git a/toolkit/mozapps/update/tests/unit_base_updater/marCallbackAppStageSuccessComplete_win.js b/toolkit/mozapps/update/tests/unit_base_updater/marCallbackAppStageSuccessComplete_win.js
index bd4e808414d6..af936791fb7a 100644
--- a/toolkit/mozapps/update/tests/unit_base_updater/marCallbackAppStageSuccessComplete_win.js
+++ b/toolkit/mozapps/update/tests/unit_base_updater/marCallbackAppStageSuccessComplete_win.js
@@ -4,25 +4,50 @@
 
 /* Replace app binary complete MAR file staged patch apply success test */
 
+const STATE_AFTER_STAGE = IS_SERVICE_TEST ? STATE_APPLIED_SVC : STATE_APPLIED;
+
 function run_test() {
-  gStageUpdate = true;
-  setupTestCommon();
+  if (!setupTestCommon()) {
+    return;
+  }
   gTestFiles = gTestFilesCompleteSuccess;
   gTestDirs = gTestDirsCompleteSuccess;
-  setupUpdaterTest(FILE_COMPLETE_MAR);
-
   gCallbackBinFile = "exe0.exe";
+  setupUpdaterTest(FILE_COMPLETE_MAR, false);
+}
 
-  runUpdate(0, STATE_APPLIED, null);
+/**
+ * Called after the call to setupUpdaterTest finishes.
+ */
+function setupUpdaterTestFinished() {
+  stageUpdate();
+}
 
+/**
+ * Called after the call to stageUpdate finishes.
+ */
+function stageUpdateFinished() {
+  checkPostUpdateRunningFile(false);
+  checkFilesAfterUpdateSuccess(getStageDirFile, true);
+  checkUpdateLogContents(LOG_COMPLETE_SUCCESS_STAGE, true);
   // Switch the application to the staged application that was updated.
-  gStageUpdate = false;
-  gSwitchApp = true;
-  runUpdate(0, STATE_SUCCEEDED, checkUpdateApplied);
+  runUpdate(STATE_SUCCEEDED, true, 0, false);
 }
 
-function checkUpdateApplied() {
-  checkFilesAfterUpdateSuccess(getApplyDirFile, false, false);
-  standardInit();
-  checkCallbackAppLog();
+/**
+ * Called after the call to runUpdate finishes.
+ */
+function runUpdateFinished() {
+  checkPostUpdateAppLog();
+}
+
+/**
+ * Called after the call to checkPostUpdateAppLog finishes.
+ */
+function checkPostUpdateAppLogFinished() {
+  standardInit();
+  checkPostUpdateRunningFile(true);
+  checkFilesAfterUpdateSuccess(getApplyDirFile, false, true);
+  checkUpdateLogContents(LOG_REPLACE_SUCCESS, false, true);
+  checkCallbackLog();
 }
diff --git a/toolkit/mozapps/update/tests/unit_base_updater/marCallbackAppStageSuccessPartial_win.js b/toolkit/mozapps/update/tests/unit_base_updater/marCallbackAppStageSuccessPartial_win.js
index 28cf094d4bac..8ed7d515cd49 100644
--- a/toolkit/mozapps/update/tests/unit_base_updater/marCallbackAppStageSuccessPartial_win.js
+++ b/toolkit/mozapps/update/tests/unit_base_updater/marCallbackAppStageSuccessPartial_win.js
@@ -4,25 +4,50 @@
 
 /* Patch app binary partial MAR file staged patch apply success test */
 
+const STATE_AFTER_STAGE = IS_SERVICE_TEST ? STATE_APPLIED_SVC : STATE_APPLIED;
+
 function run_test() {
-  gStageUpdate = true;
-  setupTestCommon();
+  if (!setupTestCommon()) {
+    return;
+  }
   gTestFiles = gTestFilesPartialSuccess;
   gTestDirs = gTestDirsPartialSuccess;
-  setupUpdaterTest(FILE_PARTIAL_MAR);
-
   gCallbackBinFile = "exe0.exe";
+  setupUpdaterTest(FILE_PARTIAL_MAR, false);
+}
 
-  runUpdate(0, STATE_APPLIED, null);
+/**
+ * Called after the call to setupUpdaterTest finishes.
+ */
+function setupUpdaterTestFinished() {
+  stageUpdate();
+}
 
+/**
+ * Called after the call to stageUpdate finishes.
+ */
+function stageUpdateFinished() {
+  checkPostUpdateRunningFile(false);
+  checkFilesAfterUpdateSuccess(getStageDirFile, true);
+  checkUpdateLogContents(LOG_PARTIAL_SUCCESS_STAGE, true);
   // Switch the application to the staged application that was updated.
-  gStageUpdate = false;
-  gSwitchApp = true;
-  runUpdate(0, STATE_SUCCEEDED, checkUpdateApplied);
+  runUpdate(STATE_SUCCEEDED, true, 0, false);
 }
 
-function checkUpdateApplied() {
-  checkFilesAfterUpdateSuccess(getApplyDirFile, false, false);
-  standardInit();
-  checkCallbackAppLog();
+/**
+ * Called after the call to runUpdate finishes.
+ */
+function runUpdateFinished() {
+  checkPostUpdateAppLog();
+}
+
+/**
+ * Called after the call to checkPostUpdateAppLog finishes.
+ */
+function checkPostUpdateAppLogFinished() {
+  standardInit();
+  checkPostUpdateRunningFile(true);
+  checkFilesAfterUpdateSuccess(getApplyDirFile, false, true);
+  checkUpdateLogContents(LOG_REPLACE_SUCCESS, false, true);
+  checkCallbackLog();
 }
diff --git a/toolkit/mozapps/update/tests/unit_base_updater/marCallbackAppSuccessComplete_win.js b/toolkit/mozapps/update/tests/unit_base_updater/marCallbackAppSuccessComplete_win.js
index f9a09b39c174..a7324bdd97d3 100644
--- a/toolkit/mozapps/update/tests/unit_base_updater/marCallbackAppSuccessComplete_win.js
+++ b/toolkit/mozapps/update/tests/unit_base_updater/marCallbackAppSuccessComplete_win.js
@@ -5,18 +5,36 @@
 /* Replace app binary complete MAR file patch apply success test */
 
 function run_test() {
-  setupTestCommon();
+  if (!setupTestCommon()) {
+    return;
+  }
   gTestFiles = gTestFilesCompleteSuccess;
   gTestDirs = gTestDirsCompleteSuccess;
-  setupUpdaterTest(FILE_COMPLETE_MAR);
-
   gCallbackBinFile = "exe0.exe";
-
-  runUpdate(0, STATE_SUCCEEDED, checkUpdateFinished);
+  setupUpdaterTest(FILE_COMPLETE_MAR, false);
 }
 
-function checkUpdateFinished() {
-  checkFilesAfterUpdateSuccess(getApplyDirFile, false, false);
+/**
+ * Called after the call to setupUpdaterTest finishes.
+ */
+function setupUpdaterTestFinished() {
+  runUpdate(STATE_SUCCEEDED, false, 0, true);
+}
+
+/**
+ * Called after the call to runUpdate finishes.
+ */
+function runUpdateFinished() {
+  checkPostUpdateAppLog();
+}
+
+/**
+ * Called after the call to checkPostUpdateAppLog finishes.
+ */
+function checkPostUpdateAppLogFinished() {
   standardInit();
-  checkCallbackAppLog();
+  checkPostUpdateRunningFile(true);
+  checkFilesAfterUpdateSuccess(getApplyDirFile);
+  checkUpdateLogContents(LOG_COMPLETE_SUCCESS);
+  checkCallbackLog();
 }
diff --git a/toolkit/mozapps/update/tests/unit_base_updater/marCallbackAppSuccessPartial_win.js b/toolkit/mozapps/update/tests/unit_base_updater/marCallbackAppSuccessPartial_win.js
index 92e35324ad20..4eeae597e1f3 100644
--- a/toolkit/mozapps/update/tests/unit_base_updater/marCallbackAppSuccessPartial_win.js
+++ b/toolkit/mozapps/update/tests/unit_base_updater/marCallbackAppSuccessPartial_win.js
@@ -5,18 +5,36 @@
 /* Patch app binary partial MAR file patch apply success test */
 
 function run_test() {
-  setupTestCommon();
+  if (!setupTestCommon()) {
+    return;
+  }
   gTestFiles = gTestFilesPartialSuccess;
   gTestDirs = gTestDirsPartialSuccess;
-  setupUpdaterTest(FILE_PARTIAL_MAR);
-
   gCallbackBinFile = "exe0.exe";
-
-  runUpdate(0, STATE_SUCCEEDED, checkUpdateFinished);
+  setupUpdaterTest(FILE_PARTIAL_MAR, false);
 }
 
-function checkUpdateFinished() {
-  checkFilesAfterUpdateSuccess(getApplyDirFile, false, false);
+/**
+ * Called after the call to setupUpdaterTest finishes.
+ */
+function setupUpdaterTestFinished() {
+  runUpdate(STATE_SUCCEEDED, false, 0, true);
+}
+
+/**
+ * Called after the call to runUpdate finishes.
+ */
+function runUpdateFinished() {
+  checkPostUpdateAppLog();
+}
+
+/**
+ * Called after the call to checkPostUpdateAppLog finishes.
+ */
+function checkPostUpdateAppLogFinished() {
   standardInit();
-  checkCallbackAppLog();
+  checkPostUpdateRunningFile(true);
+  checkFilesAfterUpdateSuccess(getApplyDirFile);
+  checkUpdateLogContents(LOG_PARTIAL_SUCCESS);
+  checkCallbackLog();
 }
diff --git a/toolkit/mozapps/update/tests/unit_base_updater/marFailurePartial.js b/toolkit/mozapps/update/tests/unit_base_updater/marFailurePartial.js
index 7f79a10458be..d89226c97c0d 100644
--- a/toolkit/mozapps/update/tests/unit_base_updater/marFailurePartial.js
+++ b/toolkit/mozapps/update/tests/unit_base_updater/marFailurePartial.js
@@ -6,30 +6,34 @@
 /* General Partial MAR File Patch Apply Failure Test */
 
 function run_test() {
-  setupTestCommon();
+  if (!setupTestCommon()) {
+    return;
+  }
   gTestFiles = gTestFilesPartialSuccess;
   gTestFiles[11].originalFile = "partial.png";
   gTestDirs = gTestDirsPartialSuccess;
   setTestFilesAndDirsForFailure();
-  setupUpdaterTest(FILE_PARTIAL_MAR);
-
-  createUpdaterINI();
-  setAppBundleModTime();
-
-  // Note that on platforms where we use execv, we cannot trust the return code.
-  runUpdate((USE_EXECV ? 0 : 1), STATE_FAILED_LOADSOURCE_ERROR_WRONG_SIZE,
-            checkUpdateFinished);
+  setupUpdaterTest(FILE_PARTIAL_MAR, false);
 }
 
 /**
- * Checks if the update has finished and if it has finished performs checks for
- * the test.
+ * Called after the call to setupUpdaterTest finishes.
  */
-function checkUpdateFinished() {
-  checkPostUpdateRunningFile(false);
-  checkAppBundleModTime();
-  checkFilesAfterUpdateFailure(getApplyDirFile, false, false);
-  checkUpdateLogContents(LOG_PARTIAL_FAILURE);
-  standardInit();
-  checkCallbackAppLog();
+function setupUpdaterTestFinished() {
+  // If execv is used the updater process will turn into the callback process
+  // and the updater's return code will be that of the callback process.
+  runUpdate(STATE_FAILED_LOADSOURCE_ERROR_WRONG_SIZE, false,
+            (USE_EXECV ? 0 : 1), true);
+}
+
+/**
+ * Called after the call to runUpdate finishes.
+ */
+function runUpdateFinished() {
+  checkAppBundleModTime();
+  standardInit();
+  checkPostUpdateRunningFile(false);
+  checkFilesAfterUpdateFailure(getApplyDirFile);
+  checkUpdateLogContents(LOG_PARTIAL_FAILURE);
+  checkCallbackLog();
 }
diff --git a/toolkit/mozapps/update/tests/unit_base_updater/marFileInUseStageFailureComplete_win.js b/toolkit/mozapps/update/tests/unit_base_updater/marFileInUseStageFailureComplete_win.js
index 3aa05b67e677..b4021c3b0e0e 100644
--- a/toolkit/mozapps/update/tests/unit_base_updater/marFileInUseStageFailureComplete_win.js
+++ b/toolkit/mozapps/update/tests/unit_base_updater/marFileInUseStageFailureComplete_win.js
@@ -4,44 +4,59 @@
 
 /* File in use complete MAR file staged patch apply failure test */
 
+const STATE_AFTER_STAGE = IS_SERVICE_TEST ? STATE_APPLIED_SVC : STATE_APPLIED;
+
 function run_test() {
-  gStageUpdate = true;
-  setupTestCommon();
+  if (!setupTestCommon()) {
+    return;
+  }
   gTestFiles = gTestFilesCompleteSuccess;
   gTestDirs = gTestDirsCompleteSuccess;
-  setTestFilesAndDirsForFailure();
-  setupUpdaterTest(FILE_COMPLETE_MAR);
-
-  // Launch an existing file so it is in use during the update.
-  let fileInUseBin = getApplyDirFile(gTestFiles[13].relPathDir +
-                                     gTestFiles[13].fileName);
-  let args = [getApplyDirPath() + DIR_RESOURCES, "input", "output", "-s",
-              HELPER_SLEEP_TIMEOUT];
-  let fileInUseProcess = Cc["@mozilla.org/process/util;1"].
-                         createInstance(Ci.nsIProcess);
-  fileInUseProcess.init(fileInUseBin);
-  fileInUseProcess.run(false, args, args.length);
-
-  do_timeout(TEST_HELPER_TIMEOUT, waitForHelperSleep);
+  setupUpdaterTest(FILE_COMPLETE_MAR, false);
 }
 
-function doUpdate() {
-  runUpdate(0, STATE_APPLIED, null);
+/**
+ * Called after the call to setupUpdaterTest finishes.
+ */
+function setupUpdaterTestFinished() {
+  runHelperFileInUse(gTestFiles[13].relPathDir + gTestFiles[13].fileName,
+                     false);
+}
 
+/**
+ * Called after the call to waitForHelperSleep finishes.
+ */
+function waitForHelperSleepFinished() {
+  stageUpdate();
+}
+
+/**
+ * Called after the call to stageUpdate finishes.
+ */
+function stageUpdateFinished() {
+  checkPostUpdateRunningFile(false);
+  checkFilesAfterUpdateSuccess(getStageDirFile, true);
+  checkUpdateLogContents(LOG_COMPLETE_SUCCESS_STAGE, true);
   // Switch the application to the staged application that was updated.
-  gStageUpdate = false;
-  gSwitchApp = true;
-  runUpdate(1, STATE_PENDING, checkUpdateApplied);
+  runUpdate(STATE_PENDING, true, 1, false);
 }
 
-function checkUpdateApplied() {
-  setupHelperFinish();
+/**
+ * Called after the call to runUpdate finishes.
+ */
+function runUpdateFinished() {
+  waitForHelperExit();
 }
 
-function checkUpdate() {
-  checkFilesAfterUpdateFailure(getApplyDirFile, false, false);
+/**
+ * Called after the call to waitForHelperExit finishes.
+ */
+function waitForHelperExitFinished() {
+  standardInit();
+  checkPostUpdateRunningFile(false);
+  setTestFilesAndDirsForFailure();
+  checkFilesAfterUpdateFailure(getApplyDirFile);
   checkUpdateLogContains(ERR_RENAME_FILE);
   checkUpdateLogContains(ERR_MOVE_DESTDIR_7);
-  standardInit();
-  checkCallbackAppLog();
+  checkCallbackLog();
 }
diff --git a/toolkit/mozapps/update/tests/unit_base_updater/marFileInUseStageFailurePartial_win.js b/toolkit/mozapps/update/tests/unit_base_updater/marFileInUseStageFailurePartial_win.js
index 8fe8215b3ca1..7ee5f38834e7 100644
--- a/toolkit/mozapps/update/tests/unit_base_updater/marFileInUseStageFailurePartial_win.js
+++ b/toolkit/mozapps/update/tests/unit_base_updater/marFileInUseStageFailurePartial_win.js
@@ -4,44 +4,59 @@
 
 /* File in use partial MAR file staged patch apply failure test */
 
+const STATE_AFTER_STAGE = IS_SERVICE_TEST ? STATE_APPLIED_SVC : STATE_APPLIED;
+
 function run_test() {
-  gStageUpdate = true;
-  setupTestCommon();
+  if (!setupTestCommon()) {
+    return;
+  }
   gTestFiles = gTestFilesPartialSuccess;
   gTestDirs = gTestDirsPartialSuccess;
-  setTestFilesAndDirsForFailure();
-  setupUpdaterTest(FILE_PARTIAL_MAR);
-
-  // Launch an existing file so it is in use during the update.
-  let fileInUseBin = getApplyDirFile(gTestFiles[11].relPathDir +
-                                     gTestFiles[11].fileName);
-  let args = [getApplyDirPath() + DIR_RESOURCES, "input", "output", "-s",
-              HELPER_SLEEP_TIMEOUT];
-  let fileInUseProcess = Cc["@mozilla.org/process/util;1"].
-                         createInstance(Ci.nsIProcess);
-  fileInUseProcess.init(fileInUseBin);
-  fileInUseProcess.run(false, args, args.length);
-
-  do_timeout(TEST_HELPER_TIMEOUT, waitForHelperSleep);
+  setupUpdaterTest(FILE_PARTIAL_MAR, false);
 }
 
-function doUpdate() {
-  runUpdate(0, STATE_APPLIED, null);
+/**
+ * Called after the call to setupUpdaterTest finishes.
+ */
+function setupUpdaterTestFinished() {
+  runHelperFileInUse(gTestFiles[11].relPathDir + gTestFiles[11].fileName,
+                     false);
+}
 
+/**
+ * Called after the call to waitForHelperSleep finishes.
+ */
+function waitForHelperSleepFinished() {
+  stageUpdate();
+}
+
+/**
+ * Called after the call to stageUpdate finishes.
+ */
+function stageUpdateFinished() {
+  checkPostUpdateRunningFile(false);
+  checkFilesAfterUpdateSuccess(getStageDirFile, true);
+  checkUpdateLogContents(LOG_PARTIAL_SUCCESS_STAGE, true);
   // Switch the application to the staged application that was updated.
-  gStageUpdate = false;
-  gSwitchApp = true;
-  runUpdate(1, STATE_PENDING, checkUpdateApplied);
+  runUpdate(STATE_PENDING, true, 1, false);
 }
 
-function checkUpdateApplied() {
-  setupHelperFinish();
+/**
+ * Called after the call to runUpdate finishes.
+ */
+function runUpdateFinished() {
+  waitForHelperExit();
 }
 
-function checkUpdate() {
-  checkFilesAfterUpdateFailure(getApplyDirFile, false, false);
+/**
+ * Called after the call to waitForHelperExit finishes.
+ */
+function waitForHelperExitFinished() {
+  standardInit();
+  checkPostUpdateRunningFile(false);
+  setTestFilesAndDirsForFailure();
+  checkFilesAfterUpdateFailure(getApplyDirFile);
   checkUpdateLogContains(ERR_RENAME_FILE);
   checkUpdateLogContains(ERR_MOVE_DESTDIR_7);
-  standardInit();
-  checkCallbackAppLog();
+  checkCallbackLog();
 }
diff --git a/toolkit/mozapps/update/tests/unit_base_updater/marFileInUseSuccessComplete_win.js b/toolkit/mozapps/update/tests/unit_base_updater/marFileInUseSuccessComplete_win.js
index 98ca7418a0fe..c0e93735d6f5 100644
--- a/toolkit/mozapps/update/tests/unit_base_updater/marFileInUseSuccessComplete_win.js
+++ b/toolkit/mozapps/update/tests/unit_base_updater/marFileInUseSuccessComplete_win.js
@@ -5,35 +5,50 @@
 /* File in use complete MAR file patch apply success test */
 
 function run_test() {
-  setupTestCommon();
+  if (!setupTestCommon()) {
+    return;
+  }
   gTestFiles = gTestFilesCompleteSuccess;
   gTestDirs = gTestDirsCompleteSuccess;
-  setupUpdaterTest(FILE_COMPLETE_MAR);
-
-  // Launch an existing file so it is in use during the update.
-  let fileInUseBin = getApplyDirFile(gTestFiles[13].relPathDir +
-                                     gTestFiles[13].fileName);
-  let args = [getApplyDirPath() + DIR_RESOURCES, "input", "output", "-s",
-              HELPER_SLEEP_TIMEOUT];
-  let fileInUseProcess = Cc["@mozilla.org/process/util;1"].
-                         createInstance(Ci.nsIProcess);
-  fileInUseProcess.init(fileInUseBin);
-  fileInUseProcess.run(false, args, args.length);
-
-  do_timeout(TEST_HELPER_TIMEOUT, waitForHelperSleep);
+  setupUpdaterTest(FILE_COMPLETE_MAR, false);
 }
 
-function doUpdate() {
-  runUpdate(0, STATE_SUCCEEDED, checkUpdateFinished);
+/**
+ * Called after the call to setupUpdaterTest finishes.
+ */
+function setupUpdaterTestFinished() {
+  runHelperFileInUse(gTestFiles[13].relPathDir + gTestFiles[13].fileName,
+                     false);
 }
 
-function checkUpdateFinished() {
-  setupHelperFinish();
+/**
+ * Called after the call to waitForHelperSleep finishes.
+ */
+function waitForHelperSleepFinished() {
+  runUpdate(STATE_SUCCEEDED, false, 0, true);
 }
 
-function checkUpdate() {
+/**
+ * Called after the call to runUpdate finishes.
+ */
+function runUpdateFinished() {
+  waitForHelperExit();
+}
+
+/**
+ * Called after the call to waitForHelperExit finishes.
+ */
+function waitForHelperExitFinished() {
+  checkPostUpdateAppLog();
+}
+
+/**
+ * Called after the call to checkPostUpdateAppLog finishes.
+ */
+function checkPostUpdateAppLogFinished() {
+  standardInit();
+  checkPostUpdateRunningFile(true);
   checkFilesAfterUpdateSuccess(getApplyDirFile, false, true);
   checkUpdateLogContains(ERR_BACKUP_DISCARD);
-  standardInit();
-  checkCallbackAppLog();
+  checkCallbackLog();
 }
diff --git a/toolkit/mozapps/update/tests/unit_base_updater/marFileInUseSuccessPartial_win.js b/toolkit/mozapps/update/tests/unit_base_updater/marFileInUseSuccessPartial_win.js
index a4ef3bedd28a..15509c1e99a9 100644
--- a/toolkit/mozapps/update/tests/unit_base_updater/marFileInUseSuccessPartial_win.js
+++ b/toolkit/mozapps/update/tests/unit_base_updater/marFileInUseSuccessPartial_win.js
@@ -5,35 +5,50 @@
 /* File in use partial MAR file patch apply success test */
 
 function run_test() {
-  setupTestCommon();
+  if (!setupTestCommon()) {
+    return;
+  }
   gTestFiles = gTestFilesPartialSuccess;
   gTestDirs = gTestDirsPartialSuccess;
-  setupUpdaterTest(FILE_PARTIAL_MAR);
-
-  // Launch an existing file so it is in use during the update.
-  let fileInUseBin = getApplyDirFile(gTestFiles[11].relPathDir +
-                                     gTestFiles[11].fileName);
-  let args = [getApplyDirPath() + DIR_RESOURCES, "input", "output", "-s",
-              HELPER_SLEEP_TIMEOUT];
-  let fileInUseProcess = Cc["@mozilla.org/process/util;1"].
-                         createInstance(Ci.nsIProcess);
-  fileInUseProcess.init(fileInUseBin);
-  fileInUseProcess.run(false, args, args.length);
-
-  do_timeout(TEST_HELPER_TIMEOUT, waitForHelperSleep);
+  setupUpdaterTest(FILE_PARTIAL_MAR, false);
 }
 
-function doUpdate() {
-  runUpdate(0, STATE_SUCCEEDED, checkUpdateFinished);
+/**
+ * Called after the call to setupUpdaterTest finishes.
+ */
+function setupUpdaterTestFinished() {
+  runHelperFileInUse(gTestFiles[11].relPathDir + gTestFiles[11].fileName,
+                     false);
 }
 
-function checkUpdateFinished() {
-  setupHelperFinish();
+/**
+ * Called after the call to waitForHelperSleep finishes.
+ */
+function waitForHelperSleepFinished() {
+  runUpdate(STATE_SUCCEEDED, false, 0, true);
 }
 
-function checkUpdate() {
+/**
+ * Called after the call to runUpdate finishes.
+ */
+function runUpdateFinished() {
+  waitForHelperExit();
+}
+
+/**
+ * Called after the call to waitForHelperExit finishes.
+ */
+function waitForHelperExitFinished() {
+  checkPostUpdateAppLog();
+}
+
+/**
+ * Called after the call to checkPostUpdateAppLog finishes.
+ */
+function checkPostUpdateAppLogFinished() {
+  standardInit();
+  checkPostUpdateRunningFile(true);
   checkFilesAfterUpdateSuccess(getApplyDirFile, false, true);
   checkUpdateLogContains(ERR_BACKUP_DISCARD);
-  standardInit();
-  checkCallbackAppLog();
+  checkCallbackLog();
 }
diff --git a/toolkit/mozapps/update/tests/unit_base_updater/marFileLockedFailureComplete_win.js b/toolkit/mozapps/update/tests/unit_base_updater/marFileLockedFailureComplete_win.js
index 5b3cb0a748d1..0e40d6578d38 100644
--- a/toolkit/mozapps/update/tests/unit_base_updater/marFileLockedFailureComplete_win.js
+++ b/toolkit/mozapps/update/tests/unit_base_updater/marFileLockedFailureComplete_win.js
@@ -5,45 +5,43 @@
 /* File locked complete MAR file patch apply failure test */
 
 function run_test() {
-  setupTestCommon();
+  if (!setupTestCommon()) {
+    return;
+  }
   gTestFiles = gTestFilesCompleteSuccess;
   gTestDirs = gTestDirsCompleteSuccess;
   setTestFilesAndDirsForFailure();
-  setupUpdaterTest(FILE_COMPLETE_MAR);
-
-  // Exclusively lock an existing file so it is in use during the update.
-  let helperBin = getTestDirFile(FILE_HELPER_BIN);
-  let helperDestDir = getApplyDirFile(DIR_RESOURCES);
-  helperBin.copyTo(helperDestDir, FILE_HELPER_BIN);
-  helperBin = getApplyDirFile(DIR_RESOURCES + FILE_HELPER_BIN);
-  // Strip off the first two directories so the path has to be from the helper's
-  // working directory.
-  let lockFileRelPath = gTestFiles[3].relPathDir.split("/");
-  if (IS_MACOSX) {
-    lockFileRelPath = lockFileRelPath.slice(2);
-  }
-  lockFileRelPath = lockFileRelPath.join("/") + "/" + gTestFiles[3].fileName;
-  let args = [getApplyDirPath() + DIR_RESOURCES, "input", "output", "-s",
-              HELPER_SLEEP_TIMEOUT, lockFileRelPath];
-  let lockFileProcess = Cc["@mozilla.org/process/util;1"].
-                        createInstance(Ci.nsIProcess);
-  lockFileProcess.init(helperBin);
-  lockFileProcess.run(false, args, args.length);
-
-  do_timeout(TEST_HELPER_TIMEOUT, waitForHelperSleep);
+  setupUpdaterTest(FILE_COMPLETE_MAR, false);
 }
 
-function doUpdate() {
-  runUpdate(1, STATE_FAILED_WRITE_ERROR, checkUpdateFinished);
+/**
+ * Called after the call to setupUpdaterTest finishes.
+ */
+function setupUpdaterTestFinished() {
+  runHelperLockFile(gTestFiles[3]);
 }
 
-function checkUpdateFinished() {
-  setupHelperFinish();
+/**
+ * Called after the call to waitForHelperSleep finishes.
+ */
+function waitForHelperSleepFinished() {
+  runUpdate(STATE_FAILED_WRITE_ERROR, false, 1, true);
 }
 
-function checkUpdate() {
-  checkFilesAfterUpdateFailure(getApplyDirFile, false, false);
-  checkUpdateLogContains(ERR_RENAME_FILE);
+/**
+ * Called after the call to runUpdate finishes.
+ */
+function runUpdateFinished() {
+  waitForHelperExit();
+}
+
+/**
+ * Called after the call to waitForHelperExit finishes.
+ */
+function waitForHelperExitFinished() {
   standardInit();
-  checkCallbackAppLog();
+  checkPostUpdateRunningFile(false);
+  checkFilesAfterUpdateFailure(getApplyDirFile);
+  checkUpdateLogContains(ERR_RENAME_FILE);
+  checkCallbackLog();
 }
diff --git a/toolkit/mozapps/update/tests/unit_base_updater/marFileLockedFailurePartial_win.js b/toolkit/mozapps/update/tests/unit_base_updater/marFileLockedFailurePartial_win.js
index d806871b45e3..2eee830bdfc5 100644
--- a/toolkit/mozapps/update/tests/unit_base_updater/marFileLockedFailurePartial_win.js
+++ b/toolkit/mozapps/update/tests/unit_base_updater/marFileLockedFailurePartial_win.js
@@ -5,45 +5,43 @@
 /* File locked partial MAR file patch apply failure test */
 
 function run_test() {
-  setupTestCommon();
+  if (!setupTestCommon()) {
+    return;
+  }
   gTestFiles = gTestFilesPartialSuccess;
   gTestDirs = gTestDirsPartialSuccess;
   setTestFilesAndDirsForFailure();
-  setupUpdaterTest(FILE_PARTIAL_MAR);
-
-  // Exclusively lock an existing file so it is in use during the update.
-  let helperBin = getTestDirFile(FILE_HELPER_BIN);
-  let helperDestDir = getApplyDirFile(DIR_RESOURCES);
-  helperBin.copyTo(helperDestDir, FILE_HELPER_BIN);
-  helperBin = getApplyDirFile(DIR_RESOURCES + FILE_HELPER_BIN);
-  // Strip off the first two directories so the path has to be from the helper's
-  // working directory.
-  let lockFileRelPath = gTestFiles[2].relPathDir.split("/");
-  if (IS_MACOSX) {
-    lockFileRelPath = lockFileRelPath.slice(2);
-  }
-  lockFileRelPath = lockFileRelPath.join("/") + "/" + gTestFiles[2].fileName;
-  let args = [getApplyDirPath() + DIR_RESOURCES, "input", "output", "-s",
-              HELPER_SLEEP_TIMEOUT, lockFileRelPath];
-  let lockFileProcess = Cc["@mozilla.org/process/util;1"].
-                        createInstance(Ci.nsIProcess);
-  lockFileProcess.init(helperBin);
-  lockFileProcess.run(false, args, args.length);
-
-  do_timeout(TEST_HELPER_TIMEOUT, waitForHelperSleep);
+  setupUpdaterTest(FILE_PARTIAL_MAR, false);
 }
 
-function doUpdate() {
-  runUpdate(1, STATE_FAILED_READ_ERROR, checkUpdateFinished);
+/**
+ * Called after the call to setupUpdaterTest finishes.
+ */
+function setupUpdaterTestFinished() {
+  runHelperLockFile(gTestFiles[2]);
 }
 
-function checkUpdateFinished() {
-  setupHelperFinish();
+/**
+ * Called after the call to waitForHelperSleep finishes.
+ */
+function waitForHelperSleepFinished() {
+  runUpdate(STATE_FAILED_READ_ERROR, false, 1, true);
 }
 
-function checkUpdate() {
-  checkFilesAfterUpdateFailure(getApplyDirFile, false, false);
-  checkUpdateLogContains(ERR_UNABLE_OPEN_DEST);
+/**
+ * Called after the call to runUpdate finishes.
+ */
+function runUpdateFinished() {
+  waitForHelperExit();
+}
+
+/**
+ * Called after the call to waitForHelperExit finishes.
+ */
+function waitForHelperExitFinished() {
   standardInit();
-  checkCallbackAppLog();
+  checkPostUpdateRunningFile(false);
+  checkFilesAfterUpdateFailure(getApplyDirFile);
+  checkUpdateLogContains(ERR_UNABLE_OPEN_DEST);
+  checkCallbackLog();
 }
diff --git a/toolkit/mozapps/update/tests/unit_base_updater/marFileLockedStageFailureComplete_win.js b/toolkit/mozapps/update/tests/unit_base_updater/marFileLockedStageFailureComplete_win.js
index 5b13e53eae9d..1d7915396fa3 100644
--- a/toolkit/mozapps/update/tests/unit_base_updater/marFileLockedStageFailureComplete_win.js
+++ b/toolkit/mozapps/update/tests/unit_base_updater/marFileLockedStageFailureComplete_win.js
@@ -4,53 +4,60 @@
 
 /* File locked complete MAR file staged patch apply failure test */
 
+const STATE_AFTER_STAGE = IS_SERVICE_TEST ? STATE_PENDING : STATE_APPLYING;
+
 function run_test() {
-  gStageUpdate = true;
-  setupTestCommon();
+  if (!setupTestCommon()) {
+    return;
+  }
   gTestFiles = gTestFilesCompleteSuccess;
   gTestDirs = gTestDirsCompleteSuccess;
   setTestFilesAndDirsForFailure();
-  setupUpdaterTest(FILE_COMPLETE_MAR);
-
-  // Exclusively lock an existing file so it is in use during the update.
-  let helperBin = getTestDirFile(FILE_HELPER_BIN);
-  let helperDestDir = getApplyDirFile(DIR_RESOURCES);
-  helperBin.copyTo(helperDestDir, FILE_HELPER_BIN);
-  helperBin = getApplyDirFile(DIR_RESOURCES + FILE_HELPER_BIN);
-  // Strip off the first two directories so the path has to be from the helper's
-  // working directory.
-  let lockFileRelPath = gTestFiles[3].relPathDir.split("/");
-  if (IS_MACOSX) {
-    lockFileRelPath = lockFileRelPath.slice(2);
-  }
-  lockFileRelPath = lockFileRelPath.join("/") + "/" + gTestFiles[3].fileName;
-  let args = [getApplyDirPath() + DIR_RESOURCES, "input", "output", "-s",
-              HELPER_SLEEP_TIMEOUT, lockFileRelPath];
-  let lockFileProcess = Cc["@mozilla.org/process/util;1"].
-                        createInstance(Ci.nsIProcess);
-  lockFileProcess.init(helperBin);
-  lockFileProcess.run(false, args, args.length);
-
-  do_timeout(TEST_HELPER_TIMEOUT, waitForHelperSleep);
+  setupUpdaterTest(FILE_COMPLETE_MAR, false);
 }
 
-function doUpdate() {
-  runUpdate(1, STATE_FAILED_WRITE_ERROR_FILE_COPY, null);
+/**
+ * Called after the call to setupUpdaterTest finishes.
+ */
+function setupUpdaterTestFinished() {
+  runHelperLockFile(gTestFiles[3]);
+}
 
+/**
+ * Called after the call to waitForHelperSleep finishes.
+ */
+function waitForHelperSleepFinished() {
+  stageUpdate();
+}
+
+/**
+ * Called after the call to stageUpdate finishes.
+ */
+function stageUpdateFinished() {
+  checkPostUpdateRunningFile(false);
+  // Files aren't checked after staging since this test locks a file which
+  // prevents reading the file.
+  checkUpdateLogContains(ERR_ENSURE_COPY);
   // Switch the application to the staged application that was updated.
-  gStageUpdate = false;
-  gSwitchApp = true;
-  runUpdate(1, STATE_PENDING, checkUpdateApplied);
+  runUpdate(STATE_FAILED_WRITE_ERROR, false, 1, false);
 }
 
-function checkUpdateApplied() {
-  setupHelperFinish();
+/**
+ * Called after the call to runUpdate finishes.
+ */
+function runUpdateFinished() {
+  waitForHelperExit();
 }
 
-function checkUpdate() {
-  checkFilesAfterUpdateFailure(getApplyDirFile, false, false);
-  checkUpdateLogContains(ERR_RENAME_FILE);
-  checkUpdateLogContains(ERR_MOVE_DESTDIR_7);
+/**
+ * Called after the call to waitForHelperExit finishes.
+ */
+function waitForHelperExitFinished() {
   standardInit();
-  checkCallbackAppLog();
+  checkPostUpdateRunningFile(false);
+  checkFilesAfterUpdateFailure(getApplyDirFile);
+  checkUpdateLogContains(ERR_RENAME_FILE);
+  checkUpdateLogContains(ERR_BACKUP_CREATE_7);
+  checkUpdateLogContains(STATE_FAILED_WRITE_ERROR + "\n" + CALL_QUIT);
+  checkCallbackLog();
 }
diff --git a/toolkit/mozapps/update/tests/unit_base_updater/marFileLockedStageFailurePartial_win.js b/toolkit/mozapps/update/tests/unit_base_updater/marFileLockedStageFailurePartial_win.js
index a69934601cc0..1a38f65b1134 100644
--- a/toolkit/mozapps/update/tests/unit_base_updater/marFileLockedStageFailurePartial_win.js
+++ b/toolkit/mozapps/update/tests/unit_base_updater/marFileLockedStageFailurePartial_win.js
@@ -4,53 +4,59 @@
 
 /* File locked partial MAR file staged patch apply failure test */
 
+const STATE_AFTER_STAGE = IS_SERVICE_TEST ? STATE_PENDING : STATE_APPLYING;
+
 function run_test() {
-  gStageUpdate = true;
-  setupTestCommon();
+  if (!setupTestCommon()) {
+    return;
+  }
   gTestFiles = gTestFilesPartialSuccess;
   gTestDirs = gTestDirsPartialSuccess;
   setTestFilesAndDirsForFailure();
-  setupUpdaterTest(FILE_PARTIAL_MAR);
-
-  // Exclusively lock an existing file so it is in use during the update.
-  let helperBin = getTestDirFile(FILE_HELPER_BIN);
-  let helperDestDir = getApplyDirFile(DIR_RESOURCES);
-  helperBin.copyTo(helperDestDir, FILE_HELPER_BIN);
-  helperBin = getApplyDirFile(DIR_RESOURCES + FILE_HELPER_BIN);
-  // Strip off the first two directories so the path has to be from the helper's
-  // working directory.
-  let lockFileRelPath = gTestFiles[2].relPathDir.split("/");
-  if (IS_MACOSX) {
-    lockFileRelPath = lockFileRelPath.slice(2);
-  }
-  lockFileRelPath = lockFileRelPath.join("/") + "/" + gTestFiles[2].fileName;
-  let args = [getApplyDirPath() + DIR_RESOURCES, "input", "output", "-s",
-              HELPER_SLEEP_TIMEOUT, lockFileRelPath];
-  let lockFileProcess = Cc["@mozilla.org/process/util;1"].
-                        createInstance(Ci.nsIProcess);
-  lockFileProcess.init(helperBin);
-  lockFileProcess.run(false, args, args.length);
-
-  do_timeout(TEST_HELPER_TIMEOUT, waitForHelperSleep);
+  setupUpdaterTest(FILE_PARTIAL_MAR, false);
 }
 
-function doUpdate() {
-  runUpdate(1, STATE_FAILED_WRITE_ERROR_FILE_COPY, null);
+/**
+ * Called after the call to setupUpdaterTest finishes.
+ */
+function setupUpdaterTestFinished() {
+  runHelperLockFile(gTestFiles[2]);
+}
 
+/**
+ * Called after the call to waitForHelperSleep finishes.
+ */
+function waitForHelperSleepFinished() {
+  stageUpdate();
+}
+
+/**
+ * Called after the call to stageUpdate finishes.
+ */
+function stageUpdateFinished() {
+  checkPostUpdateRunningFile(false);
+  // Files aren't checked after staging since this test locks a file which
+  // prevents reading the file.
+  checkUpdateLogContains(ERR_ENSURE_COPY);
   // Switch the application to the staged application that was updated.
-  gStageUpdate = false;
-  gSwitchApp = true;
-  runUpdate(1, STATE_PENDING, checkUpdateApplied);
+  runUpdate(STATE_FAILED_READ_ERROR, false, 1, false);
 }
 
-function checkUpdateApplied() {
-  setupHelperFinish();
+/**
+ * Called after the call to runUpdate finishes.
+ */
+function runUpdateFinished() {
+  waitForHelperExit();
 }
 
-function checkUpdate() {
-  checkFilesAfterUpdateFailure(getApplyDirFile, false, false);
-  checkUpdateLogContains(ERR_RENAME_FILE);
-  checkUpdateLogContains(ERR_MOVE_DESTDIR_7);
+/**
+ * Called after the call to waitForHelperExit finishes.
+ */
+function waitForHelperExitFinished() {
   standardInit();
-  checkCallbackAppLog();
+  checkPostUpdateRunningFile(false);
+  checkFilesAfterUpdateFailure(getApplyDirFile);
+  checkUpdateLogContains(ERR_UNABLE_OPEN_DEST);
+  checkUpdateLogContains(STATE_FAILED_READ_ERROR + "\n" + CALL_QUIT);
+  checkCallbackLog();
 }
diff --git a/toolkit/mozapps/update/tests/unit_base_updater/marRMRFDirFileInUseStageFailureComplete_win.js b/toolkit/mozapps/update/tests/unit_base_updater/marRMRFDirFileInUseStageFailureComplete_win.js
index 5b043d0f7d06..ae494b5a33c0 100644
--- a/toolkit/mozapps/update/tests/unit_base_updater/marRMRFDirFileInUseStageFailureComplete_win.js
+++ b/toolkit/mozapps/update/tests/unit_base_updater/marRMRFDirFileInUseStageFailureComplete_win.js
@@ -5,53 +5,59 @@
 /* File in use inside removed dir complete MAR file staged patch apply failure
    test */
 
+const STATE_AFTER_STAGE = IS_SERVICE_TEST ? STATE_APPLIED_SVC : STATE_APPLIED;
+
 function run_test() {
-  gStageUpdate = true;
-  setupTestCommon();
+  if (!setupTestCommon()) {
+    return;
+  }
   gTestFiles = gTestFilesCompleteSuccess;
   gTestDirs = gTestDirsCompleteSuccess;
-  setTestFilesAndDirsForFailure();
-  setupUpdaterTest(FILE_COMPLETE_MAR);
-
-  let fileInUseBin = getApplyDirFile(gTestDirs[4].relPathDir +
-                                     gTestDirs[4].subDirs[0] +
-                                     gTestDirs[4].subDirFiles[0]);
-  // Remove the empty file created for the test so the helper application can
-  // replace it.
-  fileInUseBin.remove(false);
-
-  let helperBin = getTestDirFile(FILE_HELPER_BIN);
-  let fileInUseDir = getApplyDirFile(gTestDirs[4].relPathDir +
-                                     gTestDirs[4].subDirs[0]);
-  helperBin.copyTo(fileInUseDir, gTestDirs[4].subDirFiles[0]);
-
-  // Launch an existing file so it is in use during the update.
-  let args = [getApplyDirPath() + DIR_RESOURCES, "input", "output", "-s",
-              HELPER_SLEEP_TIMEOUT];
-  let fileInUseProcess = Cc["@mozilla.org/process/util;1"].
-                         createInstance(Ci.nsIProcess);
-  fileInUseProcess.init(fileInUseBin);
-  fileInUseProcess.run(false, args, args.length);
-
-  do_timeout(TEST_HELPER_TIMEOUT, waitForHelperSleep);
+  setupUpdaterTest(FILE_COMPLETE_MAR, false);
 }
-function doUpdate() {
-  runUpdate(0, STATE_APPLIED, null);
 
+/**
+ * Called after the call to setupUpdaterTest finishes.
+ */
+function setupUpdaterTestFinished() {
+  runHelperFileInUse(gTestDirs[4].relPathDir + gTestDirs[4].subDirs[0] +
+                     gTestDirs[4].subDirFiles[0], true);
+}
+
+/**
+ * Called after the call to waitForHelperSleep finishes.
+ */
+function waitForHelperSleepFinished() {
+  stageUpdate();
+}
+
+/**
+ * Called after the call to stageUpdate finishes.
+ */
+function stageUpdateFinished() {
+  checkPostUpdateRunningFile(false);
+  checkFilesAfterUpdateSuccess(getStageDirFile, true);
+  checkUpdateLogContents(LOG_COMPLETE_SUCCESS_STAGE, true);
   // Switch the application to the staged application that was updated.
-  gStageUpdate = false;
-  gSwitchApp = true;
-  runUpdate(1, STATE_PENDING, checkUpdateApplied);
+  runUpdate(STATE_PENDING, true, 1, false);
 }
 
-function checkUpdateApplied() {
-  setupHelperFinish();
+/**
+ * Called after the call to runUpdate finishes.
+ */
+function runUpdateFinished() {
+  waitForHelperExit();
 }
 
-function checkUpdate() {
-  checkFilesAfterUpdateFailure(getApplyDirFile, false, false);
+/**
+ * Called after the call to waitForHelperExit finishes.
+ */
+function waitForHelperExitFinished() {
+  standardInit();
+  checkPostUpdateRunningFile(false);
+  setTestFilesAndDirsForFailure();
+  checkFilesAfterUpdateFailure(getApplyDirFile);
   checkUpdateLogContains(ERR_RENAME_FILE);
   checkUpdateLogContains(ERR_MOVE_DESTDIR_7);
-  standardInit();
-  checkCallbackAppLog();
+  checkCallbackLog();
 }
diff --git a/toolkit/mozapps/update/tests/unit_base_updater/marRMRFDirFileInUseStageFailurePartial_win.js b/toolkit/mozapps/update/tests/unit_base_updater/marRMRFDirFileInUseStageFailurePartial_win.js
index 6d16e3ed5edb..bc2d94360e7f 100644
--- a/toolkit/mozapps/update/tests/unit_base_updater/marRMRFDirFileInUseStageFailurePartial_win.js
+++ b/toolkit/mozapps/update/tests/unit_base_updater/marRMRFDirFileInUseStageFailurePartial_win.js
@@ -5,52 +5,58 @@
 /* File in use inside removed dir partial MAR file staged patch apply failure
    test */
 
+const STATE_AFTER_STAGE = IS_SERVICE_TEST ? STATE_APPLIED_SVC : STATE_APPLIED;
+
 function run_test() {
-  gStageUpdate = true;
-  setupTestCommon();
+  if (!setupTestCommon()) {
+    return;
+  }
   gTestFiles = gTestFilesPartialSuccess;
   gTestDirs = gTestDirsPartialSuccess;
-  setTestFilesAndDirsForFailure();
-  setupUpdaterTest(FILE_PARTIAL_MAR);
-
-  let fileInUseBin = getApplyDirFile(gTestDirs[2].relPathDir +
-                                     gTestDirs[2].files[0]);
-  // Remove the empty file created for the test so the helper application can
-  // replace it.
-  fileInUseBin.remove(false);
-
-  let helperBin = getTestDirFile(FILE_HELPER_BIN);
-  let fileInUseDir = getApplyDirFile(gTestDirs[2].relPathDir);
-  helperBin.copyTo(fileInUseDir, gTestDirs[2].files[0]);
-
-  // Launch an existing file so it is in use during the update.
-  let args = [getApplyDirPath() + DIR_RESOURCES, "input", "output", "-s",
-              HELPER_SLEEP_TIMEOUT];
-  let fileInUseProcess = Cc["@mozilla.org/process/util;1"].
-                         createInstance(Ci.nsIProcess);
-  fileInUseProcess.init(fileInUseBin);
-  fileInUseProcess.run(false, args, args.length);
-
-  do_timeout(TEST_HELPER_TIMEOUT, waitForHelperSleep);
+  setupUpdaterTest(FILE_PARTIAL_MAR, false);
 }
 
-function doUpdate() {
-  runUpdate(0, STATE_APPLIED, null);
+/**
+ * Called after the call to setupUpdaterTest finishes.
+ */
+function setupUpdaterTestFinished() {
+  runHelperFileInUse(gTestDirs[2].relPathDir + gTestDirs[2].files[0], true);
+}
 
+/**
+ * Called after the call to waitForHelperSleep finishes.
+ */
+function waitForHelperSleepFinished() {
+  stageUpdate();
+}
+
+/**
+ * Called after the call to stageUpdate finishes.
+ */
+function stageUpdateFinished() {
+  checkPostUpdateRunningFile(false);
+  checkFilesAfterUpdateSuccess(getStageDirFile, true);
+  checkUpdateLogContents(LOG_PARTIAL_SUCCESS_STAGE, true);
   // Switch the application to the staged application that was updated.
-  gStageUpdate = false;
-  gSwitchApp = true;
-  runUpdate(1, STATE_PENDING, checkUpdateApplied);
+  runUpdate(STATE_PENDING, true, 1, false);
 }
 
-function checkUpdateApplied() {
-  setupHelperFinish();
+/**
+ * Called after the call to runUpdate finishes.
+ */
+function runUpdateFinished() {
+  waitForHelperExit();
 }
 
-function checkUpdate() {
-  checkFilesAfterUpdateFailure(getApplyDirFile, false, false);
+/**
+ * Called after the call to waitForHelperExit finishes.
+ */
+function waitForHelperExitFinished() {
+  standardInit();
+  checkPostUpdateRunningFile(false);
+  setTestFilesAndDirsForFailure();
+  checkFilesAfterUpdateFailure(getApplyDirFile);
   checkUpdateLogContains(ERR_RENAME_FILE);
   checkUpdateLogContains(ERR_MOVE_DESTDIR_7);
-  standardInit();
-  checkCallbackAppLog();
+  checkCallbackLog();
 }
diff --git a/toolkit/mozapps/update/tests/unit_base_updater/marRMRFDirFileInUseSuccessComplete_win.js b/toolkit/mozapps/update/tests/unit_base_updater/marRMRFDirFileInUseSuccessComplete_win.js
index 163537231091..ea2dd69597b0 100644
--- a/toolkit/mozapps/update/tests/unit_base_updater/marRMRFDirFileInUseSuccessComplete_win.js
+++ b/toolkit/mozapps/update/tests/unit_base_updater/marRMRFDirFileInUseSuccessComplete_win.js
@@ -5,45 +5,50 @@
 /* File in use inside removed dir complete MAR file patch apply success test */
 
 function run_test() {
-  setupTestCommon();
+  if (!setupTestCommon()) {
+    return;
+  }
   gTestFiles = gTestFilesCompleteSuccess;
   gTestDirs = gTestDirsCompleteSuccess;
-  setupUpdaterTest(FILE_COMPLETE_MAR);
-
-  let fileInUseBin = getApplyDirFile(gTestDirs[4].relPathDir +
-                                     gTestDirs[4].subDirs[0] +
-                                     gTestDirs[4].subDirFiles[0]);
-  // Remove the empty file created for the test so the helper application can
-  // replace it.
-  fileInUseBin.remove(false);
-
-  let helperBin = getTestDirFile(FILE_HELPER_BIN);
-  let fileInUseDir = getApplyDirFile(gTestDirs[4].relPathDir +
-                                     gTestDirs[4].subDirs[0]);
-  helperBin.copyTo(fileInUseDir, gTestDirs[4].subDirFiles[0]);
-
-  // Launch an existing file so it is in use during the update.
-  let args = [getApplyDirPath() + DIR_RESOURCES, "input", "output", "-s",
-              HELPER_SLEEP_TIMEOUT];
-  let fileInUseProcess = Cc["@mozilla.org/process/util;1"].
-                         createInstance(Ci.nsIProcess);
-  fileInUseProcess.init(fileInUseBin);
-  fileInUseProcess.run(false, args, args.length);
-
-  do_timeout(TEST_HELPER_TIMEOUT, waitForHelperSleep);
+  setupUpdaterTest(FILE_COMPLETE_MAR, false);
 }
 
-function doUpdate() {
-  runUpdate(0, STATE_SUCCEEDED, checkUpdateFinished);
+/**
+ * Called after the call to setupUpdaterTest finishes.
+ */
+function setupUpdaterTestFinished() {
+  runHelperFileInUse(gTestDirs[4].relPathDir + gTestDirs[4].subDirs[0] +
+                     gTestDirs[4].subDirFiles[0], true);
 }
 
-function checkUpdateFinished() {
-  setupHelperFinish();
+/**
+ * Called after the call to waitForHelperSleep finishes.
+ */
+function waitForHelperSleepFinished() {
+  runUpdate(STATE_SUCCEEDED, false, 0, true);
 }
 
-function checkUpdate() {
+/**
+ * Called after the call to runUpdate finishes.
+ */
+function runUpdateFinished() {
+  waitForHelperExit();
+}
+
+/**
+ * Called after the call to waitForHelperExit finishes.
+ */
+function waitForHelperExitFinished() {
+  checkPostUpdateAppLog();
+}
+
+/**
+ * Called after the call to checkPostUpdateAppLog finishes.
+ */
+function checkPostUpdateAppLogFinished() {
+  standardInit();
+  checkPostUpdateRunningFile(true);
   checkFilesAfterUpdateSuccess(getApplyDirFile, false, true);
   checkUpdateLogContains(ERR_BACKUP_DISCARD);
-  standardInit();
-  checkCallbackAppLog();
+  checkCallbackLog();
 }
diff --git a/toolkit/mozapps/update/tests/unit_base_updater/marRMRFDirFileInUseSuccessPartial_win.js b/toolkit/mozapps/update/tests/unit_base_updater/marRMRFDirFileInUseSuccessPartial_win.js
index 1a4a79221330..a998fe6c4b7c 100644
--- a/toolkit/mozapps/update/tests/unit_base_updater/marRMRFDirFileInUseSuccessPartial_win.js
+++ b/toolkit/mozapps/update/tests/unit_base_updater/marRMRFDirFileInUseSuccessPartial_win.js
@@ -5,43 +5,49 @@
 /* File in use inside removed dir partial MAR file patch apply success test */
 
 function run_test() {
-  setupTestCommon();
+  if (!setupTestCommon()) {
+    return;
+  }
   gTestFiles = gTestFilesPartialSuccess;
   gTestDirs = gTestDirsPartialSuccess;
-  setupUpdaterTest(FILE_PARTIAL_MAR);
-
-  let fileInUseBin = getApplyDirFile(gTestDirs[2].relPathDir +
-                                     gTestDirs[2].files[0]);
-  // Remove the empty file created for the test so the helper application can
-  // replace it.
-  fileInUseBin.remove(false);
-
-  let helperBin = getTestDirFile(FILE_HELPER_BIN);
-  let fileInUseDir = getApplyDirFile(gTestDirs[2].relPathDir);
-  helperBin.copyTo(fileInUseDir, gTestDirs[2].files[0]);
-
-  // Launch an existing file so it is in use during the update.
-  let args = [getApplyDirPath() + DIR_RESOURCES, "input", "output", "-s",
-              HELPER_SLEEP_TIMEOUT];
-  let fileInUseProcess = Cc["@mozilla.org/process/util;1"].
-                         createInstance(Ci.nsIProcess);
-  fileInUseProcess.init(fileInUseBin);
-  fileInUseProcess.run(false, args, args.length);
-
-  do_timeout(TEST_HELPER_TIMEOUT, waitForHelperSleep);
+  setupUpdaterTest(FILE_PARTIAL_MAR, false);
 }
 
-function doUpdate() {
-  runUpdate(0, STATE_SUCCEEDED, checkUpdateFinished);
+/**
+ * Called after the call to setupUpdaterTest finishes.
+ */
+function setupUpdaterTestFinished() {
+  runHelperFileInUse(gTestDirs[2].relPathDir + gTestDirs[2].files[0], true);
 }
 
-function checkUpdateFinished() {
-  setupHelperFinish();
+/**
+ * Called after the call to waitForHelperSleep finishes.
+ */
+function waitForHelperSleepFinished() {
+  runUpdate(STATE_SUCCEEDED, false, 0, true);
 }
 
-function checkUpdate() {
+/**
+ * Called after the call to runUpdate finishes.
+ */
+function runUpdateFinished() {
+  waitForHelperExit();
+}
+
+/**
+ * Called after the call to waitForHelperExit finishes.
+ */
+function waitForHelperExitFinished() {
+  checkPostUpdateAppLog();
+}
+
+/**
+ * Called after the call to checkPostUpdateAppLog finishes.
+ */
+function checkPostUpdateAppLogFinished() {
+  standardInit();
+  checkPostUpdateRunningFile(true);
   checkFilesAfterUpdateSuccess(getApplyDirFile, false, true);
   checkUpdateLogContains(ERR_BACKUP_DISCARD);
-  standardInit();
-  checkCallbackAppLog();
+  checkCallbackLog();
 }
diff --git a/toolkit/mozapps/update/tests/unit_base_updater/marStageFailurePartial.js b/toolkit/mozapps/update/tests/unit_base_updater/marStageFailurePartial.js
index 0dbf6944d6ab..e4c6280dc4fe 100644
--- a/toolkit/mozapps/update/tests/unit_base_updater/marStageFailurePartial.js
+++ b/toolkit/mozapps/update/tests/unit_base_updater/marStageFailurePartial.js
@@ -5,28 +5,33 @@
 
 /* General Partial MAR File Staged Patch Apply Failure Test */
 
+const STATE_AFTER_STAGE = IS_SERVICE_TEST ? STATE_PENDING : STATE_APPLYING;
+
 function run_test() {
-  gStageUpdate = true;
-  setupTestCommon();
+  if (!setupTestCommon()) {
+    return;
+  }
   gTestFiles = gTestFilesPartialSuccess;
   gTestFiles[11].originalFile = "partial.png";
   gTestDirs = gTestDirsPartialSuccess;
   setTestFilesAndDirsForFailure();
-  setupUpdaterTest(FILE_PARTIAL_MAR);
-
-  createUpdaterINI(true);
-
-  runUpdate(1, STATE_FAILED_LOADSOURCE_ERROR_WRONG_SIZE, checkUpdateFinished);
+  setupUpdaterTest(FILE_PARTIAL_MAR, false);
 }
 
 /**
- * Checks if the update has finished and if it has finished performs checks for
- * the test.
+ * Called after the call to setupUpdaterTest finishes.
  */
-function checkUpdateFinished() {
-  checkPostUpdateRunningFile(false);
-  checkFilesAfterUpdateFailure(getApplyDirFile, true, false);
-  checkUpdateLogContents(LOG_PARTIAL_FAILURE);
+function setupUpdaterTestFinished() {
+  stageUpdate();
+}
+
+/**
+ * Called after the call to stageUpdate finishes.
+ */
+function stageUpdateFinished() {
   standardInit();
+  checkPostUpdateRunningFile(false);
+  checkFilesAfterUpdateFailure(getApplyDirFile);
+  checkUpdateLogContains(ERR_LOADSOURCEFILE_FAILED);
   waitForFilesInUse();
 }
diff --git a/toolkit/mozapps/update/tests/unit_base_updater/marStageSuccessComplete.js b/toolkit/mozapps/update/tests/unit_base_updater/marStageSuccessComplete.js
index d63bd58f8a92..65b91ada288f 100644
--- a/toolkit/mozapps/update/tests/unit_base_updater/marStageSuccessComplete.js
+++ b/toolkit/mozapps/update/tests/unit_base_updater/marStageSuccessComplete.js
@@ -5,15 +5,65 @@
 
 /* General Complete MAR File Staged Patch Apply Test */
 
+const STATE_AFTER_STAGE = IS_SERVICE_TEST ? STATE_APPLIED_SVC : STATE_APPLIED;
+
 function run_test() {
-  gStageUpdate = true;
-  setupTestCommon();
+  if (!setupTestCommon()) {
+    return;
+  }
   gTestFiles = gTestFilesCompleteSuccess;
   gTestFiles[gTestFiles.length - 1].originalContents = null;
   gTestFiles[gTestFiles.length - 1].compareContents = "FromComplete\n";
   gTestFiles[gTestFiles.length - 1].comparePerms = 0o644;
   gTestDirs = gTestDirsCompleteSuccess;
-  setupUpdaterTest(FILE_COMPLETE_MAR);
+  setupDistributionDir();
+  setupSymLinks();
+  setupUpdaterTest(FILE_COMPLETE_MAR, false);
+}
+
+/**
+ * Called after the call to setupUpdaterTest finishes.
+ */
+function setupUpdaterTestFinished() {
+  stageUpdate();
+}
+
+/**
+ * Called after the call to stageUpdate finishes.
+ */
+function stageUpdateFinished() {
+  checkPostUpdateRunningFile(false);
+  checkFilesAfterUpdateSuccess(getStageDirFile, true);
+  checkUpdateLogContents(LOG_COMPLETE_SUCCESS_STAGE, true);
+  // Switch the application to the staged application that was updated.
+  runUpdate(STATE_SUCCEEDED, true, 0, true);
+}
+
+/**
+ * Called after the call to runUpdate finishes.
+ */
+function runUpdateFinished() {
+  checkPostUpdateAppLog();
+}
+
+/**
+ * Called after the call to checkPostUpdateAppLog finishes.
+ */
+function checkPostUpdateAppLogFinished() {
+  checkAppBundleModTime();
+  checkSymLinks();
+  standardInit();
+  checkPostUpdateRunningFile(true);
+  checkFilesAfterUpdateSuccess(getApplyDirFile, false, true);
+  checkUpdateLogContents(LOG_REPLACE_SUCCESS, false, true);
+  checkDistributionDir();
+  checkCallbackLog();
+}
+
+/**
+ * Setup the state of the distribution directory for the test.
+ */
+function setupDistributionDir() {
   if (IS_MACOSX) {
     // Create files in the old distribution directory location to verify that
     // the directory and its contents are removed when there is a distribution
@@ -23,10 +73,24 @@ function run_test() {
     testFile = getApplyDirFile(DIR_MACOS + "distribution/test1/testFile", true);
     writeFile(testFile, "test\n");
   }
+}
 
-  createUpdaterINI(false);
-  setAppBundleModTime();
+/**
+ * Checks the state of the distribution directory for the test.
+ */
+function checkDistributionDir() {
+  if (IS_MACOSX) {
+    let distributionDir = getApplyDirFile(DIR_MACOS + "distribution", true);
+    Assert.ok(!distributionDir.exists(),
+              MSG_SHOULD_NOT_EXIST + getMsgPath(distributionDir.path));
+    checkUpdateLogContains(REMOVE_OLD_DIST_DIR);
+  }
+}
 
+/**
+ * Setup symlinks for the test.
+ */
+function setupSymLinks() {
   // Don't test symlinks on Mac OS X in this test since it tends to timeout.
   // It is tested on Mac OS X in marAppInUseStageSuccessComplete_unix.js
   // The tests don't support symlinks on gonk.
@@ -47,91 +111,14 @@ function run_test() {
       comparePerms     : 0o666
     });
   }
-
-  runUpdate(0, STATE_APPLIED, null);
-
-  checkFilesAfterUpdateSuccess(getStageDirFile, true, false);
-  checkUpdateLogContents(LOG_COMPLETE_SUCCESS);
-  checkPostUpdateRunningFile(false);
-
-  // Switch the application to the staged application that was updated.
-  gStageUpdate = false;
-  gSwitchApp = true;
-  do_timeout(TEST_CHECK_TIMEOUT, function() {
-    runUpdate(0, STATE_SUCCEEDED, checkUpdateApplied);
-  });
 }
 
 /**
- * Checks if the post update binary was properly launched for the platforms that
- * support launching post update process.
+ * Checks the state of the symlinks for the test.
  */
-function checkUpdateApplied() {
-  if (IS_WIN || IS_MACOSX) {
-    gCheckFunc = finishCheckUpdateApplied;
-    checkPostUpdateAppLog();
-  } else {
-    finishCheckUpdateApplied();
-  }
-}
-
-/**
- * Checks if the update has finished and if it has finished performs checks for
- * the test.
- */
-function finishCheckUpdateApplied() {
-  checkPostUpdateRunningFile(true);
-
-  if (IS_MACOSX) {
-    let distributionDir = getApplyDirFile(DIR_MACOS + "distribution", true);
-    Assert.ok(!distributionDir.exists(), MSG_SHOULD_NOT_EXIST);
-    checkUpdateLogContains("removing old distribution directory");
-  }
-
+function checkSymLinks() {
   // The tests don't support symlinks on gonk.
   if (IS_UNIX && !IS_MACOSX && !IS_TOOLKIT_GONK) {
     checkSymlink();
   }
-  checkAppBundleModTime();
-  checkFilesAfterUpdateSuccess(getApplyDirFile, false, false);
-  checkUpdateLogContents(LOG_COMPLETE_SUCCESS);
-  standardInit();
-  checkCallbackAppLog();
-}
-
-function runHelperProcess(args) {
-  let helperBin = getTestDirFile(FILE_HELPER_BIN);
-  let process = Cc["@mozilla.org/process/util;1"].
-                createInstance(Ci.nsIProcess);
-  process.init(helperBin);
-  debugDump("Running " + helperBin.path + " " + args.join(" "));
-  process.run(true, args, args.length);
-  Assert.equal(process.exitValue, 0,
-               "the helper process exit value should be 0");
-}
-
-function createSymlink() {
-  let args = ["setup-symlink", "moz-foo", "moz-bar", "target",
-              getApplyDirFile().path + "/" + DIR_RESOURCES + "link"];
-  runHelperProcess(args);
-  getApplyDirFile(DIR_RESOURCES + "link", false).permissions = 0o666;
-
-  args = ["setup-symlink", "moz-foo2", "moz-bar2", "target2",
-          getApplyDirFile().path + "/" + DIR_RESOURCES + "link2", "change-perm"];
-  runHelperProcess(args);
-}
-
-function removeSymlink() {
-  let args = ["remove-symlink", "moz-foo", "moz-bar", "target",
-              getApplyDirFile().path + "/" + DIR_RESOURCES + "link"];
-  runHelperProcess(args);
-  args = ["remove-symlink", "moz-foo2", "moz-bar2", "target2",
-          getApplyDirFile().path + "/" + DIR_RESOURCES + "link2"];
-  runHelperProcess(args);
-}
-
-function checkSymlink() {
-  let args = ["check-symlink",
-              getApplyDirFile().path + "/" + DIR_RESOURCES + "link"];
-  runHelperProcess(args);
 }
diff --git a/toolkit/mozapps/update/tests/unit_base_updater/marStageSuccessPartial.js b/toolkit/mozapps/update/tests/unit_base_updater/marStageSuccessPartial.js
index 8e063fc2a2e2..436555db035c 100644
--- a/toolkit/mozapps/update/tests/unit_base_updater/marStageSuccessPartial.js
+++ b/toolkit/mozapps/update/tests/unit_base_updater/marStageSuccessPartial.js
@@ -5,16 +5,64 @@
 
 /* General Partial MAR File Staged Patch Apply Test */
 
+const STATE_AFTER_STAGE = IS_SERVICE_TEST ? STATE_APPLIED_SVC : STATE_APPLIED;
+
 function run_test() {
-  gStageUpdate = true;
-  setupTestCommon();
+  if (!setupTestCommon()) {
+    return;
+  }
   gTestFiles = gTestFilesPartialSuccess;
   gTestFiles[gTestFiles.length - 2].originalContents = null;
   gTestFiles[gTestFiles.length - 2].compareContents = "FromPartial\n";
   gTestFiles[gTestFiles.length - 2].comparePerms = 0o644;
   gTestDirs = gTestDirsPartialSuccess;
   preventDistributionFiles();
-  setupUpdaterTest(FILE_PARTIAL_MAR);
+  setupDistributionDir();
+  setupUpdaterTest(FILE_PARTIAL_MAR, true);
+}
+
+/**
+ * Called after the call to setupUpdaterTest finishes.
+ */
+function setupUpdaterTestFinished() {
+  stageUpdate();
+}
+
+/**
+ * Called after the call to stageUpdate finishes.
+ */
+function stageUpdateFinished() {
+  checkPostUpdateRunningFile(false);
+  checkFilesAfterUpdateSuccess(getStageDirFile, true);
+  checkUpdateLogContents(LOG_PARTIAL_SUCCESS_STAGE, true, false, true);
+  // Switch the application to the staged application that was updated.
+  runUpdate(STATE_SUCCEEDED, true, 0, false);
+}
+
+/**
+ * Called after the call to runUpdate finishes.
+ */
+function runUpdateFinished() {
+  checkPostUpdateAppLog();
+}
+
+/**
+ * Called after the call to checkPostUpdateAppLog finishes.
+ */
+function checkPostUpdateAppLogFinished() {
+  checkAppBundleModTime();
+  standardInit();
+  checkPostUpdateRunningFile(true);
+  checkFilesAfterUpdateSuccess(getApplyDirFile, false, true);
+  checkUpdateLogContents(LOG_REPLACE_SUCCESS, false, true, true);
+  checkDistributionDir();
+  checkCallbackLog();
+}
+
+/**
+ * Setup the state of the distribution directory for the test.
+ */
+function setupDistributionDir() {
   if (IS_MACOSX) {
     // Create files in the old distribution directory location to verify that
     // the directory and its contents are moved to the new location on update.
@@ -23,67 +71,34 @@ function run_test() {
     testFile = getApplyDirFile(DIR_MACOS + "distribution/test/testFile", true);
     writeFile(testFile, "test\n");
   }
-
-  createUpdaterINI(false);
-  setAppBundleModTime();
-
-  runUpdate(0, STATE_APPLIED, null);
-
-  checkFilesAfterUpdateSuccess(getStageDirFile, true, false);
-  checkUpdateLogContents(LOG_PARTIAL_SUCCESS, true);
-  checkPostUpdateRunningFile(false);
-
-  // Switch the application to the staged application that was updated.
-  gStageUpdate = false;
-  gSwitchApp = true;
-  do_timeout(TEST_CHECK_TIMEOUT, function() {
-    runUpdate(0, STATE_SUCCEEDED, checkUpdateApplied);
-  });
 }
 
 /**
- * Checks if the post update binary was properly launched for the platforms that
- * support launching post update process.
+ * Checks the state of the distribution directory.
  */
-function checkUpdateApplied() {
-  if (IS_WIN || IS_MACOSX) {
-    gCheckFunc = finishCheckUpdateApplied;
-    checkPostUpdateAppLog();
-  } else {
-    finishCheckUpdateApplied();
-  }
-}
-
-/**
- * Checks if the update has finished and if it has finished performs checks for
- * the test.
- */
-function finishCheckUpdateApplied() {
-  checkPostUpdateRunningFile(true);
-
+function checkDistributionDir() {
   let distributionDir = getApplyDirFile(DIR_RESOURCES + "distribution", true);
   if (IS_MACOSX) {
-    Assert.ok(distributionDir.exists(), MSG_SHOULD_EXIST);
+    Assert.ok(distributionDir.exists(),
+              MSG_SHOULD_EXIST + getMsgPath(distributionDir.path));
 
     let testFile = getApplyDirFile(DIR_RESOURCES + "distribution/testFile", true);
-    Assert.ok(testFile.exists(), MSG_SHOULD_EXIST);
+    Assert.ok(testFile.exists(),
+              MSG_SHOULD_EXIST + getMsgPath(testFile.path));
 
     testFile = getApplyDirFile(DIR_RESOURCES + "distribution/test/testFile", true);
-    Assert.ok(testFile.exists(), MSG_SHOULD_EXIST);
+    Assert.ok(testFile.exists(),
+              MSG_SHOULD_EXIST + getMsgPath(testFile.path));
 
     distributionDir = getApplyDirFile(DIR_MACOS + "distribution", true);
-    Assert.ok(!distributionDir.exists(), MSG_SHOULD_NOT_EXIST);
+    Assert.ok(!distributionDir.exists(),
+              MSG_SHOULD_NOT_EXIST + getMsgPath(distributionDir.path));
 
-    checkUpdateLogContains("Moving old distribution directory to new location");
+    checkUpdateLogContains(MOVE_OLD_DIST_DIR);
   } else {
     debugDump("testing that files aren't added with an add-if instruction " +
               "when the file's destination directory doesn't exist");
-    Assert.ok(!distributionDir.exists(), MSG_SHOULD_NOT_EXIST);
+    Assert.ok(!distributionDir.exists(),
+              MSG_SHOULD_NOT_EXIST + getMsgPath(distributionDir.path));
   }
-
-  checkAppBundleModTime();
-  checkFilesAfterUpdateSuccess(getApplyDirFile, false, false);
-  checkUpdateLogContents(LOG_PARTIAL_SUCCESS, true);
-  standardInit();
-  checkCallbackAppLog();
 }
diff --git a/toolkit/mozapps/update/tests/unit_base_updater/marSuccessComplete.js b/toolkit/mozapps/update/tests/unit_base_updater/marSuccessComplete.js
index f42a53fd8760..4271e41aa68c 100644
--- a/toolkit/mozapps/update/tests/unit_base_updater/marSuccessComplete.js
+++ b/toolkit/mozapps/update/tests/unit_base_updater/marSuccessComplete.js
@@ -6,11 +6,47 @@
 /* General Complete MAR File Patch Apply Test */
 
 function run_test() {
-  setupTestCommon();
+  if (!setupTestCommon()) {
+    return;
+  }
   gTestFiles = gTestFilesCompleteSuccess;
   gTestDirs = gTestDirsCompleteSuccess;
   preventDistributionFiles();
-  setupUpdaterTest(FILE_COMPLETE_MAR);
+  setupDistributionDir();
+  setupUpdaterTest(FILE_COMPLETE_MAR, true);
+}
+
+/**
+ * Called after the call to setupUpdaterTest finishes.
+ */
+function setupUpdaterTestFinished() {
+  runUpdate(STATE_SUCCEEDED, false, 0, true);
+}
+
+/**
+ * Called after the call to runUpdate finishes.
+ */
+function runUpdateFinished() {
+  checkPostUpdateAppLog();
+}
+
+/**
+ * Called after the call to checkPostUpdateAppLog finishes.
+ */
+function checkPostUpdateAppLogFinished() {
+  checkAppBundleModTime();
+  standardInit();
+  checkPostUpdateRunningFile(true);
+  checkFilesAfterUpdateSuccess(getApplyDirFile);
+  checkUpdateLogContents(LOG_COMPLETE_SUCCESS, false, false, true);
+  checkDistributionDir();
+  checkCallbackLog();
+}
+
+/**
+ * Setup the state of the distribution directory for the test.
+ */
+function setupDistributionDir() {
   if (IS_MACOSX) {
     // Create files in the old distribution directory location to verify that
     // the directory and its contents are moved to the new location on update.
@@ -19,54 +55,34 @@ function run_test() {
     testFile = getApplyDirFile(DIR_MACOS + "distribution/test/testFile", true);
     writeFile(testFile, "test\n");
   }
-
-  createUpdaterINI();
-  setAppBundleModTime();
-
-  runUpdate(0, STATE_SUCCEEDED, checkUpdateFinished);
 }
 
 /**
- * Checks if the post update binary was properly launched for the platforms that
- * support launching post update process.
+ * Checks the state of the distribution directory.
  */
-function checkUpdateFinished() {
-  if (IS_WIN || IS_MACOSX) {
-    gCheckFunc = finishCheckUpdateFinished;
-    checkPostUpdateAppLog();
-  } else {
-    finishCheckUpdateFinished();
-  }
-}
-
-/**
- * Checks if the update has finished and if it has finished performs checks for
- * the test.
- */
-function finishCheckUpdateFinished() {
+function checkDistributionDir() {
   let distributionDir = getApplyDirFile(DIR_RESOURCES + "distribution", true);
   if (IS_MACOSX) {
-    Assert.ok(distributionDir.exists(), MSG_SHOULD_EXIST);
+    Assert.ok(distributionDir.exists(),
+              MSG_SHOULD_EXIST + getMsgPath(distributionDir.path));
 
     let testFile = getApplyDirFile(DIR_RESOURCES + "distribution/testFile", true);
-    Assert.ok(testFile.exists(), MSG_SHOULD_EXIST);
+    Assert.ok(testFile.exists(),
+              MSG_SHOULD_EXIST + getMsgPath(testFile.path));
 
     testFile = getApplyDirFile(DIR_RESOURCES + "distribution/test/testFile", true);
-    Assert.ok(testFile.exists(), MSG_SHOULD_EXIST);
+    Assert.ok(testFile.exists(),
+              MSG_SHOULD_EXIST + getMsgPath(testFile.path));
 
     distributionDir = getApplyDirFile(DIR_MACOS + "distribution", true);
-    Assert.ok(!distributionDir.exists(), MSG_SHOULD_NOT_EXIST);
+    Assert.ok(!distributionDir.exists(),
+              MSG_SHOULD_NOT_EXIST + getMsgPath(distributionDir.path));
 
-    checkUpdateLogContains("Moving old distribution directory to new location");
+    checkUpdateLogContains(MOVE_OLD_DIST_DIR);
   } else {
     debugDump("testing that files aren't added with an add-if instruction " +
               "when the file's destination directory doesn't exist");
-    Assert.ok(!distributionDir.exists(), MSG_SHOULD_NOT_EXIST);
+    Assert.ok(!distributionDir.exists(),
+              MSG_SHOULD_NOT_EXIST + getMsgPath(distributionDir.path));
   }
-
-  checkAppBundleModTime();
-  checkFilesAfterUpdateSuccess(getApplyDirFile, false, false);
-  checkUpdateLogContents(LOG_COMPLETE_SUCCESS, true);
-  standardInit();
-  checkCallbackAppLog();
 }
diff --git a/toolkit/mozapps/update/tests/unit_base_updater/marSuccessPartial.js b/toolkit/mozapps/update/tests/unit_base_updater/marSuccessPartial.js
index c71a40a46a70..c96c1b6b6299 100644
--- a/toolkit/mozapps/update/tests/unit_base_updater/marSuccessPartial.js
+++ b/toolkit/mozapps/update/tests/unit_base_updater/marSuccessPartial.js
@@ -6,7 +6,9 @@
 /* General Partial MAR File Patch Apply Test */
 
 function run_test() {
-  setupTestCommon();
+  if (!setupTestCommon()) {
+    return;
+  }
   gTestFiles = gTestFilesPartialSuccess;
   gTestFiles[gTestFiles.length - 1].originalContents = null;
   gTestFiles[gTestFiles.length - 1].compareContents = "FromPartial\n";
@@ -15,7 +17,41 @@ function run_test() {
   gTestFiles[gTestFiles.length - 2].compareContents = "FromPartial\n";
   gTestFiles[gTestFiles.length - 2].comparePerms = 0o644;
   gTestDirs = gTestDirsPartialSuccess;
-  setupUpdaterTest(FILE_PARTIAL_MAR);
+  setupDistributionDir();
+  setupUpdaterTest(FILE_PARTIAL_MAR, false);
+}
+
+/**
+ * Called after the call to setupUpdaterTest finishes.
+ */
+function setupUpdaterTestFinished() {
+  runUpdate(STATE_SUCCEEDED, false, 0, true);
+}
+
+/**
+ * Called after the call to runUpdate finishes.
+ */
+function runUpdateFinished() {
+  checkPostUpdateAppLog();
+}
+
+/**
+ * Called after the call to checkPostUpdateAppLog finishes.
+ */
+function checkPostUpdateAppLogFinished() {
+  checkAppBundleModTime();
+  standardInit();
+  checkPostUpdateRunningFile(true);
+  checkFilesAfterUpdateSuccess(getApplyDirFile);
+  checkUpdateLogContents(LOG_PARTIAL_SUCCESS);
+  checkDistributionDir();
+  checkCallbackLog();
+}
+
+/**
+ * Setup the state of the distribution directory for the test.
+ */
+function setupDistributionDir() {
   if (IS_MACOSX) {
     // Create files in the old distribution directory location to verify that
     // the directory and its contents are removed when there is a distribution
@@ -25,40 +61,16 @@ function run_test() {
     testFile = getApplyDirFile(DIR_MACOS + "distribution/test/testFile", true);
     writeFile(testFile, "test\n");
   }
-
-  createUpdaterINI(true);
-  setAppBundleModTime();
-
-  runUpdate(0, STATE_SUCCEEDED, checkUpdateFinished);
 }
 
 /**
- * Checks if the post update binary was properly launched for the platforms that
- * support launching post update process.
+ * Checks the state of the distribution directory.
  */
-function checkUpdateFinished() {
-  if (IS_WIN || IS_MACOSX) {
-    gCheckFunc = finishCheckUpdateFinished;
-    checkPostUpdateAppLog();
-  } else {
-    finishCheckUpdateFinished();
-  }
-}
-
-/**
- * Checks if the update has finished and if it has finished performs checks for
- * the test.
- */
-function finishCheckUpdateFinished() {
+function checkDistributionDir() {
   if (IS_MACOSX) {
     let distributionDir = getApplyDirFile(DIR_MACOS + "distribution", true);
-    Assert.ok(!distributionDir.exists(), MSG_SHOULD_NOT_EXIST);
-    checkUpdateLogContains("removing old distribution directory");
+    Assert.ok(!distributionDir.exists(),
+              MSG_SHOULD_NOT_EXIST + getMsgPath(distributionDir.path));
+    checkUpdateLogContains(REMOVE_OLD_DIST_DIR);
   }
-
-  checkAppBundleModTime();
-  checkFilesAfterUpdateSuccess(getApplyDirFile, false, false);
-  checkUpdateLogContents(LOG_PARTIAL_SUCCESS);
-  standardInit();
-  checkCallbackAppLog();
 }
diff --git a/toolkit/mozapps/update/tests/unit_base_updater/marVersionDowngrade.js b/toolkit/mozapps/update/tests/unit_base_updater/marVersionDowngrade.js
index d1f0bf0e98df..5ceac662edbb 100644
--- a/toolkit/mozapps/update/tests/unit_base_updater/marVersionDowngrade.js
+++ b/toolkit/mozapps/update/tests/unit_base_updater/marVersionDowngrade.js
@@ -10,30 +10,32 @@ function run_test() {
     return;
   }
 
-  setupTestCommon();
-  // We don't actually care if the MAR has any data, we only care about the
-  // application return code and update.status result.
-  gTestFiles = gTestFilesCommon;
-  gTestDirs = [];
-  setupUpdaterTest(FILE_OLD_VERSION_MAR);
-
-  createUpdaterINI(true);
-
-  // Apply the MAR
-  // Note that if execv is used, the updater process will turn into the
-  // callback process, so its return code will be that of the callback
-  // app.
-  runUpdate((USE_EXECV ? 0 : 1), STATE_FAILED_VERSION_DOWNGRADE_ERROR,
-            checkUpdateApplied);
+  if (!setupTestCommon()) {
+    return;
+  }
+  gTestFiles = gTestFilesCompleteSuccess;
+  gTestDirs = gTestDirsCompleteSuccess;
+  setTestFilesAndDirsForFailure();
+  setupUpdaterTest(FILE_OLD_VERSION_MAR, false);
 }
 
 /**
- * Checks if the update has finished and if it has finished performs checks for
- * the test.
+ * Called after the call to setupUpdaterTest finishes.
  */
-function checkUpdateApplied() {
-  checkPostUpdateRunningFile(false);
-  checkFilesAfterUpdateSuccess(getApplyDirFile, false, false);
-  standardInit();
-  doTestFinish();
+function setupUpdaterTestFinished() {
+  // If execv is used the updater process will turn into the callback process
+  // and the updater's return code will be that of the callback process.
+  runUpdateUsingUpdater(STATE_FAILED_VERSION_DOWNGRADE_ERROR, false,
+                        (USE_EXECV ? 0 : 1));
+}
+
+/**
+ * Called after the call to runUpdateUsingUpdater finishes.
+ */
+function runUpdateFinished() {
+  standardInit();
+  checkPostUpdateRunningFile(false);
+  checkFilesAfterUpdateFailure(getApplyDirFile);
+  checkUpdateLogContains(STATE_FAILED_VERSION_DOWNGRADE_ERROR);
+  waitForFilesInUse();
 }
diff --git a/toolkit/mozapps/update/tests/unit_base_updater/marWrongChannel.js b/toolkit/mozapps/update/tests/unit_base_updater/marWrongChannel.js
index d0d4b4eedac2..fad09d4ba8fd 100644
--- a/toolkit/mozapps/update/tests/unit_base_updater/marWrongChannel.js
+++ b/toolkit/mozapps/update/tests/unit_base_updater/marWrongChannel.js
@@ -10,30 +10,32 @@ function run_test() {
     return;
   }
 
-  setupTestCommon();
-  // We don't actually care if the MAR has any data, we only care about the
-  // application return code and update.status result.
-  gTestFiles = gTestFilesCommon;
-  gTestDirs = [];
-  setupUpdaterTest(FILE_WRONG_CHANNEL_MAR);
-
-  createUpdaterINI();
-
-  // Apply the MAR
-  // Note that if execv is used, the updater process will turn into the
-  // callback process, so its return code will be that of the callback
-  // app.
-  runUpdate((USE_EXECV ? 0 : 1), STATE_FAILED_CHANNEL_MISMATCH_ERROR,
-            checkUpdateApplied);
+  if (!setupTestCommon()) {
+    return;
+  }
+  gTestFiles = gTestFilesCompleteSuccess;
+  gTestDirs = gTestDirsCompleteSuccess;
+  setTestFilesAndDirsForFailure();
+  setupUpdaterTest(FILE_WRONG_CHANNEL_MAR, false);
 }
 
 /**
- * Checks if the update has finished and if it has finished performs checks for
- * the test.
+ * Called after the call to setupUpdaterTest finishes.
  */
-function checkUpdateApplied() {
-  checkPostUpdateRunningFile(false);
-  checkFilesAfterUpdateSuccess(getApplyDirFile, false, false);
-  standardInit();
-  doTestFinish();
+function setupUpdaterTestFinished() {
+  // If execv is used the updater process will turn into the callback process
+  // and the updater's return code will be that of the callback process.
+  runUpdateUsingUpdater(STATE_FAILED_CHANNEL_MISMATCH_ERROR, false,
+                        (USE_EXECV ? 0 : 1));
+}
+
+/**
+ * Called after the call to runUpdateUsingUpdater finishes.
+ */
+function runUpdateFinished() {
+  standardInit();
+  checkPostUpdateRunningFile(false);
+  checkFilesAfterUpdateFailure(getApplyDirFile);
+  checkUpdateLogContains(STATE_FAILED_CHANNEL_MISMATCH_ERROR);
+  waitForFilesInUse();
 }
diff --git a/toolkit/mozapps/update/tests/unit_base_updater/xpcshell.ini b/toolkit/mozapps/update/tests/unit_base_updater/xpcshell.ini
index 8e05cb107203..81ef7053dd30 100644
--- a/toolkit/mozapps/update/tests/unit_base_updater/xpcshell.ini
+++ b/toolkit/mozapps/update/tests/unit_base_updater/xpcshell.ini
@@ -15,7 +15,11 @@ tail =
 [marSuccessPartial.js]
 [marFailurePartial.js]
 [marStageSuccessComplete.js]
+skip-if = toolkit == 'gonk' && debug == true
+reason = bug 1179091 
 [marStageSuccessPartial.js]
+skip-if = toolkit == 'gonk' && debug == true
+reason = bug 1179091 
 [marVersionDowngrade.js]
 skip-if = toolkit == 'gonk'
 reason = mar signing
@@ -45,7 +49,6 @@ skip-if = os != 'win'
 skip-if = os != 'win'
 [marFileLockedStageFailureComplete_win.js]
 skip-if = os != 'win'
-run-sequentially = Bug 1156446
 [marFileLockedStageFailurePartial_win.js]
 skip-if = os != 'win'
 [marFileInUseSuccessComplete_win.js]
diff --git a/toolkit/mozapps/update/tests/unit_service_updater/bootstrapSvc.js b/toolkit/mozapps/update/tests/unit_service_updater/bootstrapSvc.js
index ffa207ebbe65..30b2071a86fd 100644
--- a/toolkit/mozapps/update/tests/unit_service_updater/bootstrapSvc.js
+++ b/toolkit/mozapps/update/tests/unit_service_updater/bootstrapSvc.js
@@ -5,29 +5,31 @@
 /* Bootstrap the tests using the service by installing our own version of the service */
 
 function run_test() {
-  if (!shouldRunServiceTest(true)) {
+  if (!setupTestCommon()) {
     return;
   }
-
-  setupTestCommon();
   // We don't actually care if the MAR has any data, we only care about the
   // application return code and update.status result.
   gTestFiles = gTestFilesCommon;
   gTestDirs = [];
-  setupUpdaterTest(FILE_COMPLETE_MAR);
-
-  setupAppFilesAsync();
+  setupUpdaterTest(FILE_COMPLETE_MAR, null);
 }
 
-function setupAppFilesFinished() {
-  runUpdateUsingService(STATE_PENDING_SVC, STATE_SUCCEEDED, false);
+/**
+ * Called after the call to setupUpdaterTest finishes.
+ */
+function setupUpdaterTestFinished() {
+  runUpdateUsingService(STATE_SUCCEEDED, false, true);
 }
 
-function checkUpdateFinished() {
+/**
+ * Called after the call to runUpdateUsingService finishes.
+ */
+function runUpdateFinished() {
   checkFilesAfterUpdateSuccess(getApplyDirFile, false, false);
 
   // We need to check the service log even though this is a bootstrap
   // because the app bin could be in use by this test by the time the next
   // test runs.
-  checkCallbackServiceLog();
+  checkCallbackLog();
 }
diff --git a/toolkit/mozapps/update/tests/unit_service_updater/checkUpdaterSigSvc.js b/toolkit/mozapps/update/tests/unit_service_updater/checkUpdaterSigSvc.js
index 99f0a5da9ec5..bf765ee78572 100644
--- a/toolkit/mozapps/update/tests/unit_service_updater/checkUpdaterSigSvc.js
+++ b/toolkit/mozapps/update/tests/unit_service_updater/checkUpdaterSigSvc.js
@@ -24,9 +24,7 @@ function run_test() {
             updaterBin.path + " signature.");
 
   // Bypass the manifest and run as invoker
-  let env = Cc["@mozilla.org/process/environment;1"].
-            getService(Ci.nsIEnvironment);
-  env.set("__COMPAT_LAYER", "RunAsInvoker");
+  gEnv.set("__COMPAT_LAYER", "RunAsInvoker");
 
   let dummyInstallPath = "---";
   let maintenanceServiceBinArgs = ["check-cert", dummyInstallPath,
diff --git a/toolkit/mozapps/update/tests/unit_service_updater/head_update.js b/toolkit/mozapps/update/tests/unit_service_updater/head_update.js
index 2db27288e643..a78cc957392f 100644
--- a/toolkit/mozapps/update/tests/unit_service_updater/head_update.js
+++ b/toolkit/mozapps/update/tests/unit_service_updater/head_update.js
@@ -2,4 +2,6 @@
  * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
+const IS_SERVICE_TEST = true;
+
 load("../data/xpcshellUtilsAUS.js");
diff --git a/toolkit/mozapps/update/tests/unit_service_updater/marAppApplyDirLockedStageFailureSvc_win.js b/toolkit/mozapps/update/tests/unit_service_updater/marAppApplyDirLockedStageFailureSvc_win.js
index 96687649f877..92e437f04edd 100644
--- a/toolkit/mozapps/update/tests/unit_service_updater/marAppApplyDirLockedStageFailureSvc_win.js
+++ b/toolkit/mozapps/update/tests/unit_service_updater/marAppApplyDirLockedStageFailureSvc_win.js
@@ -7,83 +7,36 @@
  * apply it.
  */
 
-const START_STATE = STATE_PENDING_SVC;
-const END_STATE = STATE_PENDING;
+const STATE_AFTER_STAGE = STATE_PENDING;
 
 function run_test() {
-  if (MOZ_APP_NAME == "xulrunner") {
-    logTestInfo("Unable to run this test on xulrunner");
+  if (!setupTestCommon()) {
     return;
   }
 
-  if (!shouldRunServiceTest()) {
-    return;
-  }
-
-  setupTestCommon();
   gTestFiles = gTestFilesCompleteSuccess;
   gTestDirs = gTestDirsCompleteSuccess;
   setTestFilesAndDirsForFailure();
-  setupUpdaterTest(FILE_COMPLETE_MAR);
-
-  createUpdaterINI(false);
-
-  if (IS_WIN) {
-    Services.prefs.setBoolPref(PREF_APP_UPDATE_SERVICE_ENABLED, true);
-  }
-
-  let channel = Services.prefs.getCharPref(PREF_APP_UPDATE_CHANNEL);
-  let patches = getLocalPatchString(null, null, null, null, null, "true",
-                                    START_STATE);
-  let updates = getLocalUpdateString(patches, null, null, null, null, null,
-                                     null, null, null, null, null, null,
-                                     "true", channel);
-  writeUpdatesToXMLFile(getLocalUpdatesXMLString(updates), true);
-  writeVersionFile(getAppVersion());
-  writeStatusFile(START_STATE);
-
-  reloadUpdateManagerData();
-  Assert.ok(!!gUpdateManager.activeUpdate,
-            "the active update should be defined");
-
-  lockDirectory(getAppBaseDir());
-
-  setupAppFilesAsync();
-}
-
-function setupAppFilesFinished() {
-  stageUpdate();
-}
-
-function end_test() {
-  resetEnvironment();
+  createUpdateInProgressLockFile(getAppBaseDir());
+  setupUpdaterTest(FILE_COMPLETE_MAR, false);
 }
 
 /**
- * Checks if staging the update has failed.
+ * Called after the call to setupUpdaterTest finishes.
  */
-function checkUpdateApplied() {
-  // Don't proceed until the update has failed, and reset to pending.
-  if (gUpdateManager.activeUpdate.state != END_STATE) {
-    if (++gTimeoutRuns > MAX_TIMEOUT_RUNS) {
-      do_throw("Exceeded MAX_TIMEOUT_RUNS while waiting for the " +
-               "active update status state to equal: " +
-               END_STATE +
-               ", current state: " + gUpdateManager.activeUpdate.state);
-    }
-    do_timeout(TEST_CHECK_TIMEOUT, checkUpdateApplied);
-    return;
-  }
-
-  do_timeout(TEST_CHECK_TIMEOUT, finishTest);
+function setupUpdaterTestFinished() {
+  stageUpdate();
 }
 
-function finishTest() {
-  checkPostUpdateRunningFile(false);
-  Assert.equal(readStatusState(), END_STATE,
-               "the status state" + MSG_SHOULD_EQUAL);
-  checkFilesAfterUpdateFailure(getApplyDirFile, false, false);
-  unlockDirectory(getAppBaseDir());
+/**
+ * Called after the call to stageUpdate finishes.
+ */
+function stageUpdateFinished() {
+  removeUpdateInProgressLockFile(getAppBaseDir());
   standardInit();
+  checkPostUpdateRunningFile(false);
+  checkFilesAfterUpdateFailure(getApplyDirFile);
+  checkUpdateLogContains(PERFORMING_STAGED_UPDATE);
+  checkUpdateLogContains(ERR_UPDATE_IN_PROGRESS);
   waitForFilesInUse();
 }
diff --git a/toolkit/mozapps/update/tests/unit_service_updater/marAppApplyUpdateAppBinInUseStageSuccessSvc_win.js b/toolkit/mozapps/update/tests/unit_service_updater/marAppApplyUpdateAppBinInUseStageSuccessSvc_win.js
index 873bb9aa0e0d..2a93272f0568 100644
--- a/toolkit/mozapps/update/tests/unit_service_updater/marAppApplyUpdateAppBinInUseStageSuccessSvc_win.js
+++ b/toolkit/mozapps/update/tests/unit_service_updater/marAppApplyUpdateAppBinInUseStageSuccessSvc_win.js
@@ -7,248 +7,69 @@
  * apply it.
  */
 
-const START_STATE = STATE_PENDING_SVC;
-const END_STATE = STATE_APPLIED_SVC;
+const STATE_AFTER_STAGE = IS_SERVICE_TEST ? STATE_APPLIED_SVC : STATE_APPLIED;
 
 function run_test() {
-  if (MOZ_APP_NAME == "xulrunner") {
-    logTestInfo("Unable to run this test on xulrunner");
+  if (!setupTestCommon()) {
     return;
   }
 
-  if (!shouldRunServiceTest()) {
-    return;
-  }
-
-  setupTestCommon();
   gTestFiles = gTestFilesCompleteSuccess;
   gTestDirs = gTestDirsCompleteSuccess;
-  setupUpdaterTest(FILE_COMPLETE_MAR);
-
-  createUpdaterINI(true);
-
-  if (IS_WIN) {
-    Services.prefs.setBoolPref(PREF_APP_UPDATE_SERVICE_ENABLED, true);
-  }
-
-  let channel = Services.prefs.getCharPref(PREF_APP_UPDATE_CHANNEL);
-  let patches = getLocalPatchString(null, null, null, null, null, "true",
-                                    START_STATE);
-  let updates = getLocalUpdateString(patches, null, null, null, null, null,
-                                     null, null, null, null, null, null,
-                                     "true", channel);
-  writeUpdatesToXMLFile(getLocalUpdatesXMLString(updates), true);
-  writeVersionFile(getAppVersion());
-  writeStatusFile(START_STATE);
-
-  reloadUpdateManagerData();
-  Assert.ok(!!gUpdateManager.activeUpdate,
-            "the active update should be defined");
-
-  setupAppFilesAsync();
+  setupUpdaterTest(FILE_COMPLETE_MAR, undefined);
 }
 
-function setupAppFilesFinished() {
-  setAppBundleModTime();
+/**
+ * Called after the call to setupUpdaterTest finishes.
+ */
+function setupUpdaterTestFinished() {
   stageUpdate();
 }
 
-function customLaunchAppToApplyUpdate() {
-  debugDump("start - locking installation directory");
-  const LPCWSTR = ctypes.char16_t.ptr;
-  const DWORD = ctypes.uint32_t;
-  const LPVOID = ctypes.voidptr_t;
-  const GENERIC_READ = 0x80000000;
-  const FILE_SHARE_READ = 1;
-  const FILE_SHARE_WRITE = 2;
-  const OPEN_EXISTING = 3;
-  const FILE_FLAG_BACKUP_SEMANTICS = 0x02000000;
-  const INVALID_HANDLE_VALUE = LPVOID(0xffffffff);
-  let kernel32 = ctypes.open("kernel32");
-  let CreateFile = kernel32.declare("CreateFileW", ctypes.default_abi,
-                                    LPVOID, LPCWSTR, DWORD, DWORD,
-                                    LPVOID, DWORD, DWORD, LPVOID);
-  gHandle = CreateFile(getAppBaseDir().path, GENERIC_READ,
-                       FILE_SHARE_READ | FILE_SHARE_WRITE, LPVOID(0),
-                       OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, LPVOID(0));
-  Assert.notEqual(gHandle.toString(), INVALID_HANDLE_VALUE.toString(),
-                  "the handle should not equal INVALID_HANDLE_VALUE");
-  kernel32.close();
-  debugDump("finish - locking installation directory");
-}
-
 /**
- * Checks if the update has finished being staged.
+ * Called after the call to stageUpdate finishes.
  */
-function checkUpdateApplied() {
-  gTimeoutRuns++;
-  // Don't proceed until the active update's state is the expected value.
-  if (gUpdateManager.activeUpdate.state != END_STATE) {
-    if (gTimeoutRuns > MAX_TIMEOUT_RUNS) {
-      do_throw("Exceeded MAX_TIMEOUT_RUNS while waiting for the " +
-               "active update status state to equal: " +
-               END_STATE +
-               ", current state: " + gUpdateManager.activeUpdate.state);
-    }
-    do_timeout(TEST_CHECK_TIMEOUT, checkUpdateApplied);
-    return;
-  }
-
-  // Don't proceed until the update's status state is the expected value.
-  let state = readStatusState();
-  if (state != END_STATE) {
-    if (gTimeoutRuns > MAX_TIMEOUT_RUNS) {
-      do_throw("Exceeded MAX_TIMEOUT_RUNS while waiting for the update" +
-               "status file state to equal: " +
-               END_STATE +
-               ", current status state: " + state);
-    }
-    do_timeout(TEST_CHECK_TIMEOUT, checkUpdateApplied);
-    return;
-  }
-
-  // Don't proceed until the last update log has been created.
-  let log;
-  if (IS_WIN || IS_MACOSX) {
-    log = getUpdatesDir();
-  } else {
-    log = getStageDirFile(null, true);
-    log.append(DIR_UPDATES);
-  }
-  log.append(FILE_LAST_LOG);
-  if (!log.exists()) {
-    if (gTimeoutRuns > MAX_TIMEOUT_RUNS) {
-      do_throw("Exceeded MAX_TIMEOUT_RUNS while waiting for the update log " +
-               "to be created. Path: " + log.path);
-    }
-    do_timeout(TEST_CHECK_TIMEOUT, checkUpdateApplied);
-    return;
-  }
-
+function stageUpdateFinished() {
   checkPostUpdateRunningFile(false);
   checkFilesAfterUpdateSuccess(getStageDirFile, true, false);
-
-  log = getUpdatesPatchDir();
-  log.append(FILE_UPDATE_LOG);
-  Assert.ok(!log.exists(), MSG_SHOULD_NOT_EXIST);
-
-  log = getUpdatesDir();
-  log.append(FILE_LAST_LOG);
-  if (IS_WIN || IS_MACOSX) {
-    Assert.ok(log.exists(), MSG_SHOULD_EXIST);
-  } else {
-    Assert.ok(!log.exists(), MSG_SHOULD_NOT_EXIST);
-  }
-
-  log = getUpdatesDir();
-  log.append(FILE_BACKUP_LOG);
-  Assert.ok(!log.exists(), MSG_SHOULD_NOT_EXIST);
-
-  let updatesDir = getStageDirFile(DIR_UPDATES + "/" + DIR_PATCH, true);
-  Assert.ok(!updatesDir.exists(), MSG_SHOULD_NOT_EXIST);
-
-  log = getStageDirFile(DIR_UPDATES + "/" + FILE_LAST_LOG, true);
-  if (IS_WIN || IS_MACOSX) {
-    Assert.ok(!log.exists(), MSG_SHOULD_NOT_EXIST);
-  } else {
-    Assert.ok(log.exists(), MSG_SHOULD_EXIST);
-  }
-
-  log = getStageDirFile(DIR_UPDATES + "/" + FILE_BACKUP_LOG, true);
-  Assert.ok(!log.exists(), MSG_SHOULD_NOT_EXIST);
-
-  // Switch the application to the staged application that was updated by
-  // launching the application.
-  do_timeout(TEST_CHECK_TIMEOUT, launchAppToApplyUpdate);
+  checkUpdateLogContents(LOG_COMPLETE_SUCCESS_STAGE, true);
+  lockDirectory(getAppBaseDir().path);
+  // Switch the application to the staged application that was updated.
+  runUpdateUsingApp(STATE_SUCCEEDED);
 }
 
 /**
- * Checks if the post update binary was properly launched for the platforms that
- * support launching post update process.
+ * Called after the call to runUpdateUsingApp finishes.
  */
-function checkUpdateFinished() {
-  if (IS_WIN || IS_MACOSX) {
-    gCheckFunc = finishCheckUpdateFinished;
-    checkPostUpdateAppLog();
-  } else {
-    finishCheckUpdateFinished();
-  }
+function runUpdateFinished() {
+  checkPostUpdateAppLog();
 }
 
 /**
- * Checks if the update has finished and if it has finished performs checks for
- * the test.
+ * Called after the call to checkPostUpdateAppLog finishes.
  */
-function finishCheckUpdateFinished() {
-  gTimeoutRuns++;
-  // Don't proceed until the update's status state is the expected value.
-  let state = readStatusState();
-  if (state != STATE_SUCCEEDED) {
-    if (gTimeoutRuns > MAX_TIMEOUT_RUNS) {
-      do_throw("Exceeded MAX_TIMEOUT_RUNS while waiting for the " +
-               "update status file state to equal: " +
-               STATE_SUCCEEDED +
-               ", current status state: " + state);
-    }
-    do_timeout(TEST_CHECK_TIMEOUT, checkUpdateFinished);
-    return;
-  }
-
-  // Don't proceed until the application was switched out with the staged update
-  // successfully.
-  let updatedDir = getStageDirFile(null, true);
-  if (updatedDir.exists()) {
-    if (gTimeoutRuns > MAX_TIMEOUT_RUNS) {
-      do_throw("Exceeded MAX_TIMEOUT_RUNS while waiting for the updated " +
-               "directory to not exist. Path: " + updatedDir.path);
-    }
-    do_timeout(TEST_CHECK_TIMEOUT, checkUpdateFinished);
-    return;
-  }
-
-  if (IS_WIN) {
-    // Don't proceed until the updater binary is no longer in use.
-    let updater = getUpdatesPatchDir();
-    updater.append(FILE_UPDATER_BIN);
-    if (updater.exists()) {
-      if (gTimeoutRuns > MAX_TIMEOUT_RUNS) {
-        do_throw("Exceeded MAX_TIMEOUT_RUNS while waiting for the " +
-                 "updater binary to no longer be in use");
-      }
-      try {
-        updater.remove(false);
-      } catch (e) {
-        do_timeout(TEST_CHECK_TIMEOUT, checkUpdateFinished);
-        return;
-      }
-    }
-  }
-
-  checkPostUpdateRunningFile(true);
+function checkPostUpdateAppLogFinished() {
   checkAppBundleModTime();
-  checkFilesAfterUpdateSuccess(getApplyDirFile, false, false);
+  standardInit();
+  checkPostUpdateRunningFile(true);
+  checkFilesAfterUpdateSuccess(getApplyDirFile);
   checkUpdateLogContents(LOG_COMPLETE_SUCCESS);
 
-  standardInit();
-
-  let update = gUpdateManager.getUpdateAt(0);
-  Assert.equal(update.state, STATE_SUCCEEDED,
-               "the update state" + MSG_SHOULD_EQUAL);
-
   let updatesDir = getUpdatesPatchDir();
-  Assert.ok(updatesDir.exists(), MSG_SHOULD_EXIST);
+  Assert.ok(updatesDir.exists(),
+            MSG_SHOULD_EXIST + getMsgPath(updatesDir.path));
 
-  let log = getUpdatesPatchDir();
-  log.append(FILE_UPDATE_LOG);
-  Assert.ok(!log.exists(), MSG_SHOULD_NOT_EXIST);
+  let log = getUpdateLog(FILE_UPDATE_LOG);
+  Assert.ok(!log.exists(),
+            MSG_SHOULD_NOT_EXIST + getMsgPath(log.path));
 
-  log = getUpdatesDir();
-  log.append(FILE_LAST_LOG);
-  Assert.ok(log.exists(), MSG_SHOULD_EXIST);
+  log = getUpdateLog(FILE_LAST_UPDATE_LOG);
+  Assert.ok(log.exists(),
+            MSG_SHOULD_EXIST + getMsgPath(log.path));
 
-  log = getUpdatesDir();
-  log.append(FILE_BACKUP_LOG);
-  Assert.ok(log.exists(), MSG_SHOULD_EXIST);
+  log = getUpdateLog(FILE_BACKUP_UPDATE_LOG);
+  Assert.ok(log.exists(),
+            MSG_SHOULD_EXIST + getMsgPath(log.path));
 
   waitForFilesInUse();
 }
diff --git a/toolkit/mozapps/update/tests/unit_service_updater/marAppApplyUpdateStageSuccessSvc.js b/toolkit/mozapps/update/tests/unit_service_updater/marAppApplyUpdateStageSuccessSvc.js
index cec56ebfb99b..cc7a099386eb 100644
--- a/toolkit/mozapps/update/tests/unit_service_updater/marAppApplyUpdateStageSuccessSvc.js
+++ b/toolkit/mozapps/update/tests/unit_service_updater/marAppApplyUpdateStageSuccessSvc.js
@@ -7,230 +7,68 @@
  * apply it.
  */
 
-const START_STATE = STATE_PENDING_SVC;
-const END_STATE = STATE_APPLIED_SVC;
+const STATE_AFTER_STAGE = IS_SERVICE_TEST ? STATE_APPLIED_SVC : STATE_APPLIED;
 
 function run_test() {
-  if (MOZ_APP_NAME == "xulrunner") {
-    logTestInfo("Unable to run this test on xulrunner");
+  if (!setupTestCommon()) {
     return;
   }
 
-  if (!shouldRunServiceTest()) {
-    return;
-  }
-
-  setupTestCommon();
   gTestFiles = gTestFilesCompleteSuccess;
   gTestDirs = gTestDirsCompleteSuccess;
-  setupUpdaterTest(FILE_COMPLETE_MAR);
-
-  createUpdaterINI(false);
-
-  if (IS_WIN) {
-    Services.prefs.setBoolPref(PREF_APP_UPDATE_SERVICE_ENABLED, true);
-  }
-
-  let channel = Services.prefs.getCharPref(PREF_APP_UPDATE_CHANNEL);
-  let patches = getLocalPatchString(null, null, null, null, null, "true",
-                                    START_STATE);
-  let updates = getLocalUpdateString(patches, null, null, null, null, null,
-                                     null, null, null, null, null, null,
-                                     "true", channel);
-  writeUpdatesToXMLFile(getLocalUpdatesXMLString(updates), true);
-  writeVersionFile(getAppVersion());
-  writeStatusFile(START_STATE);
-
-  reloadUpdateManagerData();
-  Assert.ok(!!gUpdateManager.activeUpdate,
-            "the active update should be defined");
-
-  setupAppFilesAsync();
+  setupUpdaterTest(FILE_COMPLETE_MAR, true);
 }
 
-function setupAppFilesFinished() {
-  setAppBundleModTime();
+/**
+ * Called after the call to setupUpdaterTest finishes.
+ */
+function setupUpdaterTestFinished() {
   stageUpdate();
 }
 
 /**
- * Checks if the update has finished being staged.
+ * Called after the call to stageUpdate finishes.
  */
-function checkUpdateApplied() {
-  gTimeoutRuns++;
-  // Don't proceed until the active update's state is the expected value.
-  if (gUpdateManager.activeUpdate.state != END_STATE) {
-    if (gTimeoutRuns > MAX_TIMEOUT_RUNS) {
-      do_throw("Exceeded MAX_TIMEOUT_RUNS while waiting for the " +
-               "active update status state to equal: " +
-               END_STATE +
-               ", current state: " + gUpdateManager.activeUpdate.state);
-    }
-    do_timeout(TEST_CHECK_TIMEOUT, checkUpdateApplied);
-    return;
-  }
-
-  // Don't proceed until the update's status state is the expected value.
-  let state = readStatusState();
-  if (state != END_STATE) {
-    if (gTimeoutRuns > MAX_TIMEOUT_RUNS) {
-      do_throw("Exceeded MAX_TIMEOUT_RUNS while waiting for the update " +
-               "status state to equal: " +
-               END_STATE +
-               ", current status state: " + state);
-    }
-    do_timeout(TEST_CHECK_TIMEOUT, checkUpdateApplied);
-    return;
-  }
-
-  // Don't proceed until the last update log has been created.
-  let log;
-  if (IS_WIN || IS_MACOSX) {
-    log = getUpdatesDir();
-  } else {
-    log = getStageDirFile(null, true);
-    log.append(DIR_UPDATES);
-  }
-  log.append(FILE_LAST_LOG);
-  if (!log.exists()) {
-    if (gTimeoutRuns > MAX_TIMEOUT_RUNS) {
-      do_throw("Exceeded MAX_TIMEOUT_RUNS while waiting for the update log " +
-               "to be created. Path: " + log.path);
-    }
-    do_timeout(TEST_CHECK_TIMEOUT, checkUpdateApplied);
-    return;
-  }
-
+function stageUpdateFinished() {
   checkPostUpdateRunningFile(false);
-  checkFilesAfterUpdateSuccess(getStageDirFile, true, false);
-
-  log = getUpdatesPatchDir();
-  log.append(FILE_UPDATE_LOG);
-  Assert.ok(!log.exists(), MSG_SHOULD_NOT_EXIST);
-
-  log = getUpdatesDir();
-  log.append(FILE_LAST_LOG);
-  if (IS_WIN || IS_MACOSX) {
-    Assert.ok(log.exists(), MSG_SHOULD_EXIST);
-  } else {
-    Assert.ok(!log.exists(), MSG_SHOULD_NOT_EXIST);
-  }
-
-  log = getUpdatesDir();
-  log.append(FILE_BACKUP_LOG);
-  Assert.ok(!log.exists(), MSG_SHOULD_NOT_EXIST);
-
-  let updatesDir = getStageDirFile(DIR_UPDATES + "/" + DIR_PATCH, true);
-  Assert.ok(!updatesDir.exists(), MSG_SHOULD_NOT_EXIST);
-
-  log = getStageDirFile(DIR_UPDATES + "/" + FILE_LAST_LOG, true);
-  if (IS_WIN || IS_MACOSX) {
-    Assert.ok(!log.exists(), MSG_SHOULD_NOT_EXIST);
-  } else {
-    Assert.ok(log.exists(), MSG_SHOULD_EXIST);
-  }
-
-  log = getStageDirFile(DIR_UPDATES + "/" + FILE_BACKUP_LOG, true);
-  Assert.ok(!log.exists(), MSG_SHOULD_NOT_EXIST);
-
-  // Switch the application to the staged application that was updated by
-  // launching the application.
-  do_timeout(TEST_CHECK_TIMEOUT, launchAppToApplyUpdate);
+  checkFilesAfterUpdateSuccess(getStageDirFile, true);
+  checkUpdateLogContents(LOG_COMPLETE_SUCCESS_STAGE, true);
+  // Switch the application to the staged application that was updated.
+  runUpdateUsingApp(STATE_SUCCEEDED);
 }
 
 /**
- * Checks if the post update binary was properly launched for the platforms that
- * support launching post update process.
+ * Called after the call to runUpdateUsingApp finishes.
  */
-function checkUpdateFinished() {
-  if (IS_WIN || IS_MACOSX) {
-    gCheckFunc = finishCheckUpdateApplied;
-    checkPostUpdateAppLog();
-  } else {
-    finishCheckUpdateApplied();
-  }
+function runUpdateFinished() {
+  checkPostUpdateAppLog();
 }
 
 /**
- * Checks if the update has finished and if it has finished performs checks for
- * the test.
+ * Called after the call to checkPostUpdateAppLog finishes.
  */
-function finishCheckUpdateApplied() {
-  gTimeoutRuns++;
-  // Don't proceed until the update's status state is the expected value.
-  let state = readStatusState();
-  if (state != STATE_SUCCEEDED) {
-    if (gTimeoutRuns > MAX_TIMEOUT_RUNS) {
-      do_throw("Exceeded MAX_TIMEOUT_RUNS while waiting for the " +
-               "update status file state to equal: " +
-               STATE_SUCCEEDED +
-               ", current status state: " + state);
-    }
-    do_timeout(TEST_CHECK_TIMEOUT, checkUpdateFinished);
-    return;
-  }
-
-  // Don't proceed until the application was switched out with the staged update
-  // successfully.
-  let updatedDir = getStageDirFile(null, true);
-  if (updatedDir.exists()) {
-    if (gTimeoutRuns > MAX_TIMEOUT_RUNS) {
-      do_throw("Exceeded MAX_TIMEOUT_RUNS while waiting for the updated " +
-               "directory to not exist. Path: " + updatedDir.path);
-    }
-    do_timeout(TEST_CHECK_TIMEOUT, checkUpdateFinished);
-    return;
-  }
-
-  if (IS_WIN) {
-    // Don't proceed until the updater binary is no longer in use.
-    let updater = getUpdatesPatchDir();
-    updater.append(FILE_UPDATER_BIN);
-    if (updater.exists()) {
-      if (gTimeoutRuns > MAX_TIMEOUT_RUNS) {
-        do_throw("Exceeded MAX_TIMEOUT_RUNS while waiting for the " +
-                 "updater binary to no longer be in use");
-      }
-      try {
-        updater.remove(false);
-      } catch (e) {
-        do_timeout(TEST_CHECK_TIMEOUT, checkUpdateFinished);
-        return;
-      }
-    }
-  }
-
-  checkPostUpdateRunningFile(true);
+function checkPostUpdateAppLogFinished() {
   checkAppBundleModTime();
-  checkFilesAfterUpdateSuccess(getApplyDirFile, false, true);
-  gSwitchApp = true;
-  checkUpdateLogContents();
-  gSwitchApp = false;
-
   standardInit();
-
-  let update = gUpdateManager.getUpdateAt(0);
-  Assert.equal(update.state, STATE_SUCCEEDED,
-               "the update state" + MSG_SHOULD_EQUAL);
+  checkPostUpdateRunningFile(true);
+  checkFilesAfterUpdateSuccess(getApplyDirFile, false, true);
+  checkUpdateLogContents(LOG_REPLACE_SUCCESS, false, true);
 
   let updatesDir = getUpdatesPatchDir();
-  Assert.ok(updatesDir.exists(), MSG_SHOULD_EXIST);
+  Assert.ok(updatesDir.exists(),
+            MSG_SHOULD_EXIST + getMsgPath(updatesDir.path));
 
-  let log = getUpdatesPatchDir();
-  log.append(FILE_UPDATE_LOG);
-  Assert.ok(!log.exists(), MSG_SHOULD_NOT_EXIST);
+  let log = getUpdateLog(FILE_UPDATE_LOG);
+  Assert.ok(!log.exists(),
+            MSG_SHOULD_NOT_EXIST + getMsgPath(log.path));
 
-  log = getUpdatesDir();
-  log.append(FILE_LAST_LOG);
-  Assert.ok(log.exists(), MSG_SHOULD_EXIST);
+  log = getUpdateLog(FILE_LAST_UPDATE_LOG);
+  Assert.ok(log.exists(),
+            MSG_SHOULD_EXIST + getMsgPath(log.path));
 
-  log = getUpdatesDir();
-  log.append(FILE_BACKUP_LOG);
-  if (IS_WIN || IS_MACOSX) {
-    Assert.ok(log.exists(), MSG_SHOULD_EXIST);
-  } else {
-    Assert.ok(!log.exists(), MSG_SHOULD_NOT_EXIST);
-  }
+  log = getUpdateLog(FILE_BACKUP_UPDATE_LOG);
+  Assert.ok(log.exists(),
+            MSG_SHOULD_EXIST + getMsgPath(log.path));
 
   waitForFilesInUse();
 }
diff --git a/toolkit/mozapps/update/tests/unit_service_updater/marAppApplyUpdateSuccessSvc.js b/toolkit/mozapps/update/tests/unit_service_updater/marAppApplyUpdateSuccessSvc.js
index 85cff2ddd302..a44264fac843 100644
--- a/toolkit/mozapps/update/tests/unit_service_updater/marAppApplyUpdateSuccessSvc.js
+++ b/toolkit/mozapps/update/tests/unit_service_updater/marAppApplyUpdateSuccessSvc.js
@@ -7,130 +7,55 @@
  * apply it.
  */
 
-const START_STATE = STATE_PENDING_SVC;
-const END_STATE = STATE_SUCCEEDED;
-
 function run_test() {
-  if (MOZ_APP_NAME == "xulrunner") {
-    logTestInfo("Unable to run this test on xulrunner");
+  if (!setupTestCommon()) {
     return;
   }
 
-  if (!shouldRunServiceTest()) {
-    return;
-  }
-
-  setupTestCommon();
   gTestFiles = gTestFilesCompleteSuccess;
   gTestDirs = gTestDirsCompleteSuccess;
-  setupUpdaterTest(FILE_COMPLETE_MAR);
-
-  createUpdaterINI();
-  setAppBundleModTime();
-
-  let channel = Services.prefs.getCharPref(PREF_APP_UPDATE_CHANNEL);
-  let patches = getLocalPatchString(null, null, null, null, null, "true",
-                                    START_STATE);
-  let updates = getLocalUpdateString(patches, null, null, null, null, null,
-                                     null, null, null, null, null, null,
-                                     "true", channel);
-  writeUpdatesToXMLFile(getLocalUpdatesXMLString(updates), true);
-  writeVersionFile(getAppVersion());
-  writeStatusFile(START_STATE);
-
-  setupAppFilesAsync();
-}
-
-function setupAppFilesFinished() {
-  runUpdateUsingService(START_STATE, END_STATE);
+  setupUpdaterTest(FILE_COMPLETE_MAR, undefined);
 }
 
 /**
- * Checks if the post update binary was properly launched for the platforms that
- * support launching post update process.
+ * Called after the call to setupUpdaterTest finishes.
  */
-function checkUpdateFinished() {
-  if (IS_WIN || IS_MACOSX) {
-    gCheckFunc = finishCheckUpdateFinished;
-    checkPostUpdateAppLog();
-  } else {
-    finishCheckUpdateFinished();
-  }
+function setupUpdaterTestFinished() {
+  runUpdateUsingApp(STATE_SUCCEEDED);
 }
 
 /**
- * Checks if the update has finished and if it has finished performs checks for
- * the test.
+ * Called after the call to runUpdateUsingApp finishes.
  */
-function finishCheckUpdateFinished() {
-  gTimeoutRuns++;
-  // Don't proceed until the update's status state is the expected value.
-  let state = readStatusState();
-  if (state != END_STATE) {
-    if (gTimeoutRuns > MAX_TIMEOUT_RUNS) {
-      do_throw("Exceeded MAX_TIMEOUT_RUNS while waiting for the update " +
-               "status state to equal: " + END_STATE +
-               ", current status state: " + state);
-    } else {
-      do_timeout(TEST_CHECK_TIMEOUT, checkUpdateFinished);
-    }
-    return;
-  }
-
-  // Don't proceed until the update log has been created.
-  let log = getUpdatesPatchDir();
-  log.append(FILE_UPDATE_LOG);
-  if (!log.exists()) {
-    if (gTimeoutRuns > MAX_TIMEOUT_RUNS) {
-      do_throw("Exceeded MAX_TIMEOUT_RUNS while waiting for the update log " +
-               "to be created. Path: " + log.path);
-    }
-    do_timeout(TEST_CHECK_TIMEOUT, checkUpdateFinished);
-    return;
-  }
-
-  if (IS_WIN) {
-    // Don't proceed until the updater binary is no longer in use.
-    let updater = getUpdatesPatchDir();
-    updater.append(FILE_UPDATER_BIN);
-    if (updater.exists()) {
-      if (gTimeoutRuns > MAX_TIMEOUT_RUNS) {
-        do_throw("Exceeded while waiting for updater binary to no longer be " +
-                 "in use");
-      }
-      try {
-        updater.remove(false);
-      } catch (e) {
-        do_timeout(TEST_CHECK_TIMEOUT, checkUpdateFinished);
-        return;
-      }
-    }
-  }
+function runUpdateFinished() {
+  checkPostUpdateAppLog();
+}
 
+/**
+ * Called after the call to checkPostUpdateAppLog finishes.
+ */
+function checkPostUpdateAppLogFinished() {
   checkAppBundleModTime();
-  checkFilesAfterUpdateSuccess(getApplyDirFile, false, false);
+  standardInit();
+  checkPostUpdateRunningFile(true);
+  checkFilesAfterUpdateSuccess(getApplyDirFile);
   checkUpdateLogContents(LOG_COMPLETE_SUCCESS);
 
-  standardInit();
-
-  let update = gUpdateManager.getUpdateAt(0);
-  Assert.equal(update.state, END_STATE,
-               "the update state" + MSG_SHOULD_EQUAL);
-
   let updatesDir = getUpdatesPatchDir();
-  Assert.ok(updatesDir.exists(), MSG_SHOULD_EXIST);
+  Assert.ok(updatesDir.exists(),
+            MSG_SHOULD_EXIST + getMsgPath(updatesDir.path));
 
-  log = getUpdatesPatchDir();
-  log.append(FILE_UPDATE_LOG);
-  Assert.ok(!log.exists(), MSG_SHOULD_NOT_EXIST);
+  let log = getUpdateLog(FILE_UPDATE_LOG);
+  Assert.ok(!log.exists(),
+            MSG_SHOULD_NOT_EXIST + getMsgPath(log.path));
 
-  log = getUpdatesDir();
-  log.append(FILE_LAST_LOG);
-  Assert.ok(log.exists(), MSG_SHOULD_EXIST);
+  log = getUpdateLog(FILE_LAST_UPDATE_LOG);
+  Assert.ok(log.exists(),
+            MSG_SHOULD_EXIST + getMsgPath(log.path));
 
-  log = getUpdatesDir();
-  log.append(FILE_BACKUP_LOG);
-  Assert.ok(!log.exists(), MSG_SHOULD_NOT_EXIST);
+  log = getUpdateLog(FILE_BACKUP_UPDATE_LOG);
+  Assert.ok(!log.exists(),
+            MSG_SHOULD_NOT_EXIST + getMsgPath(log.path));
 
   waitForFilesInUse();
 }
diff --git a/toolkit/mozapps/update/tests/unit_service_updater/marAppInUseStageFailureCompleteSvc_win.js b/toolkit/mozapps/update/tests/unit_service_updater/marAppInUseStageFailureCompleteSvc_win.js
index 0a5e86187c89..e3f4008ca09f 100644
--- a/toolkit/mozapps/update/tests/unit_service_updater/marAppInUseStageFailureCompleteSvc_win.js
+++ b/toolkit/mozapps/update/tests/unit_service_updater/marAppInUseStageFailureCompleteSvc_win.js
@@ -4,56 +4,59 @@
 
 /* Application in use complete MAR file staged patch apply failure test */
 
-const START_STATE = STATE_PENDING_SVC;
-const END_STATE = STATE_PENDING;
+const STATE_AFTER_STAGE = IS_SERVICE_TEST ? STATE_APPLIED_SVC : STATE_APPLIED;
 
 function run_test() {
-  if (!shouldRunServiceTest()) {
+  if (!setupTestCommon()) {
     return;
   }
-
-  gStageUpdate = true;
-  setupTestCommon();
   gTestFiles = gTestFilesCompleteSuccess;
   gTestDirs = gTestDirsCompleteSuccess;
-  setTestFilesAndDirsForFailure();
-  setupUpdaterTest(FILE_COMPLETE_MAR);
-
-  // Launch the callback helper application so it is in use during the update.
-  let callbackApp = getApplyDirFile(DIR_RESOURCES + gCallbackBinFile);
-  let args = [getApplyDirPath() + DIR_RESOURCES, "input", "output", "-s",
-              HELPER_SLEEP_TIMEOUT];
-  let callbackAppProcess = Cc["@mozilla.org/process/util;1"].
-                           createInstance(Ci.nsIProcess);
-  callbackAppProcess.init(callbackApp);
-  callbackAppProcess.run(false, args, args.length);
-
-  setupAppFilesAsync();
+  createUpdaterINI(false);
+  setupUpdaterTest(FILE_COMPLETE_MAR, false);
 }
 
-function setupAppFilesFinished() {
-  do_timeout(TEST_HELPER_TIMEOUT, waitForHelperSleep);
+/**
+ * Called after the call to setupUpdaterTest finishes.
+ */
+function setupUpdaterTestFinished() {
+  runHelperFileInUse(DIR_RESOURCES + gCallbackBinFile, false);
 }
 
-function doUpdate() {
-  runUpdateUsingService(START_STATE, STATE_APPLIED);
+/**
+ * Called after the call to waitForHelperSleep finishes.
+ */
+function waitForHelperSleepFinished() {
+  stageUpdate();
 }
 
-function checkUpdateFinished() {
+/**
+ * Called after the call to stageUpdate finishes.
+ */
+function stageUpdateFinished() {
+  checkPostUpdateRunningFile(false);
+  checkFilesAfterUpdateSuccess(getStageDirFile, true);
+  checkUpdateLogContents(LOG_COMPLETE_SUCCESS_STAGE, true);
   // Switch the application to the staged application that was updated.
-  gStageUpdate = false;
-  gSwitchApp = true;
-  runUpdate(1, END_STATE, checkUpdateApplied);
+  runUpdate(STATE_PENDING, true, 1, false);
 }
 
-function checkUpdateApplied() {
-  setupHelperFinish();
+/**
+ * Called after the call to runUpdate finishes.
+ */
+function runUpdateFinished() {
+  waitForHelperExit();
 }
 
-function checkUpdate() {
-  checkFilesAfterUpdateFailure(getApplyDirFile, false, false);
+/**
+ * Called after the call to waitForHelperExit finishes.
+ */
+function waitForHelperExitFinished() {
+  standardInit();
+  checkPostUpdateRunningFile(false);
+  setTestFilesAndDirsForFailure();
+  checkFilesAfterUpdateFailure(getApplyDirFile);
   checkUpdateLogContains(ERR_RENAME_FILE);
   checkUpdateLogContains(ERR_MOVE_DESTDIR_7);
-  standardInit();
-  checkCallbackAppLog();
+  checkCallbackLog();
 }
diff --git a/toolkit/mozapps/update/tests/unit_service_updater/marAppInUseSuccessCompleteSvc.js b/toolkit/mozapps/update/tests/unit_service_updater/marAppInUseSuccessCompleteSvc.js
index bb82d3f1f2b9..9f726597bece 100644
--- a/toolkit/mozapps/update/tests/unit_service_updater/marAppInUseSuccessCompleteSvc.js
+++ b/toolkit/mozapps/update/tests/unit_service_updater/marAppInUseSuccessCompleteSvc.js
@@ -5,45 +5,50 @@
 /* Application in use complete MAR file patch apply success test */
 
 function run_test() {
-  if (!shouldRunServiceTest()) {
+  if (!setupTestCommon()) {
     return;
   }
-
-  setupTestCommon();
   gTestFiles = gTestFilesCompleteSuccess;
   gTestDirs = gTestDirsCompleteSuccess;
-  setupUpdaterTest(FILE_COMPLETE_MAR);
-
-  // Launch the callback helper application so it is in use during the update.
-  let callbackApp = getApplyDirFile(DIR_RESOURCES + gCallbackBinFile);
-  callbackApp.permissions = PERMS_DIRECTORY;
-  let args = [getApplyDirPath() + DIR_RESOURCES, "input", "output", "-s",
-              HELPER_SLEEP_TIMEOUT];
-  let callbackAppProcess = Cc["@mozilla.org/process/util;1"].
-                           createInstance(Ci.nsIProcess);
-  callbackAppProcess.init(callbackApp);
-  callbackAppProcess.run(false, args, args.length);
-
-  setupAppFilesAsync();
+  setupUpdaterTest(FILE_COMPLETE_MAR, false);
 }
 
-function setupAppFilesFinished() {
-  do_timeout(TEST_HELPER_TIMEOUT, waitForHelperSleep);
+/**
+ * Called after the call to setupUpdaterTest finishes.
+ */
+function setupUpdaterTestFinished() {
+  runHelperFileInUse(DIR_RESOURCES + gCallbackBinFile, false);
 }
 
-function doUpdate() {
-  setAppBundleModTime();
-  runUpdateUsingService(STATE_PENDING_SVC, STATE_SUCCEEDED);
+/**
+ * Called after the call to waitForHelperSleep finishes.
+ */
+function waitForHelperSleepFinished() {
+  runUpdate(STATE_SUCCEEDED, false, 0, true);
 }
 
-function checkUpdateFinished() {
-  setupHelperFinish();
+/**
+ * Called after the call to runUpdate finishes.
+ */
+function runUpdateFinished() {
+  waitForHelperExit();
 }
 
-function checkUpdate() {
+/**
+ * Called after the call to waitForHelperExit finishes.
+ */
+function waitForHelperExitFinished() {
+  checkPostUpdateAppLog();
+}
+
+/**
+ * Called after the call to checkPostUpdateAppLog finishes.
+ */
+function checkPostUpdateAppLogFinished() {
   checkAppBundleModTime();
-  checkFilesAfterUpdateSuccess(getApplyDirFile, false, false);
-  checkUpdateLogContents(LOG_COMPLETE_SUCCESS);
   standardInit();
-  checkCallbackServiceLog();
+  checkPostUpdateRunningFile(true);
+  checkFilesAfterUpdateSuccess(getApplyDirFile);
+  checkUpdateLogContents(LOG_COMPLETE_SUCCESS);
+  checkCallbackLog();
 }
diff --git a/toolkit/mozapps/update/tests/unit_service_updater/marCallbackAppStageSuccessCompleteSvc_win.js b/toolkit/mozapps/update/tests/unit_service_updater/marCallbackAppStageSuccessCompleteSvc_win.js
index aaee1adea70b..af936791fb7a 100644
--- a/toolkit/mozapps/update/tests/unit_service_updater/marCallbackAppStageSuccessCompleteSvc_win.js
+++ b/toolkit/mozapps/update/tests/unit_service_updater/marCallbackAppStageSuccessCompleteSvc_win.js
@@ -4,35 +4,50 @@
 
 /* Replace app binary complete MAR file staged patch apply success test */
 
+const STATE_AFTER_STAGE = IS_SERVICE_TEST ? STATE_APPLIED_SVC : STATE_APPLIED;
+
 function run_test() {
-  if (!shouldRunServiceTest()) {
+  if (!setupTestCommon()) {
     return;
   }
-
-  gStageUpdate = true;
-  setupTestCommon();
   gTestFiles = gTestFilesCompleteSuccess;
   gTestDirs = gTestDirsCompleteSuccess;
-  setupUpdaterTest(FILE_COMPLETE_MAR);
-
   gCallbackBinFile = "exe0.exe";
-
-  setupAppFilesAsync();
+  setupUpdaterTest(FILE_COMPLETE_MAR, false);
 }
 
-function setupAppFilesFinished() {
-  runUpdateUsingService(STATE_PENDING_SVC, STATE_APPLIED);
+/**
+ * Called after the call to setupUpdaterTest finishes.
+ */
+function setupUpdaterTestFinished() {
+  stageUpdate();
 }
 
-function checkUpdateFinished() {
+/**
+ * Called after the call to stageUpdate finishes.
+ */
+function stageUpdateFinished() {
+  checkPostUpdateRunningFile(false);
+  checkFilesAfterUpdateSuccess(getStageDirFile, true);
+  checkUpdateLogContents(LOG_COMPLETE_SUCCESS_STAGE, true);
   // Switch the application to the staged application that was updated.
-  gStageUpdate = false;
-  gSwitchApp = true;
-  runUpdate(0, STATE_SUCCEEDED, checkUpdateApplied);
+  runUpdate(STATE_SUCCEEDED, true, 0, false);
 }
 
-function checkUpdateApplied() {
-  checkFilesAfterUpdateSuccess(getApplyDirFile, false, false);
-  standardInit();
-  checkCallbackAppLog();
+/**
+ * Called after the call to runUpdate finishes.
+ */
+function runUpdateFinished() {
+  checkPostUpdateAppLog();
+}
+
+/**
+ * Called after the call to checkPostUpdateAppLog finishes.
+ */
+function checkPostUpdateAppLogFinished() {
+  standardInit();
+  checkPostUpdateRunningFile(true);
+  checkFilesAfterUpdateSuccess(getApplyDirFile, false, true);
+  checkUpdateLogContents(LOG_REPLACE_SUCCESS, false, true);
+  checkCallbackLog();
 }
diff --git a/toolkit/mozapps/update/tests/unit_service_updater/marCallbackAppStageSuccessPartialSvc_win.js b/toolkit/mozapps/update/tests/unit_service_updater/marCallbackAppStageSuccessPartialSvc_win.js
index 451cbd4b8d9b..8ed7d515cd49 100644
--- a/toolkit/mozapps/update/tests/unit_service_updater/marCallbackAppStageSuccessPartialSvc_win.js
+++ b/toolkit/mozapps/update/tests/unit_service_updater/marCallbackAppStageSuccessPartialSvc_win.js
@@ -4,35 +4,50 @@
 
 /* Patch app binary partial MAR file staged patch apply success test */
 
+const STATE_AFTER_STAGE = IS_SERVICE_TEST ? STATE_APPLIED_SVC : STATE_APPLIED;
+
 function run_test() {
-  if (!shouldRunServiceTest()) {
+  if (!setupTestCommon()) {
     return;
   }
-
-  gStageUpdate = true;
-  setupTestCommon();
   gTestFiles = gTestFilesPartialSuccess;
   gTestDirs = gTestDirsPartialSuccess;
-  setupUpdaterTest(FILE_PARTIAL_MAR);
-
   gCallbackBinFile = "exe0.exe";
-
-  setupAppFilesAsync();
+  setupUpdaterTest(FILE_PARTIAL_MAR, false);
 }
 
-function setupAppFilesFinished() {
-  runUpdateUsingService(STATE_PENDING_SVC, STATE_APPLIED);
+/**
+ * Called after the call to setupUpdaterTest finishes.
+ */
+function setupUpdaterTestFinished() {
+  stageUpdate();
 }
 
-function checkUpdateFinished() {
+/**
+ * Called after the call to stageUpdate finishes.
+ */
+function stageUpdateFinished() {
+  checkPostUpdateRunningFile(false);
+  checkFilesAfterUpdateSuccess(getStageDirFile, true);
+  checkUpdateLogContents(LOG_PARTIAL_SUCCESS_STAGE, true);
   // Switch the application to the staged application that was updated.
-  gStageUpdate = false;
-  gSwitchApp = true;
-  runUpdate(0, STATE_SUCCEEDED, checkUpdateApplied);
+  runUpdate(STATE_SUCCEEDED, true, 0, false);
 }
 
-function checkUpdateApplied() {
-  checkFilesAfterUpdateSuccess(getApplyDirFile, false, false);
-  standardInit();
-  checkCallbackAppLog();
+/**
+ * Called after the call to runUpdate finishes.
+ */
+function runUpdateFinished() {
+  checkPostUpdateAppLog();
+}
+
+/**
+ * Called after the call to checkPostUpdateAppLog finishes.
+ */
+function checkPostUpdateAppLogFinished() {
+  standardInit();
+  checkPostUpdateRunningFile(true);
+  checkFilesAfterUpdateSuccess(getApplyDirFile, false, true);
+  checkUpdateLogContents(LOG_REPLACE_SUCCESS, false, true);
+  checkCallbackLog();
 }
diff --git a/toolkit/mozapps/update/tests/unit_service_updater/marCallbackAppSuccessCompleteSvc_win.js b/toolkit/mozapps/update/tests/unit_service_updater/marCallbackAppSuccessCompleteSvc_win.js
index a06d49078cc0..a7324bdd97d3 100644
--- a/toolkit/mozapps/update/tests/unit_service_updater/marCallbackAppSuccessCompleteSvc_win.js
+++ b/toolkit/mozapps/update/tests/unit_service_updater/marCallbackAppSuccessCompleteSvc_win.js
@@ -5,26 +5,36 @@
 /* Replace app binary complete MAR file patch apply success test */
 
 function run_test() {
-  if (!shouldRunServiceTest()) {
+  if (!setupTestCommon()) {
     return;
   }
-
-  setupTestCommon();
   gTestFiles = gTestFilesCompleteSuccess;
   gTestDirs = gTestDirsCompleteSuccess;
-  setupUpdaterTest(FILE_COMPLETE_MAR);
-
   gCallbackBinFile = "exe0.exe";
-
-  setupAppFilesAsync();
+  setupUpdaterTest(FILE_COMPLETE_MAR, false);
 }
 
-function setupAppFilesFinished() {
-  runUpdateUsingService(STATE_PENDING_SVC, STATE_SUCCEEDED);
+/**
+ * Called after the call to setupUpdaterTest finishes.
+ */
+function setupUpdaterTestFinished() {
+  runUpdate(STATE_SUCCEEDED, false, 0, true);
 }
 
-function checkUpdateFinished() {
-  checkFilesAfterUpdateSuccess(getApplyDirFile, false, false);
+/**
+ * Called after the call to runUpdate finishes.
+ */
+function runUpdateFinished() {
+  checkPostUpdateAppLog();
+}
+
+/**
+ * Called after the call to checkPostUpdateAppLog finishes.
+ */
+function checkPostUpdateAppLogFinished() {
   standardInit();
-  checkCallbackServiceLog();
+  checkPostUpdateRunningFile(true);
+  checkFilesAfterUpdateSuccess(getApplyDirFile);
+  checkUpdateLogContents(LOG_COMPLETE_SUCCESS);
+  checkCallbackLog();
 }
diff --git a/toolkit/mozapps/update/tests/unit_service_updater/marCallbackAppSuccessPartialSvc_win.js b/toolkit/mozapps/update/tests/unit_service_updater/marCallbackAppSuccessPartialSvc_win.js
index d8cbf8a310b6..4eeae597e1f3 100644
--- a/toolkit/mozapps/update/tests/unit_service_updater/marCallbackAppSuccessPartialSvc_win.js
+++ b/toolkit/mozapps/update/tests/unit_service_updater/marCallbackAppSuccessPartialSvc_win.js
@@ -5,26 +5,36 @@
 /* Patch app binary partial MAR file patch apply success test */
 
 function run_test() {
-  if (!shouldRunServiceTest()) {
+  if (!setupTestCommon()) {
     return;
   }
-
-  setupTestCommon();
   gTestFiles = gTestFilesPartialSuccess;
   gTestDirs = gTestDirsPartialSuccess;
-  setupUpdaterTest(FILE_PARTIAL_MAR);
-
   gCallbackBinFile = "exe0.exe";
-
-  setupAppFilesAsync();
+  setupUpdaterTest(FILE_PARTIAL_MAR, false);
 }
 
-function setupAppFilesFinished() {
-  runUpdateUsingService(STATE_PENDING_SVC, STATE_SUCCEEDED);
+/**
+ * Called after the call to setupUpdaterTest finishes.
+ */
+function setupUpdaterTestFinished() {
+  runUpdate(STATE_SUCCEEDED, false, 0, true);
 }
 
-function checkUpdateFinished() {
-  checkFilesAfterUpdateSuccess(getApplyDirFile, false, false);
+/**
+ * Called after the call to runUpdate finishes.
+ */
+function runUpdateFinished() {
+  checkPostUpdateAppLog();
+}
+
+/**
+ * Called after the call to checkPostUpdateAppLog finishes.
+ */
+function checkPostUpdateAppLogFinished() {
   standardInit();
-  checkCallbackServiceLog();
+  checkPostUpdateRunningFile(true);
+  checkFilesAfterUpdateSuccess(getApplyDirFile);
+  checkUpdateLogContents(LOG_PARTIAL_SUCCESS);
+  checkCallbackLog();
 }
diff --git a/toolkit/mozapps/update/tests/unit_service_updater/marFailurePartialSvc.js b/toolkit/mozapps/update/tests/unit_service_updater/marFailurePartialSvc.js
index d87a1c50a852..d89226c97c0d 100644
--- a/toolkit/mozapps/update/tests/unit_service_updater/marFailurePartialSvc.js
+++ b/toolkit/mozapps/update/tests/unit_service_updater/marFailurePartialSvc.js
@@ -6,37 +6,34 @@
 /* General Partial MAR File Patch Apply Failure Test */
 
 function run_test() {
-  if (!shouldRunServiceTest()) {
+  if (!setupTestCommon()) {
     return;
   }
-
-  setupTestCommon();
   gTestFiles = gTestFilesPartialSuccess;
   gTestFiles[11].originalFile = "partial.png";
   gTestDirs = gTestDirsPartialSuccess;
   setTestFilesAndDirsForFailure();
-  setupUpdaterTest(FILE_PARTIAL_MAR);
-
-  createUpdaterINI();
-  setAppBundleModTime();
-
-  setupAppFilesAsync();
-}
-
-function setupAppFilesFinished() {
-  runUpdateUsingService(STATE_PENDING_SVC,
-                        STATE_FAILED_LOADSOURCE_ERROR_WRONG_SIZE);
+  setupUpdaterTest(FILE_PARTIAL_MAR, false);
 }
 
 /**
- * Checks if the update has finished and if it has finished performs checks for
- * the test.
+ * Called after the call to setupUpdaterTest finishes.
  */
-function checkUpdateFinished() {
-  checkPostUpdateRunningFile(false);
-  checkAppBundleModTime();
-  checkFilesAfterUpdateFailure(getApplyDirFile, false, false);
-  checkUpdateLogContents(LOG_PARTIAL_FAILURE);
-  standardInit();
-  checkCallbackServiceLog();
+function setupUpdaterTestFinished() {
+  // If execv is used the updater process will turn into the callback process
+  // and the updater's return code will be that of the callback process.
+  runUpdate(STATE_FAILED_LOADSOURCE_ERROR_WRONG_SIZE, false,
+            (USE_EXECV ? 0 : 1), true);
+}
+
+/**
+ * Called after the call to runUpdate finishes.
+ */
+function runUpdateFinished() {
+  checkAppBundleModTime();
+  standardInit();
+  checkPostUpdateRunningFile(false);
+  checkFilesAfterUpdateFailure(getApplyDirFile);
+  checkUpdateLogContents(LOG_PARTIAL_FAILURE);
+  checkCallbackLog();
 }
diff --git a/toolkit/mozapps/update/tests/unit_service_updater/marFileInUseStageFailureCompleteSvc_win.js b/toolkit/mozapps/update/tests/unit_service_updater/marFileInUseStageFailureCompleteSvc_win.js
index 4c9ab7e60f32..b4021c3b0e0e 100644
--- a/toolkit/mozapps/update/tests/unit_service_updater/marFileInUseStageFailureCompleteSvc_win.js
+++ b/toolkit/mozapps/update/tests/unit_service_updater/marFileInUseStageFailureCompleteSvc_win.js
@@ -4,54 +4,59 @@
 
 /* File in use complete MAR file staged patch apply failure test */
 
+const STATE_AFTER_STAGE = IS_SERVICE_TEST ? STATE_APPLIED_SVC : STATE_APPLIED;
+
 function run_test() {
-  if (!shouldRunServiceTest()) {
+  if (!setupTestCommon()) {
     return;
   }
-
-  gStageUpdate = true;
-  setupTestCommon();
   gTestFiles = gTestFilesCompleteSuccess;
   gTestDirs = gTestDirsCompleteSuccess;
-  setTestFilesAndDirsForFailure();
-  setupUpdaterTest(FILE_COMPLETE_MAR);
-
-  // Launch an existing file so it is in use during the update.
-  let fileInUseBin = getApplyDirFile(gTestFiles[13].relPathDir +
-                                     gTestFiles[13].fileName);
-  let args = [getApplyDirPath() + DIR_RESOURCES, "input", "output", "-s",
-              HELPER_SLEEP_TIMEOUT];
-  let fileInUseProcess = Cc["@mozilla.org/process/util;1"].
-                         createInstance(Ci.nsIProcess);
-  fileInUseProcess.init(fileInUseBin);
-  fileInUseProcess.run(false, args, args.length);
-
-  setupAppFilesAsync();
+  setupUpdaterTest(FILE_COMPLETE_MAR, false);
 }
 
-function setupAppFilesFinished() {
-  do_timeout(TEST_HELPER_TIMEOUT, waitForHelperSleep);
+/**
+ * Called after the call to setupUpdaterTest finishes.
+ */
+function setupUpdaterTestFinished() {
+  runHelperFileInUse(gTestFiles[13].relPathDir + gTestFiles[13].fileName,
+                     false);
 }
 
-function doUpdate() {
-  runUpdateUsingService(STATE_PENDING_SVC, STATE_APPLIED);
+/**
+ * Called after the call to waitForHelperSleep finishes.
+ */
+function waitForHelperSleepFinished() {
+  stageUpdate();
 }
 
-function checkUpdateFinished() {
+/**
+ * Called after the call to stageUpdate finishes.
+ */
+function stageUpdateFinished() {
+  checkPostUpdateRunningFile(false);
+  checkFilesAfterUpdateSuccess(getStageDirFile, true);
+  checkUpdateLogContents(LOG_COMPLETE_SUCCESS_STAGE, true);
   // Switch the application to the staged application that was updated.
-  gStageUpdate = false;
-  gSwitchApp = true;
-  runUpdate(1, STATE_PENDING, checkUpdateApplied);
+  runUpdate(STATE_PENDING, true, 1, false);
 }
 
-function checkUpdateApplied() {
-  setupHelperFinish();
+/**
+ * Called after the call to runUpdate finishes.
+ */
+function runUpdateFinished() {
+  waitForHelperExit();
 }
 
-function checkUpdate() {
-  checkFilesAfterUpdateFailure(getApplyDirFile, false, false);
+/**
+ * Called after the call to waitForHelperExit finishes.
+ */
+function waitForHelperExitFinished() {
+  standardInit();
+  checkPostUpdateRunningFile(false);
+  setTestFilesAndDirsForFailure();
+  checkFilesAfterUpdateFailure(getApplyDirFile);
   checkUpdateLogContains(ERR_RENAME_FILE);
   checkUpdateLogContains(ERR_MOVE_DESTDIR_7);
-  standardInit();
-  checkCallbackAppLog();
+  checkCallbackLog();
 }
diff --git a/toolkit/mozapps/update/tests/unit_service_updater/marFileInUseStageFailurePartialSvc_win.js b/toolkit/mozapps/update/tests/unit_service_updater/marFileInUseStageFailurePartialSvc_win.js
index a3f09b4a6ff6..7ee5f38834e7 100644
--- a/toolkit/mozapps/update/tests/unit_service_updater/marFileInUseStageFailurePartialSvc_win.js
+++ b/toolkit/mozapps/update/tests/unit_service_updater/marFileInUseStageFailurePartialSvc_win.js
@@ -4,54 +4,59 @@
 
 /* File in use partial MAR file staged patch apply failure test */
 
+const STATE_AFTER_STAGE = IS_SERVICE_TEST ? STATE_APPLIED_SVC : STATE_APPLIED;
+
 function run_test() {
-  if (!shouldRunServiceTest()) {
+  if (!setupTestCommon()) {
     return;
   }
-
-  gStageUpdate = true;
-  setupTestCommon();
   gTestFiles = gTestFilesPartialSuccess;
   gTestDirs = gTestDirsPartialSuccess;
-  setTestFilesAndDirsForFailure();
-  setupUpdaterTest(FILE_PARTIAL_MAR);
-
-  // Launch an existing file so it is in use during the update.
-  let fileInUseBin = getApplyDirFile(gTestFiles[11].relPathDir +
-                                     gTestFiles[11].fileName);
-  let args = [getApplyDirPath() + DIR_RESOURCES, "input", "output", "-s",
-              HELPER_SLEEP_TIMEOUT];
-  let fileInUseProcess = Cc["@mozilla.org/process/util;1"].
-                         createInstance(Ci.nsIProcess);
-  fileInUseProcess.init(fileInUseBin);
-  fileInUseProcess.run(false, args, args.length);
-
-  setupAppFilesAsync();
+  setupUpdaterTest(FILE_PARTIAL_MAR, false);
 }
 
-function setupAppFilesFinished() {
-  do_timeout(TEST_HELPER_TIMEOUT, waitForHelperSleep);
+/**
+ * Called after the call to setupUpdaterTest finishes.
+ */
+function setupUpdaterTestFinished() {
+  runHelperFileInUse(gTestFiles[11].relPathDir + gTestFiles[11].fileName,
+                     false);
 }
 
-function doUpdate() {
-  runUpdateUsingService(STATE_PENDING_SVC, STATE_APPLIED);
+/**
+ * Called after the call to waitForHelperSleep finishes.
+ */
+function waitForHelperSleepFinished() {
+  stageUpdate();
 }
 
-function checkUpdateFinished() {
+/**
+ * Called after the call to stageUpdate finishes.
+ */
+function stageUpdateFinished() {
+  checkPostUpdateRunningFile(false);
+  checkFilesAfterUpdateSuccess(getStageDirFile, true);
+  checkUpdateLogContents(LOG_PARTIAL_SUCCESS_STAGE, true);
   // Switch the application to the staged application that was updated.
-  gStageUpdate = false;
-  gSwitchApp = true;
-  runUpdate(1, STATE_PENDING, checkUpdateApplied);
+  runUpdate(STATE_PENDING, true, 1, false);
 }
 
-function checkUpdateApplied() {
-  setupHelperFinish();
+/**
+ * Called after the call to runUpdate finishes.
+ */
+function runUpdateFinished() {
+  waitForHelperExit();
 }
 
-function checkUpdate() {
-  checkFilesAfterUpdateFailure(getApplyDirFile, false, false);
+/**
+ * Called after the call to waitForHelperExit finishes.
+ */
+function waitForHelperExitFinished() {
+  standardInit();
+  checkPostUpdateRunningFile(false);
+  setTestFilesAndDirsForFailure();
+  checkFilesAfterUpdateFailure(getApplyDirFile);
   checkUpdateLogContains(ERR_RENAME_FILE);
   checkUpdateLogContains(ERR_MOVE_DESTDIR_7);
-  standardInit();
-  checkCallbackAppLog();
+  checkCallbackLog();
 }
diff --git a/toolkit/mozapps/update/tests/unit_service_updater/marFileInUseSuccessCompleteSvc_win.js b/toolkit/mozapps/update/tests/unit_service_updater/marFileInUseSuccessCompleteSvc_win.js
index d35d6dbb9948..c0e93735d6f5 100644
--- a/toolkit/mozapps/update/tests/unit_service_updater/marFileInUseSuccessCompleteSvc_win.js
+++ b/toolkit/mozapps/update/tests/unit_service_updater/marFileInUseSuccessCompleteSvc_win.js
@@ -5,43 +5,50 @@
 /* File in use complete MAR file patch apply success test */
 
 function run_test() {
-  if (!shouldRunServiceTest()) {
+  if (!setupTestCommon()) {
     return;
   }
-
-  setupTestCommon();
   gTestFiles = gTestFilesCompleteSuccess;
   gTestDirs = gTestDirsCompleteSuccess;
-  setupUpdaterTest(FILE_COMPLETE_MAR);
-
-  // Launch an existing file so it is in use during the update.
-  let fileInUseBin = getApplyDirFile(gTestFiles[13].relPathDir +
-                                     gTestFiles[13].fileName);
-  let args = [getApplyDirPath() + DIR_RESOURCES, "input", "output", "-s",
-              HELPER_SLEEP_TIMEOUT];
-  let fileInUseProcess = Cc["@mozilla.org/process/util;1"].
-                         createInstance(Ci.nsIProcess);
-  fileInUseProcess.init(fileInUseBin);
-  fileInUseProcess.run(false, args, args.length);
-
-  setupAppFilesAsync();
+  setupUpdaterTest(FILE_COMPLETE_MAR, false);
 }
 
-function setupAppFilesFinished() {
-  do_timeout(TEST_HELPER_TIMEOUT, waitForHelperSleep);
+/**
+ * Called after the call to setupUpdaterTest finishes.
+ */
+function setupUpdaterTestFinished() {
+  runHelperFileInUse(gTestFiles[13].relPathDir + gTestFiles[13].fileName,
+                     false);
 }
 
-function doUpdate() {
-  runUpdateUsingService(STATE_PENDING_SVC, STATE_SUCCEEDED);
+/**
+ * Called after the call to waitForHelperSleep finishes.
+ */
+function waitForHelperSleepFinished() {
+  runUpdate(STATE_SUCCEEDED, false, 0, true);
 }
 
-function checkUpdateFinished() {
-  setupHelperFinish();
+/**
+ * Called after the call to runUpdate finishes.
+ */
+function runUpdateFinished() {
+  waitForHelperExit();
 }
 
-function checkUpdate() {
+/**
+ * Called after the call to waitForHelperExit finishes.
+ */
+function waitForHelperExitFinished() {
+  checkPostUpdateAppLog();
+}
+
+/**
+ * Called after the call to checkPostUpdateAppLog finishes.
+ */
+function checkPostUpdateAppLogFinished() {
+  standardInit();
+  checkPostUpdateRunningFile(true);
   checkFilesAfterUpdateSuccess(getApplyDirFile, false, true);
   checkUpdateLogContains(ERR_BACKUP_DISCARD);
-  standardInit();
-  checkCallbackServiceLog();
+  checkCallbackLog();
 }
diff --git a/toolkit/mozapps/update/tests/unit_service_updater/marFileInUseSuccessPartialSvc_win.js b/toolkit/mozapps/update/tests/unit_service_updater/marFileInUseSuccessPartialSvc_win.js
index ae34168f100a..15509c1e99a9 100644
--- a/toolkit/mozapps/update/tests/unit_service_updater/marFileInUseSuccessPartialSvc_win.js
+++ b/toolkit/mozapps/update/tests/unit_service_updater/marFileInUseSuccessPartialSvc_win.js
@@ -5,43 +5,50 @@
 /* File in use partial MAR file patch apply success test */
 
 function run_test() {
-  if (!shouldRunServiceTest()) {
+  if (!setupTestCommon()) {
     return;
   }
-
-  setupTestCommon();
   gTestFiles = gTestFilesPartialSuccess;
   gTestDirs = gTestDirsPartialSuccess;
-  setupUpdaterTest(FILE_PARTIAL_MAR);
-
-  // Launch an existing file so it is in use during the update.
-  let fileInUseBin = getApplyDirFile(gTestFiles[11].relPathDir +
-                                     gTestFiles[11].fileName);
-  let args = [getApplyDirPath() + DIR_RESOURCES, "input", "output", "-s",
-              HELPER_SLEEP_TIMEOUT];
-  let fileInUseProcess = Cc["@mozilla.org/process/util;1"].
-                         createInstance(Ci.nsIProcess);
-  fileInUseProcess.init(fileInUseBin);
-  fileInUseProcess.run(false, args, args.length);
-
-  setupAppFilesAsync();
+  setupUpdaterTest(FILE_PARTIAL_MAR, false);
 }
 
-function setupAppFilesFinished() {
-  do_timeout(TEST_HELPER_TIMEOUT, waitForHelperSleep);
+/**
+ * Called after the call to setupUpdaterTest finishes.
+ */
+function setupUpdaterTestFinished() {
+  runHelperFileInUse(gTestFiles[11].relPathDir + gTestFiles[11].fileName,
+                     false);
 }
 
-function doUpdate() {
-  runUpdateUsingService(STATE_PENDING_SVC, STATE_SUCCEEDED);
+/**
+ * Called after the call to waitForHelperSleep finishes.
+ */
+function waitForHelperSleepFinished() {
+  runUpdate(STATE_SUCCEEDED, false, 0, true);
 }
 
-function checkUpdateFinished() {
-  setupHelperFinish();
+/**
+ * Called after the call to runUpdate finishes.
+ */
+function runUpdateFinished() {
+  waitForHelperExit();
 }
 
-function checkUpdate() {
+/**
+ * Called after the call to waitForHelperExit finishes.
+ */
+function waitForHelperExitFinished() {
+  checkPostUpdateAppLog();
+}
+
+/**
+ * Called after the call to checkPostUpdateAppLog finishes.
+ */
+function checkPostUpdateAppLogFinished() {
+  standardInit();
+  checkPostUpdateRunningFile(true);
   checkFilesAfterUpdateSuccess(getApplyDirFile, false, true);
   checkUpdateLogContains(ERR_BACKUP_DISCARD);
-  standardInit();
-  checkCallbackServiceLog();
+  checkCallbackLog();
 }
diff --git a/toolkit/mozapps/update/tests/unit_service_updater/marFileLockedFailureCompleteSvc_win.js b/toolkit/mozapps/update/tests/unit_service_updater/marFileLockedFailureCompleteSvc_win.js
index 77afda102655..0e40d6578d38 100644
--- a/toolkit/mozapps/update/tests/unit_service_updater/marFileLockedFailureCompleteSvc_win.js
+++ b/toolkit/mozapps/update/tests/unit_service_updater/marFileLockedFailureCompleteSvc_win.js
@@ -5,53 +5,43 @@
 /* File locked complete MAR file patch apply failure test */
 
 function run_test() {
-  if (!shouldRunServiceTest()) {
+  if (!setupTestCommon()) {
     return;
   }
-
-  setupTestCommon();
   gTestFiles = gTestFilesCompleteSuccess;
   gTestDirs = gTestDirsCompleteSuccess;
   setTestFilesAndDirsForFailure();
-  setupUpdaterTest(FILE_COMPLETE_MAR);
-
-  // Exclusively lock an existing file so it is in use during the update.
-  let helperBin = getTestDirFile(FILE_HELPER_BIN);
-  let helperDestDir = getApplyDirFile(DIR_RESOURCES);
-  helperBin.copyTo(helperDestDir, FILE_HELPER_BIN);
-  helperBin = getApplyDirFile(DIR_RESOURCES + FILE_HELPER_BIN);
-  // Strip off the first two directories so the path has to be from the helper's
-  // working directory.
-  let lockFileRelPath = gTestFiles[3].relPathDir.split("/");
-  if (IS_MACOSX) {
-    lockFileRelPath = lockFileRelPath.slice(2);
-  }
-  lockFileRelPath = lockFileRelPath.join("/") + "/" + gTestFiles[3].fileName;
-  let args = [getApplyDirPath() + DIR_RESOURCES, "input", "output", "-s",
-              HELPER_SLEEP_TIMEOUT, lockFileRelPath];
-  let lockFileProcess = Cc["@mozilla.org/process/util;1"].
-                        createInstance(Ci.nsIProcess);
-  lockFileProcess.init(helperBin);
-  lockFileProcess.run(false, args, args.length);
-
-  setupAppFilesAsync();
+  setupUpdaterTest(FILE_COMPLETE_MAR, false);
 }
 
-function setupAppFilesFinished() {
-  do_timeout(TEST_HELPER_TIMEOUT, waitForHelperSleep);
+/**
+ * Called after the call to setupUpdaterTest finishes.
+ */
+function setupUpdaterTestFinished() {
+  runHelperLockFile(gTestFiles[3]);
 }
 
-function doUpdate() {
-  runUpdateUsingService(STATE_PENDING_SVC, STATE_FAILED_WRITE_ERROR);
+/**
+ * Called after the call to waitForHelperSleep finishes.
+ */
+function waitForHelperSleepFinished() {
+  runUpdate(STATE_FAILED_WRITE_ERROR, false, 1, true);
 }
 
-function checkUpdateFinished() {
-  setupHelperFinish();
+/**
+ * Called after the call to runUpdate finishes.
+ */
+function runUpdateFinished() {
+  waitForHelperExit();
 }
 
-function checkUpdate() {
-  checkFilesAfterUpdateFailure(getApplyDirFile, false, false);
-  checkUpdateLogContains(ERR_RENAME_FILE);
+/**
+ * Called after the call to waitForHelperExit finishes.
+ */
+function waitForHelperExitFinished() {
   standardInit();
-  checkCallbackServiceLog();
+  checkPostUpdateRunningFile(false);
+  checkFilesAfterUpdateFailure(getApplyDirFile);
+  checkUpdateLogContains(ERR_RENAME_FILE);
+  checkCallbackLog();
 }
diff --git a/toolkit/mozapps/update/tests/unit_service_updater/marFileLockedFailurePartialSvc_win.js b/toolkit/mozapps/update/tests/unit_service_updater/marFileLockedFailurePartialSvc_win.js
index 9a2fac751817..2eee830bdfc5 100644
--- a/toolkit/mozapps/update/tests/unit_service_updater/marFileLockedFailurePartialSvc_win.js
+++ b/toolkit/mozapps/update/tests/unit_service_updater/marFileLockedFailurePartialSvc_win.js
@@ -5,53 +5,43 @@
 /* File locked partial MAR file patch apply failure test */
 
 function run_test() {
-  if (!shouldRunServiceTest()) {
+  if (!setupTestCommon()) {
     return;
   }
-
-  setupTestCommon();
   gTestFiles = gTestFilesPartialSuccess;
   gTestDirs = gTestDirsPartialSuccess;
   setTestFilesAndDirsForFailure();
-  setupUpdaterTest(FILE_PARTIAL_MAR);
-
-  // Exclusively lock an existing file so it is in use during the update.
-  let helperBin = getTestDirFile(FILE_HELPER_BIN);
-  let helperDestDir = getApplyDirFile(DIR_RESOURCES);
-  helperBin.copyTo(helperDestDir, FILE_HELPER_BIN);
-  helperBin = getApplyDirFile(DIR_RESOURCES + FILE_HELPER_BIN);
-  // Strip off the first two directories so the path has to be from the helper's
-  // working directory.
-  let lockFileRelPath = gTestFiles[2].relPathDir.split("/");
-  if (IS_MACOSX) {
-    lockFileRelPath = lockFileRelPath.slice(2);
-  }
-  lockFileRelPath = lockFileRelPath.join("/") + "/" + gTestFiles[2].fileName;
-  let args = [getApplyDirPath() + DIR_RESOURCES, "input", "output", "-s",
-              HELPER_SLEEP_TIMEOUT, lockFileRelPath];
-  let lockFileProcess = Cc["@mozilla.org/process/util;1"].
-                        createInstance(Ci.nsIProcess);
-  lockFileProcess.init(helperBin);
-  lockFileProcess.run(false, args, args.length);
-
-  setupAppFilesAsync();
+  setupUpdaterTest(FILE_PARTIAL_MAR, false);
 }
 
-function setupAppFilesFinished() {
-  do_timeout(TEST_HELPER_TIMEOUT, waitForHelperSleep);
+/**
+ * Called after the call to setupUpdaterTest finishes.
+ */
+function setupUpdaterTestFinished() {
+  runHelperLockFile(gTestFiles[2]);
 }
 
-function doUpdate() {
-  runUpdateUsingService(STATE_PENDING_SVC, STATE_FAILED_READ_ERROR);
+/**
+ * Called after the call to waitForHelperSleep finishes.
+ */
+function waitForHelperSleepFinished() {
+  runUpdate(STATE_FAILED_READ_ERROR, false, 1, true);
 }
 
-function checkUpdateFinished() {
-  setupHelperFinish();
+/**
+ * Called after the call to runUpdate finishes.
+ */
+function runUpdateFinished() {
+  waitForHelperExit();
 }
 
-function checkUpdate() {
-  checkFilesAfterUpdateFailure(getApplyDirFile, false, false);
-  checkUpdateLogContains(ERR_UNABLE_OPEN_DEST);
+/**
+ * Called after the call to waitForHelperExit finishes.
+ */
+function waitForHelperExitFinished() {
   standardInit();
-  checkCallbackServiceLog();
+  checkPostUpdateRunningFile(false);
+  checkFilesAfterUpdateFailure(getApplyDirFile);
+  checkUpdateLogContains(ERR_UNABLE_OPEN_DEST);
+  checkCallbackLog();
 }
diff --git a/toolkit/mozapps/update/tests/unit_service_updater/marFileLockedStageFailureCompleteSvc_win.js b/toolkit/mozapps/update/tests/unit_service_updater/marFileLockedStageFailureCompleteSvc_win.js
index 9e4bb658d174..1d7915396fa3 100644
--- a/toolkit/mozapps/update/tests/unit_service_updater/marFileLockedStageFailureCompleteSvc_win.js
+++ b/toolkit/mozapps/update/tests/unit_service_updater/marFileLockedStageFailureCompleteSvc_win.js
@@ -4,63 +4,60 @@
 
 /* File locked complete MAR file staged patch apply failure test */
 
+const STATE_AFTER_STAGE = IS_SERVICE_TEST ? STATE_PENDING : STATE_APPLYING;
+
 function run_test() {
-  if (!shouldRunServiceTest()) {
+  if (!setupTestCommon()) {
     return;
   }
-
-  gStageUpdate = true;
-  setupTestCommon();
   gTestFiles = gTestFilesCompleteSuccess;
   gTestDirs = gTestDirsCompleteSuccess;
   setTestFilesAndDirsForFailure();
-  setupUpdaterTest(FILE_COMPLETE_MAR);
-
-  // Exclusively lock an existing file so it is in use during the update.
-  let helperBin = getTestDirFile(FILE_HELPER_BIN);
-  let helperDestDir = getApplyDirFile(DIR_RESOURCES);
-  helperBin.copyTo(helperDestDir, FILE_HELPER_BIN);
-  helperBin = getApplyDirFile(DIR_RESOURCES + FILE_HELPER_BIN);
-  // Strip off the first two directories so the path has to be from the helper's
-  // working directory.
-  let lockFileRelPath = gTestFiles[3].relPathDir.split("/");
-  if (IS_MACOSX) {
-    lockFileRelPath = lockFileRelPath.slice(2);
-  }
-  lockFileRelPath = lockFileRelPath.join("/") + "/" + gTestFiles[3].fileName;
-  let args = [getApplyDirPath() + DIR_RESOURCES, "input", "output", "-s",
-              HELPER_SLEEP_TIMEOUT, lockFileRelPath];
-  let lockFileProcess = Cc["@mozilla.org/process/util;1"].
-                        createInstance(Ci.nsIProcess);
-  lockFileProcess.init(helperBin);
-  lockFileProcess.run(false, args, args.length);
-
-  setupAppFilesAsync();
+  setupUpdaterTest(FILE_COMPLETE_MAR, false);
 }
 
-function setupAppFilesFinished() {
-  do_timeout(TEST_HELPER_TIMEOUT, waitForHelperSleep);
+/**
+ * Called after the call to setupUpdaterTest finishes.
+ */
+function setupUpdaterTestFinished() {
+  runHelperLockFile(gTestFiles[3]);
 }
 
-function doUpdate() {
-  runUpdateUsingService(STATE_PENDING_SVC, STATE_FAILED_WRITE_ERROR_FILE_COPY);
+/**
+ * Called after the call to waitForHelperSleep finishes.
+ */
+function waitForHelperSleepFinished() {
+  stageUpdate();
 }
 
-function checkUpdateFinished() {
+/**
+ * Called after the call to stageUpdate finishes.
+ */
+function stageUpdateFinished() {
+  checkPostUpdateRunningFile(false);
+  // Files aren't checked after staging since this test locks a file which
+  // prevents reading the file.
+  checkUpdateLogContains(ERR_ENSURE_COPY);
   // Switch the application to the staged application that was updated.
-  gStageUpdate = false;
-  gSwitchApp = true;
-  runUpdate(1, STATE_PENDING, checkUpdateApplied);
+  runUpdate(STATE_FAILED_WRITE_ERROR, false, 1, false);
 }
 
-function checkUpdateApplied() {
-  setupHelperFinish();
+/**
+ * Called after the call to runUpdate finishes.
+ */
+function runUpdateFinished() {
+  waitForHelperExit();
 }
 
-function checkUpdate() {
-  checkFilesAfterUpdateFailure(getApplyDirFile, false, false);
-  checkUpdateLogContains(ERR_RENAME_FILE);
-  checkUpdateLogContains(ERR_MOVE_DESTDIR_7);
+/**
+ * Called after the call to waitForHelperExit finishes.
+ */
+function waitForHelperExitFinished() {
   standardInit();
-  checkCallbackAppLog();
+  checkPostUpdateRunningFile(false);
+  checkFilesAfterUpdateFailure(getApplyDirFile);
+  checkUpdateLogContains(ERR_RENAME_FILE);
+  checkUpdateLogContains(ERR_BACKUP_CREATE_7);
+  checkUpdateLogContains(STATE_FAILED_WRITE_ERROR + "\n" + CALL_QUIT);
+  checkCallbackLog();
 }
diff --git a/toolkit/mozapps/update/tests/unit_service_updater/marFileLockedStageFailurePartialSvc_win.js b/toolkit/mozapps/update/tests/unit_service_updater/marFileLockedStageFailurePartialSvc_win.js
index e6dad5283123..1a38f65b1134 100644
--- a/toolkit/mozapps/update/tests/unit_service_updater/marFileLockedStageFailurePartialSvc_win.js
+++ b/toolkit/mozapps/update/tests/unit_service_updater/marFileLockedStageFailurePartialSvc_win.js
@@ -4,63 +4,59 @@
 
 /* File locked partial MAR file staged patch apply failure test */
 
+const STATE_AFTER_STAGE = IS_SERVICE_TEST ? STATE_PENDING : STATE_APPLYING;
+
 function run_test() {
-  if (!shouldRunServiceTest()) {
+  if (!setupTestCommon()) {
     return;
   }
-
-  gStageUpdate = true;
-  setupTestCommon();
   gTestFiles = gTestFilesPartialSuccess;
   gTestDirs = gTestDirsPartialSuccess;
   setTestFilesAndDirsForFailure();
-  setupUpdaterTest(FILE_PARTIAL_MAR);
-
-  // Exclusively lock an existing file so it is in use during the update.
-  let helperBin = getTestDirFile(FILE_HELPER_BIN);
-  let helperDestDir = getApplyDirFile(DIR_RESOURCES);
-  helperBin.copyTo(helperDestDir, FILE_HELPER_BIN);
-  helperBin = getApplyDirFile(DIR_RESOURCES + FILE_HELPER_BIN);
-  // Strip off the first two directories so the path has to be from the helper's
-  // working directory.
-  let lockFileRelPath = gTestFiles[2].relPathDir.split("/");
-  if (IS_MACOSX) {
-    lockFileRelPath = lockFileRelPath.slice(2);
-  }
-  lockFileRelPath = lockFileRelPath.join("/") + "/" + gTestFiles[2].fileName;
-  let args = [getApplyDirPath() + DIR_RESOURCES, "input", "output", "-s",
-              HELPER_SLEEP_TIMEOUT, lockFileRelPath];
-  let lockFileProcess = Cc["@mozilla.org/process/util;1"].
-                        createInstance(Ci.nsIProcess);
-  lockFileProcess.init(helperBin);
-  lockFileProcess.run(false, args, args.length);
-
-  setupAppFilesAsync();
+  setupUpdaterTest(FILE_PARTIAL_MAR, false);
 }
 
-function setupAppFilesFinished() {
-  do_timeout(TEST_HELPER_TIMEOUT, waitForHelperSleep);
+/**
+ * Called after the call to setupUpdaterTest finishes.
+ */
+function setupUpdaterTestFinished() {
+  runHelperLockFile(gTestFiles[2]);
 }
 
-function doUpdate() {
-  runUpdateUsingService(STATE_PENDING_SVC, STATE_FAILED_WRITE_ERROR_FILE_COPY);
+/**
+ * Called after the call to waitForHelperSleep finishes.
+ */
+function waitForHelperSleepFinished() {
+  stageUpdate();
 }
 
-function checkUpdateFinished() {
+/**
+ * Called after the call to stageUpdate finishes.
+ */
+function stageUpdateFinished() {
+  checkPostUpdateRunningFile(false);
+  // Files aren't checked after staging since this test locks a file which
+  // prevents reading the file.
+  checkUpdateLogContains(ERR_ENSURE_COPY);
   // Switch the application to the staged application that was updated.
-  gStageUpdate = false;
-  gSwitchApp = true;
-  runUpdate(1, STATE_PENDING, checkUpdateApplied);
+  runUpdate(STATE_FAILED_READ_ERROR, false, 1, false);
 }
 
-function checkUpdateApplied() {
-  setupHelperFinish();
+/**
+ * Called after the call to runUpdate finishes.
+ */
+function runUpdateFinished() {
+  waitForHelperExit();
 }
 
-function checkUpdate() {
-  checkFilesAfterUpdateFailure(getApplyDirFile, false, false);
-  checkUpdateLogContains(ERR_RENAME_FILE);
-  checkUpdateLogContains(ERR_MOVE_DESTDIR_7);
+/**
+ * Called after the call to waitForHelperExit finishes.
+ */
+function waitForHelperExitFinished() {
   standardInit();
-  checkCallbackAppLog();
+  checkPostUpdateRunningFile(false);
+  checkFilesAfterUpdateFailure(getApplyDirFile);
+  checkUpdateLogContains(ERR_UNABLE_OPEN_DEST);
+  checkUpdateLogContains(STATE_FAILED_READ_ERROR + "\n" + CALL_QUIT);
+  checkCallbackLog();
 }
diff --git a/toolkit/mozapps/update/tests/unit_service_updater/marRMRFDirFileInUseStageFailureCompleteSvc_win.js b/toolkit/mozapps/update/tests/unit_service_updater/marRMRFDirFileInUseStageFailureCompleteSvc_win.js
index 1d840e703ad7..ae494b5a33c0 100644
--- a/toolkit/mozapps/update/tests/unit_service_updater/marRMRFDirFileInUseStageFailureCompleteSvc_win.js
+++ b/toolkit/mozapps/update/tests/unit_service_updater/marRMRFDirFileInUseStageFailureCompleteSvc_win.js
@@ -5,64 +5,59 @@
 /* File in use inside removed dir complete MAR file staged patch apply failure
    test */
 
+const STATE_AFTER_STAGE = IS_SERVICE_TEST ? STATE_APPLIED_SVC : STATE_APPLIED;
+
 function run_test() {
-  if (!shouldRunServiceTest()) {
+  if (!setupTestCommon()) {
     return;
   }
-
-  gStageUpdate = true;
-  setupTestCommon();
   gTestFiles = gTestFilesCompleteSuccess;
   gTestDirs = gTestDirsCompleteSuccess;
-  setTestFilesAndDirsForFailure();
-  setupUpdaterTest(FILE_COMPLETE_MAR);
-
-  let fileInUseBin = getApplyDirFile(gTestDirs[4].relPathDir +
-                                     gTestDirs[4].subDirs[0] +
-                                     gTestDirs[4].subDirFiles[0]);
-  // Remove the empty file created for the test so the helper application can
-  // replace it.
-  fileInUseBin.remove(false);
-
-  let helperBin = getTestDirFile(FILE_HELPER_BIN);
-  let fileInUseDir = getApplyDirFile(gTestDirs[4].relPathDir +
-                                     gTestDirs[4].subDirs[0]);
-  helperBin.copyTo(fileInUseDir, gTestDirs[4].subDirFiles[0]);
-
-  // Launch an existing file so it is in use during the update.
-  let args = [getApplyDirPath() + DIR_RESOURCES, "input", "output", "-s",
-              HELPER_SLEEP_TIMEOUT];
-  let fileInUseProcess = Cc["@mozilla.org/process/util;1"].
-                         createInstance(Ci.nsIProcess);
-  fileInUseProcess.init(fileInUseBin);
-  fileInUseProcess.run(false, args, args.length);
-
-  setupAppFilesAsync();
+  setupUpdaterTest(FILE_COMPLETE_MAR, false);
 }
 
-function setupAppFilesFinished() {
-  do_timeout(TEST_HELPER_TIMEOUT, waitForHelperSleep);
+/**
+ * Called after the call to setupUpdaterTest finishes.
+ */
+function setupUpdaterTestFinished() {
+  runHelperFileInUse(gTestDirs[4].relPathDir + gTestDirs[4].subDirs[0] +
+                     gTestDirs[4].subDirFiles[0], true);
 }
 
-function doUpdate() {
-  runUpdateUsingService(STATE_PENDING_SVC, STATE_APPLIED);
+/**
+ * Called after the call to waitForHelperSleep finishes.
+ */
+function waitForHelperSleepFinished() {
+  stageUpdate();
 }
 
-function checkUpdateFinished() {
+/**
+ * Called after the call to stageUpdate finishes.
+ */
+function stageUpdateFinished() {
+  checkPostUpdateRunningFile(false);
+  checkFilesAfterUpdateSuccess(getStageDirFile, true);
+  checkUpdateLogContents(LOG_COMPLETE_SUCCESS_STAGE, true);
   // Switch the application to the staged application that was updated.
-  gStageUpdate = false;
-  gSwitchApp = true;
-  runUpdate(1, STATE_PENDING, checkUpdateApplied);
+  runUpdate(STATE_PENDING, true, 1, false);
 }
 
-function checkUpdateApplied() {
-  setupHelperFinish();
+/**
+ * Called after the call to runUpdate finishes.
+ */
+function runUpdateFinished() {
+  waitForHelperExit();
 }
 
-function checkUpdate() {
-  checkFilesAfterUpdateFailure(getApplyDirFile, false, false);
+/**
+ * Called after the call to waitForHelperExit finishes.
+ */
+function waitForHelperExitFinished() {
+  standardInit();
+  checkPostUpdateRunningFile(false);
+  setTestFilesAndDirsForFailure();
+  checkFilesAfterUpdateFailure(getApplyDirFile);
   checkUpdateLogContains(ERR_RENAME_FILE);
   checkUpdateLogContains(ERR_MOVE_DESTDIR_7);
-  standardInit();
-  checkCallbackAppLog();
+  checkCallbackLog();
 }
diff --git a/toolkit/mozapps/update/tests/unit_service_updater/marRMRFDirFileInUseStageFailurePartialSvc_win.js b/toolkit/mozapps/update/tests/unit_service_updater/marRMRFDirFileInUseStageFailurePartialSvc_win.js
index 4073410eb531..bc2d94360e7f 100644
--- a/toolkit/mozapps/update/tests/unit_service_updater/marRMRFDirFileInUseStageFailurePartialSvc_win.js
+++ b/toolkit/mozapps/update/tests/unit_service_updater/marRMRFDirFileInUseStageFailurePartialSvc_win.js
@@ -5,62 +5,58 @@
 /* File in use inside removed dir partial MAR file staged patch apply failure
    test */
 
+const STATE_AFTER_STAGE = IS_SERVICE_TEST ? STATE_APPLIED_SVC : STATE_APPLIED;
+
 function run_test() {
-  if (!shouldRunServiceTest()) {
+  if (!setupTestCommon()) {
     return;
   }
-
-  gStageUpdate = true;
-  setupTestCommon();
   gTestFiles = gTestFilesPartialSuccess;
   gTestDirs = gTestDirsPartialSuccess;
-  setTestFilesAndDirsForFailure();
-  setupUpdaterTest(FILE_PARTIAL_MAR);
-
-  let fileInUseBin = getApplyDirFile(gTestDirs[2].relPathDir +
-                                     gTestDirs[2].files[0]);
-  // Remove the empty file created for the test so the helper application can
-  // replace it.
-  fileInUseBin.remove(false);
-
-  let helperBin = getTestDirFile(FILE_HELPER_BIN);
-  let fileInUseDir = getApplyDirFile(gTestDirs[2].relPathDir);
-  helperBin.copyTo(fileInUseDir, gTestDirs[2].files[0]);
-
-  // Launch an existing file so it is in use during the update.
-  let args = [getApplyDirPath() + DIR_RESOURCES, "input", "output", "-s",
-              HELPER_SLEEP_TIMEOUT];
-  let fileInUseProcess = Cc["@mozilla.org/process/util;1"].
-                         createInstance(Ci.nsIProcess);
-  fileInUseProcess.init(fileInUseBin);
-  fileInUseProcess.run(false, args, args.length);
-
-  setupAppFilesAsync();
+  setupUpdaterTest(FILE_PARTIAL_MAR, false);
 }
 
-function setupAppFilesFinished() {
-  do_timeout(TEST_HELPER_TIMEOUT, waitForHelperSleep);
+/**
+ * Called after the call to setupUpdaterTest finishes.
+ */
+function setupUpdaterTestFinished() {
+  runHelperFileInUse(gTestDirs[2].relPathDir + gTestDirs[2].files[0], true);
 }
 
-function doUpdate() {
-  runUpdateUsingService(STATE_PENDING_SVC, STATE_APPLIED);
+/**
+ * Called after the call to waitForHelperSleep finishes.
+ */
+function waitForHelperSleepFinished() {
+  stageUpdate();
 }
 
-function checkUpdateFinished() {
+/**
+ * Called after the call to stageUpdate finishes.
+ */
+function stageUpdateFinished() {
+  checkPostUpdateRunningFile(false);
+  checkFilesAfterUpdateSuccess(getStageDirFile, true);
+  checkUpdateLogContents(LOG_PARTIAL_SUCCESS_STAGE, true);
   // Switch the application to the staged application that was updated.
-  gStageUpdate = false;
-  gSwitchApp = true;
-  runUpdate(1, STATE_PENDING, checkUpdateApplied);
+  runUpdate(STATE_PENDING, true, 1, false);
 }
 
-function checkUpdateApplied() {
-  setupHelperFinish();
+/**
+ * Called after the call to runUpdate finishes.
+ */
+function runUpdateFinished() {
+  waitForHelperExit();
 }
 
-function checkUpdate() {
-  checkFilesAfterUpdateFailure(getApplyDirFile, false, false);
+/**
+ * Called after the call to waitForHelperExit finishes.
+ */
+function waitForHelperExitFinished() {
+  standardInit();
+  checkPostUpdateRunningFile(false);
+  setTestFilesAndDirsForFailure();
+  checkFilesAfterUpdateFailure(getApplyDirFile);
   checkUpdateLogContains(ERR_RENAME_FILE);
   checkUpdateLogContains(ERR_MOVE_DESTDIR_7);
-  standardInit();
-  checkCallbackAppLog();
+  checkCallbackLog();
 }
diff --git a/toolkit/mozapps/update/tests/unit_service_updater/marRMRFDirFileInUseSuccessCompleteSvc_win.js b/toolkit/mozapps/update/tests/unit_service_updater/marRMRFDirFileInUseSuccessCompleteSvc_win.js
index a46caeca7dc6..ea2dd69597b0 100644
--- a/toolkit/mozapps/update/tests/unit_service_updater/marRMRFDirFileInUseSuccessCompleteSvc_win.js
+++ b/toolkit/mozapps/update/tests/unit_service_updater/marRMRFDirFileInUseSuccessCompleteSvc_win.js
@@ -5,53 +5,50 @@
 /* File in use inside removed dir complete MAR file patch apply success test */
 
 function run_test() {
-  if (!shouldRunServiceTest()) {
+  if (!setupTestCommon()) {
     return;
   }
-
-  setupTestCommon();
   gTestFiles = gTestFilesCompleteSuccess;
   gTestDirs = gTestDirsCompleteSuccess;
-  setupUpdaterTest(FILE_COMPLETE_MAR);
-
-  let fileInUseBin = getApplyDirFile(gTestDirs[4].relPathDir +
-                                     gTestDirs[4].subDirs[0] +
-                                     gTestDirs[4].subDirFiles[0]);
-  // Remove the empty file created for the test so the helper application can
-  // replace it.
-  fileInUseBin.remove(false);
-
-  let helperBin = getTestDirFile(FILE_HELPER_BIN);
-  let fileInUseDir = getApplyDirFile(gTestDirs[4].relPathDir +
-                                     gTestDirs[4].subDirs[0]);
-  helperBin.copyTo(fileInUseDir, gTestDirs[4].subDirFiles[0]);
-
-  // Launch an existing file so it is in use during the update.
-  let args = [getApplyDirPath() + DIR_RESOURCES, "input", "output", "-s",
-              HELPER_SLEEP_TIMEOUT];
-  let fileInUseProcess = Cc["@mozilla.org/process/util;1"].
-                         createInstance(Ci.nsIProcess);
-  fileInUseProcess.init(fileInUseBin);
-  fileInUseProcess.run(false, args, args.length);
-
-  setupAppFilesAsync();
+  setupUpdaterTest(FILE_COMPLETE_MAR, false);
 }
 
-function setupAppFilesFinished() {
-  do_timeout(TEST_HELPER_TIMEOUT, waitForHelperSleep);
+/**
+ * Called after the call to setupUpdaterTest finishes.
+ */
+function setupUpdaterTestFinished() {
+  runHelperFileInUse(gTestDirs[4].relPathDir + gTestDirs[4].subDirs[0] +
+                     gTestDirs[4].subDirFiles[0], true);
 }
 
-function doUpdate() {
-  runUpdateUsingService(STATE_PENDING_SVC, STATE_SUCCEEDED);
+/**
+ * Called after the call to waitForHelperSleep finishes.
+ */
+function waitForHelperSleepFinished() {
+  runUpdate(STATE_SUCCEEDED, false, 0, true);
 }
 
-function checkUpdateFinished() {
-  setupHelperFinish();
+/**
+ * Called after the call to runUpdate finishes.
+ */
+function runUpdateFinished() {
+  waitForHelperExit();
 }
 
-function checkUpdate() {
+/**
+ * Called after the call to waitForHelperExit finishes.
+ */
+function waitForHelperExitFinished() {
+  checkPostUpdateAppLog();
+}
+
+/**
+ * Called after the call to checkPostUpdateAppLog finishes.
+ */
+function checkPostUpdateAppLogFinished() {
+  standardInit();
+  checkPostUpdateRunningFile(true);
   checkFilesAfterUpdateSuccess(getApplyDirFile, false, true);
   checkUpdateLogContains(ERR_BACKUP_DISCARD);
-  standardInit();
-  checkCallbackServiceLog();
+  checkCallbackLog();
 }
diff --git a/toolkit/mozapps/update/tests/unit_service_updater/marRMRFDirFileInUseSuccessPartialSvc_win.js b/toolkit/mozapps/update/tests/unit_service_updater/marRMRFDirFileInUseSuccessPartialSvc_win.js
index 04f71aab190d..a998fe6c4b7c 100644
--- a/toolkit/mozapps/update/tests/unit_service_updater/marRMRFDirFileInUseSuccessPartialSvc_win.js
+++ b/toolkit/mozapps/update/tests/unit_service_updater/marRMRFDirFileInUseSuccessPartialSvc_win.js
@@ -5,51 +5,49 @@
 /* File in use inside removed dir partial MAR file patch apply success test */
 
 function run_test() {
-  if (!shouldRunServiceTest()) {
+  if (!setupTestCommon()) {
     return;
   }
-
-  setupTestCommon();
   gTestFiles = gTestFilesPartialSuccess;
   gTestDirs = gTestDirsPartialSuccess;
-  setupUpdaterTest(FILE_PARTIAL_MAR);
-
-  let fileInUseBin = getApplyDirFile(gTestDirs[2].relPathDir +
-                                     gTestDirs[2].files[0]);
-  // Remove the empty file created for the test so the helper application can
-  // replace it.
-  fileInUseBin.remove(false);
-
-  let helperBin = getTestDirFile(FILE_HELPER_BIN);
-  let fileInUseDir = getApplyDirFile(gTestDirs[2].relPathDir);
-  helperBin.copyTo(fileInUseDir, gTestDirs[2].files[0]);
-
-  // Launch an existing file so it is in use during the update.
-  let args = [getApplyDirPath() + DIR_RESOURCES, "input", "output", "-s",
-              HELPER_SLEEP_TIMEOUT];
-  let fileInUseProcess = Cc["@mozilla.org/process/util;1"].
-                         createInstance(Ci.nsIProcess);
-  fileInUseProcess.init(fileInUseBin);
-  fileInUseProcess.run(false, args, args.length);
-
-  setupAppFilesAsync();
+  setupUpdaterTest(FILE_PARTIAL_MAR, false);
 }
 
-function setupAppFilesFinished() {
-  do_timeout(TEST_HELPER_TIMEOUT, waitForHelperSleep);
+/**
+ * Called after the call to setupUpdaterTest finishes.
+ */
+function setupUpdaterTestFinished() {
+  runHelperFileInUse(gTestDirs[2].relPathDir + gTestDirs[2].files[0], true);
 }
 
-function doUpdate() {
-  runUpdateUsingService(STATE_PENDING_SVC, STATE_SUCCEEDED);
+/**
+ * Called after the call to waitForHelperSleep finishes.
+ */
+function waitForHelperSleepFinished() {
+  runUpdate(STATE_SUCCEEDED, false, 0, true);
 }
 
-function checkUpdateFinished() {
-  setupHelperFinish();
+/**
+ * Called after the call to runUpdate finishes.
+ */
+function runUpdateFinished() {
+  waitForHelperExit();
 }
 
-function checkUpdate() {
+/**
+ * Called after the call to waitForHelperExit finishes.
+ */
+function waitForHelperExitFinished() {
+  checkPostUpdateAppLog();
+}
+
+/**
+ * Called after the call to checkPostUpdateAppLog finishes.
+ */
+function checkPostUpdateAppLogFinished() {
+  standardInit();
+  checkPostUpdateRunningFile(true);
   checkFilesAfterUpdateSuccess(getApplyDirFile, false, true);
   checkUpdateLogContains(ERR_BACKUP_DISCARD);
-  standardInit();
-  checkCallbackServiceLog();
+  checkCallbackLog();
 }
diff --git a/toolkit/mozapps/update/tests/unit_service_updater/marStageFailurePartialSvc.js b/toolkit/mozapps/update/tests/unit_service_updater/marStageFailurePartialSvc.js
index 20e15da77941..e4c6280dc4fe 100644
--- a/toolkit/mozapps/update/tests/unit_service_updater/marStageFailurePartialSvc.js
+++ b/toolkit/mozapps/update/tests/unit_service_updater/marStageFailurePartialSvc.js
@@ -5,37 +5,33 @@
 
 /* General Partial MAR File Staged Patch Apply Failure Test */
 
+const STATE_AFTER_STAGE = IS_SERVICE_TEST ? STATE_PENDING : STATE_APPLYING;
+
 function run_test() {
-  if (!shouldRunServiceTest()) {
+  if (!setupTestCommon()) {
     return;
   }
-
-  gStageUpdate = true;
-  setupTestCommon();
   gTestFiles = gTestFilesPartialSuccess;
   gTestFiles[11].originalFile = "partial.png";
   gTestDirs = gTestDirsPartialSuccess;
   setTestFilesAndDirsForFailure();
-  setupUpdaterTest(FILE_PARTIAL_MAR);
-
-  createUpdaterINI(true);
-
-  setupAppFilesAsync();
-}
-
-function setupAppFilesFinished() {
-  runUpdateUsingService(STATE_PENDING_SVC,
-                        STATE_FAILED_LOADSOURCE_ERROR_WRONG_SIZE);
+  setupUpdaterTest(FILE_PARTIAL_MAR, false);
 }
 
 /**
- * Checks if the update has finished and if it has finished performs checks for
- * the test.
+ * Called after the call to setupUpdaterTest finishes.
  */
-function checkUpdateFinished() {
-  checkPostUpdateRunningFile(false);
-  checkFilesAfterUpdateFailure(getApplyDirFile, true, false);
-  checkUpdateLogContents(LOG_PARTIAL_FAILURE);
+function setupUpdaterTestFinished() {
+  stageUpdate();
+}
+
+/**
+ * Called after the call to stageUpdate finishes.
+ */
+function stageUpdateFinished() {
   standardInit();
+  checkPostUpdateRunningFile(false);
+  checkFilesAfterUpdateFailure(getApplyDirFile);
+  checkUpdateLogContains(ERR_LOADSOURCEFILE_FAILED);
   waitForFilesInUse();
 }
diff --git a/toolkit/mozapps/update/tests/unit_service_updater/marStageSuccessCompleteSvc.js b/toolkit/mozapps/update/tests/unit_service_updater/marStageSuccessCompleteSvc.js
index 0675853144d4..65b91ada288f 100644
--- a/toolkit/mozapps/update/tests/unit_service_updater/marStageSuccessCompleteSvc.js
+++ b/toolkit/mozapps/update/tests/unit_service_updater/marStageSuccessCompleteSvc.js
@@ -5,19 +5,65 @@
 
 /* General Complete MAR File Staged Patch Apply Test */
 
+const STATE_AFTER_STAGE = IS_SERVICE_TEST ? STATE_APPLIED_SVC : STATE_APPLIED;
+
 function run_test() {
-  if (!shouldRunServiceTest()) {
+  if (!setupTestCommon()) {
     return;
   }
-
-  gStageUpdate = true;
-  setupTestCommon();
   gTestFiles = gTestFilesCompleteSuccess;
   gTestFiles[gTestFiles.length - 1].originalContents = null;
   gTestFiles[gTestFiles.length - 1].compareContents = "FromComplete\n";
   gTestFiles[gTestFiles.length - 1].comparePerms = 0o644;
   gTestDirs = gTestDirsCompleteSuccess;
-  setupUpdaterTest(FILE_COMPLETE_MAR);
+  setupDistributionDir();
+  setupSymLinks();
+  setupUpdaterTest(FILE_COMPLETE_MAR, false);
+}
+
+/**
+ * Called after the call to setupUpdaterTest finishes.
+ */
+function setupUpdaterTestFinished() {
+  stageUpdate();
+}
+
+/**
+ * Called after the call to stageUpdate finishes.
+ */
+function stageUpdateFinished() {
+  checkPostUpdateRunningFile(false);
+  checkFilesAfterUpdateSuccess(getStageDirFile, true);
+  checkUpdateLogContents(LOG_COMPLETE_SUCCESS_STAGE, true);
+  // Switch the application to the staged application that was updated.
+  runUpdate(STATE_SUCCEEDED, true, 0, true);
+}
+
+/**
+ * Called after the call to runUpdate finishes.
+ */
+function runUpdateFinished() {
+  checkPostUpdateAppLog();
+}
+
+/**
+ * Called after the call to checkPostUpdateAppLog finishes.
+ */
+function checkPostUpdateAppLogFinished() {
+  checkAppBundleModTime();
+  checkSymLinks();
+  standardInit();
+  checkPostUpdateRunningFile(true);
+  checkFilesAfterUpdateSuccess(getApplyDirFile, false, true);
+  checkUpdateLogContents(LOG_REPLACE_SUCCESS, false, true);
+  checkDistributionDir();
+  checkCallbackLog();
+}
+
+/**
+ * Setup the state of the distribution directory for the test.
+ */
+function setupDistributionDir() {
   if (IS_MACOSX) {
     // Create files in the old distribution directory location to verify that
     // the directory and its contents are removed when there is a distribution
@@ -27,10 +73,24 @@ function run_test() {
     testFile = getApplyDirFile(DIR_MACOS + "distribution/test1/testFile", true);
     writeFile(testFile, "test\n");
   }
+}
 
-  createUpdaterINI(false);
-  setAppBundleModTime();
+/**
+ * Checks the state of the distribution directory for the test.
+ */
+function checkDistributionDir() {
+  if (IS_MACOSX) {
+    let distributionDir = getApplyDirFile(DIR_MACOS + "distribution", true);
+    Assert.ok(!distributionDir.exists(),
+              MSG_SHOULD_NOT_EXIST + getMsgPath(distributionDir.path));
+    checkUpdateLogContains(REMOVE_OLD_DIST_DIR);
+  }
+}
 
+/**
+ * Setup symlinks for the test.
+ */
+function setupSymLinks() {
   // Don't test symlinks on Mac OS X in this test since it tends to timeout.
   // It is tested on Mac OS X in marAppInUseStageSuccessComplete_unix.js
   // The tests don't support symlinks on gonk.
@@ -51,97 +111,14 @@ function run_test() {
       comparePerms     : 0o666
     });
   }
-
-  setupAppFilesAsync();
-}
-
-function setupAppFilesFinished() {
-  runUpdateUsingService(STATE_PENDING_SVC, STATE_APPLIED);
-}
-
-function checkUpdateFinished() {
-  checkFilesAfterUpdateSuccess(getStageDirFile, true, false);
-  checkUpdateLogContents(LOG_COMPLETE_SUCCESS);
-  checkPostUpdateRunningFile(false);
-
-  // Switch the application to the staged application that was updated.
-  gStageUpdate = false;
-  gSwitchApp = true;
-  do_timeout(TEST_CHECK_TIMEOUT, function() {
-    runUpdate(0, STATE_SUCCEEDED, checkUpdateApplied);
-  });
 }
 
 /**
- * Checks if the post update binary was properly launched for the platforms that
- * support launching post update process.
+ * Checks the state of the symlinks for the test.
  */
-function checkUpdateApplied() {
-  if (IS_WIN || IS_MACOSX) {
-    gCheckFunc = finishCheckUpdateApplied;
-    checkPostUpdateAppLog();
-  } else {
-    finishCheckUpdateApplied();
-  }
-}
-
-/**
- * Checks if the update has finished and if it has finished performs checks for
- * the test.
- */
-function finishCheckUpdateApplied() {
-  checkPostUpdateRunningFile(true);
-
-  if (IS_MACOSX) {
-    let distributionDir = getApplyDirFile(DIR_MACOS + "distribution", true);
-    Assert.ok(!distributionDir.exists(), MSG_SHOULD_NOT_EXIST);
-    checkUpdateLogContains("removing old distribution directory");
-  }
-
+function checkSymLinks() {
   // The tests don't support symlinks on gonk.
   if (IS_UNIX && !IS_MACOSX && !IS_TOOLKIT_GONK) {
     checkSymlink();
   }
-  checkAppBundleModTime();
-  checkFilesAfterUpdateSuccess(getApplyDirFile, false, false);
-  checkUpdateLogContents(LOG_COMPLETE_SUCCESS);
-  standardInit();
-  checkCallbackAppLog();
-}
-
-function runHelperProcess(args) {
-  let helperBin = getTestDirFile(FILE_HELPER_BIN);
-  let process = Cc["@mozilla.org/process/util;1"].
-                createInstance(Ci.nsIProcess);
-  process.init(helperBin);
-  debugDump("Running " + helperBin.path + " " + args.join(" "));
-  process.run(true, args, args.length);
-  Assert.equal(process.exitValue, 0,
-               "the helper process exit value should be 0");
-}
-
-function createSymlink() {
-  let args = ["setup-symlink", "moz-foo", "moz-bar", "target",
-              getApplyDirFile().path + "/" + DIR_RESOURCES + "link"];
-  runHelperProcess(args);
-  getApplyDirFile(DIR_RESOURCES + "link", false).permissions = 0o666;
-
-  args = ["setup-symlink", "moz-foo2", "moz-bar2", "target2",
-          getApplyDirFile().path + "/" + DIR_RESOURCES + "link2", "change-perm"];
-  runHelperProcess(args);
-}
-
-function removeSymlink() {
-  let args = ["remove-symlink", "moz-foo", "moz-bar", "target",
-              getApplyDirFile().path + "/" + DIR_RESOURCES + "link"];
-  runHelperProcess(args);
-  args = ["remove-symlink", "moz-foo2", "moz-bar2", "target2",
-          getApplyDirFile().path + "/" + DIR_RESOURCES + "link2"];
-  runHelperProcess(args);
-}
-
-function checkSymlink() {
-  let args = ["check-symlink",
-              getApplyDirFile().path + "/" + DIR_RESOURCES + "link"];
-  runHelperProcess(args);
 }
diff --git a/toolkit/mozapps/update/tests/unit_service_updater/marStageSuccessPartialSvc.js b/toolkit/mozapps/update/tests/unit_service_updater/marStageSuccessPartialSvc.js
index db867ac53526..436555db035c 100644
--- a/toolkit/mozapps/update/tests/unit_service_updater/marStageSuccessPartialSvc.js
+++ b/toolkit/mozapps/update/tests/unit_service_updater/marStageSuccessPartialSvc.js
@@ -5,20 +5,64 @@
 
 /* General Partial MAR File Staged Patch Apply Test */
 
+const STATE_AFTER_STAGE = IS_SERVICE_TEST ? STATE_APPLIED_SVC : STATE_APPLIED;
+
 function run_test() {
-  if (!shouldRunServiceTest()) {
+  if (!setupTestCommon()) {
     return;
   }
-
-  gStageUpdate = true;
-  setupTestCommon();
   gTestFiles = gTestFilesPartialSuccess;
   gTestFiles[gTestFiles.length - 2].originalContents = null;
   gTestFiles[gTestFiles.length - 2].compareContents = "FromPartial\n";
   gTestFiles[gTestFiles.length - 2].comparePerms = 0o644;
   gTestDirs = gTestDirsPartialSuccess;
   preventDistributionFiles();
-  setupUpdaterTest(FILE_PARTIAL_MAR);
+  setupDistributionDir();
+  setupUpdaterTest(FILE_PARTIAL_MAR, true);
+}
+
+/**
+ * Called after the call to setupUpdaterTest finishes.
+ */
+function setupUpdaterTestFinished() {
+  stageUpdate();
+}
+
+/**
+ * Called after the call to stageUpdate finishes.
+ */
+function stageUpdateFinished() {
+  checkPostUpdateRunningFile(false);
+  checkFilesAfterUpdateSuccess(getStageDirFile, true);
+  checkUpdateLogContents(LOG_PARTIAL_SUCCESS_STAGE, true, false, true);
+  // Switch the application to the staged application that was updated.
+  runUpdate(STATE_SUCCEEDED, true, 0, false);
+}
+
+/**
+ * Called after the call to runUpdate finishes.
+ */
+function runUpdateFinished() {
+  checkPostUpdateAppLog();
+}
+
+/**
+ * Called after the call to checkPostUpdateAppLog finishes.
+ */
+function checkPostUpdateAppLogFinished() {
+  checkAppBundleModTime();
+  standardInit();
+  checkPostUpdateRunningFile(true);
+  checkFilesAfterUpdateSuccess(getApplyDirFile, false, true);
+  checkUpdateLogContents(LOG_REPLACE_SUCCESS, false, true, true);
+  checkDistributionDir();
+  checkCallbackLog();
+}
+
+/**
+ * Setup the state of the distribution directory for the test.
+ */
+function setupDistributionDir() {
   if (IS_MACOSX) {
     // Create files in the old distribution directory location to verify that
     // the directory and its contents are moved to the new location on update.
@@ -27,73 +71,34 @@ function run_test() {
     testFile = getApplyDirFile(DIR_MACOS + "distribution/test/testFile", true);
     writeFile(testFile, "test\n");
   }
-
-  createUpdaterINI(false);
-  setAppBundleModTime();
-
-  setupAppFilesAsync();
-}
-
-function setupAppFilesFinished() {
-  runUpdateUsingService(STATE_PENDING_SVC, STATE_APPLIED);
-}
-
-function checkUpdateFinished() {
-  checkFilesAfterUpdateSuccess(getStageDirFile, true, false);
-  checkUpdateLogContents(LOG_PARTIAL_SUCCESS, true);
-  checkPostUpdateRunningFile(false);
-
-  // Switch the application to the staged application that was updated.
-  gStageUpdate = false;
-  gSwitchApp = true;
-  do_timeout(TEST_CHECK_TIMEOUT, function() {
-    runUpdate(0, STATE_SUCCEEDED, checkUpdateApplied);
-  });
 }
 
 /**
- * Checks if the post update binary was properly launched for the platforms that
- * support launching post update process.
+ * Checks the state of the distribution directory.
  */
-function checkUpdateApplied() {
-  if (IS_WIN || IS_MACOSX) {
-    gCheckFunc = finishCheckUpdateApplied;
-    checkPostUpdateAppLog();
-  } else {
-    finishCheckUpdateApplied();
-  }
-}
-
-/**
- * Checks if the update has finished and if it has finished performs checks for
- * the test.
- */
-function finishCheckUpdateApplied() {
-  checkPostUpdateRunningFile(true);
-
+function checkDistributionDir() {
   let distributionDir = getApplyDirFile(DIR_RESOURCES + "distribution", true);
   if (IS_MACOSX) {
-    Assert.ok(distributionDir.exists(), MSG_SHOULD_EXIST);
+    Assert.ok(distributionDir.exists(),
+              MSG_SHOULD_EXIST + getMsgPath(distributionDir.path));
 
     let testFile = getApplyDirFile(DIR_RESOURCES + "distribution/testFile", true);
-    Assert.ok(testFile.exists(), MSG_SHOULD_EXIST);
+    Assert.ok(testFile.exists(),
+              MSG_SHOULD_EXIST + getMsgPath(testFile.path));
 
     testFile = getApplyDirFile(DIR_RESOURCES + "distribution/test/testFile", true);
-    Assert.ok(testFile.exists(), MSG_SHOULD_EXIST);
+    Assert.ok(testFile.exists(),
+              MSG_SHOULD_EXIST + getMsgPath(testFile.path));
 
     distributionDir = getApplyDirFile(DIR_MACOS + "distribution", true);
-    Assert.ok(!distributionDir.exists(), MSG_SHOULD_NOT_EXIST);
+    Assert.ok(!distributionDir.exists(),
+              MSG_SHOULD_NOT_EXIST + getMsgPath(distributionDir.path));
 
-    checkUpdateLogContains("Moving old distribution directory to new location");
+    checkUpdateLogContains(MOVE_OLD_DIST_DIR);
   } else {
     debugDump("testing that files aren't added with an add-if instruction " +
               "when the file's destination directory doesn't exist");
-    Assert.ok(!distributionDir.exists(), MSG_SHOULD_NOT_EXIST);
+    Assert.ok(!distributionDir.exists(),
+              MSG_SHOULD_NOT_EXIST + getMsgPath(distributionDir.path));
   }
-
-  checkAppBundleModTime();
-  checkFilesAfterUpdateSuccess(getApplyDirFile, false, false);
-  checkUpdateLogContents(LOG_PARTIAL_SUCCESS, true);
-  standardInit();
-  checkCallbackAppLog();
 }
diff --git a/toolkit/mozapps/update/tests/unit_service_updater/marSuccessCompleteSvc.js b/toolkit/mozapps/update/tests/unit_service_updater/marSuccessCompleteSvc.js
index 8fb4f169fe75..4271e41aa68c 100644
--- a/toolkit/mozapps/update/tests/unit_service_updater/marSuccessCompleteSvc.js
+++ b/toolkit/mozapps/update/tests/unit_service_updater/marSuccessCompleteSvc.js
@@ -6,15 +6,47 @@
 /* General Complete MAR File Patch Apply Test */
 
 function run_test() {
-  if (!shouldRunServiceTest()) {
+  if (!setupTestCommon()) {
     return;
   }
-
-  setupTestCommon();
   gTestFiles = gTestFilesCompleteSuccess;
   gTestDirs = gTestDirsCompleteSuccess;
   preventDistributionFiles();
-  setupUpdaterTest(FILE_COMPLETE_MAR);
+  setupDistributionDir();
+  setupUpdaterTest(FILE_COMPLETE_MAR, true);
+}
+
+/**
+ * Called after the call to setupUpdaterTest finishes.
+ */
+function setupUpdaterTestFinished() {
+  runUpdate(STATE_SUCCEEDED, false, 0, true);
+}
+
+/**
+ * Called after the call to runUpdate finishes.
+ */
+function runUpdateFinished() {
+  checkPostUpdateAppLog();
+}
+
+/**
+ * Called after the call to checkPostUpdateAppLog finishes.
+ */
+function checkPostUpdateAppLogFinished() {
+  checkAppBundleModTime();
+  standardInit();
+  checkPostUpdateRunningFile(true);
+  checkFilesAfterUpdateSuccess(getApplyDirFile);
+  checkUpdateLogContents(LOG_COMPLETE_SUCCESS, false, false, true);
+  checkDistributionDir();
+  checkCallbackLog();
+}
+
+/**
+ * Setup the state of the distribution directory for the test.
+ */
+function setupDistributionDir() {
   if (IS_MACOSX) {
     // Create files in the old distribution directory location to verify that
     // the directory and its contents are moved to the new location on update.
@@ -23,58 +55,34 @@ function run_test() {
     testFile = getApplyDirFile(DIR_MACOS + "distribution/test/testFile", true);
     writeFile(testFile, "test\n");
   }
-
-  createUpdaterINI();
-  setAppBundleModTime();
-
-  setupAppFilesAsync();
-}
-
-function setupAppFilesFinished() {
-  runUpdateUsingService(STATE_PENDING_SVC, STATE_SUCCEEDED);
 }
 
 /**
- * Checks if the post update binary was properly launched for the platforms that
- * support launching post update process.
+ * Checks the state of the distribution directory.
  */
-function checkUpdateFinished() {
-  if (IS_WIN || IS_MACOSX) {
-    gCheckFunc = finishCheckUpdateFinished;
-    checkPostUpdateAppLog();
-  } else {
-    finishCheckUpdateFinished();
-  }
-}
-
-/**
- * Checks if the update has finished and if it has finished performs checks for
- * the test.
- */
-function finishCheckUpdateFinished() {
+function checkDistributionDir() {
   let distributionDir = getApplyDirFile(DIR_RESOURCES + "distribution", true);
   if (IS_MACOSX) {
-    Assert.ok(distributionDir.exists(), MSG_SHOULD_EXIST);
+    Assert.ok(distributionDir.exists(),
+              MSG_SHOULD_EXIST + getMsgPath(distributionDir.path));
 
     let testFile = getApplyDirFile(DIR_RESOURCES + "distribution/testFile", true);
-    Assert.ok(testFile.exists(), MSG_SHOULD_EXIST);
+    Assert.ok(testFile.exists(),
+              MSG_SHOULD_EXIST + getMsgPath(testFile.path));
 
     testFile = getApplyDirFile(DIR_RESOURCES + "distribution/test/testFile", true);
-    Assert.ok(testFile.exists(), MSG_SHOULD_EXIST);
+    Assert.ok(testFile.exists(),
+              MSG_SHOULD_EXIST + getMsgPath(testFile.path));
 
     distributionDir = getApplyDirFile(DIR_MACOS + "distribution", true);
-    Assert.ok(!distributionDir.exists(), MSG_SHOULD_NOT_EXIST);
+    Assert.ok(!distributionDir.exists(),
+              MSG_SHOULD_NOT_EXIST + getMsgPath(distributionDir.path));
 
-    checkUpdateLogContains("Moving old distribution directory to new location");
+    checkUpdateLogContains(MOVE_OLD_DIST_DIR);
   } else {
     debugDump("testing that files aren't added with an add-if instruction " +
               "when the file's destination directory doesn't exist");
-    Assert.ok(!distributionDir.exists(), MSG_SHOULD_NOT_EXIST);
+    Assert.ok(!distributionDir.exists(),
+              MSG_SHOULD_NOT_EXIST + getMsgPath(distributionDir.path));
   }
-
-  checkAppBundleModTime();
-  checkFilesAfterUpdateSuccess(getApplyDirFile, false, false);
-  checkUpdateLogContents(LOG_COMPLETE_SUCCESS, true);
-  standardInit();
-  checkCallbackServiceLog();
 }
diff --git a/toolkit/mozapps/update/tests/unit_service_updater/marSuccessPartialSvc.js b/toolkit/mozapps/update/tests/unit_service_updater/marSuccessPartialSvc.js
index 56e7e1ea5a52..c96c1b6b6299 100644
--- a/toolkit/mozapps/update/tests/unit_service_updater/marSuccessPartialSvc.js
+++ b/toolkit/mozapps/update/tests/unit_service_updater/marSuccessPartialSvc.js
@@ -6,11 +6,9 @@
 /* General Partial MAR File Patch Apply Test */
 
 function run_test() {
-  if (!shouldRunServiceTest()) {
+  if (!setupTestCommon()) {
     return;
   }
-
-  setupTestCommon();
   gTestFiles = gTestFilesPartialSuccess;
   gTestFiles[gTestFiles.length - 1].originalContents = null;
   gTestFiles[gTestFiles.length - 1].compareContents = "FromPartial\n";
@@ -19,7 +17,41 @@ function run_test() {
   gTestFiles[gTestFiles.length - 2].compareContents = "FromPartial\n";
   gTestFiles[gTestFiles.length - 2].comparePerms = 0o644;
   gTestDirs = gTestDirsPartialSuccess;
-  setupUpdaterTest(FILE_PARTIAL_MAR);
+  setupDistributionDir();
+  setupUpdaterTest(FILE_PARTIAL_MAR, false);
+}
+
+/**
+ * Called after the call to setupUpdaterTest finishes.
+ */
+function setupUpdaterTestFinished() {
+  runUpdate(STATE_SUCCEEDED, false, 0, true);
+}
+
+/**
+ * Called after the call to runUpdate finishes.
+ */
+function runUpdateFinished() {
+  checkPostUpdateAppLog();
+}
+
+/**
+ * Called after the call to checkPostUpdateAppLog finishes.
+ */
+function checkPostUpdateAppLogFinished() {
+  checkAppBundleModTime();
+  standardInit();
+  checkPostUpdateRunningFile(true);
+  checkFilesAfterUpdateSuccess(getApplyDirFile);
+  checkUpdateLogContents(LOG_PARTIAL_SUCCESS);
+  checkDistributionDir();
+  checkCallbackLog();
+}
+
+/**
+ * Setup the state of the distribution directory for the test.
+ */
+function setupDistributionDir() {
   if (IS_MACOSX) {
     // Create files in the old distribution directory location to verify that
     // the directory and its contents are removed when there is a distribution
@@ -29,44 +61,16 @@ function run_test() {
     testFile = getApplyDirFile(DIR_MACOS + "distribution/test/testFile", true);
     writeFile(testFile, "test\n");
   }
-
-  createUpdaterINI(true);
-  setAppBundleModTime();
-
-  setupAppFilesAsync();
-}
-
-function setupAppFilesFinished() {
-  runUpdateUsingService(STATE_PENDING_SVC, STATE_SUCCEEDED);
 }
 
 /**
- * Checks if the post update binary was properly launched for the platforms that
- * support launching post update process.
+ * Checks the state of the distribution directory.
  */
-function checkUpdateFinished() {
-  if (IS_WIN || IS_MACOSX) {
-    gCheckFunc = finishCheckUpdateFinished;
-    checkPostUpdateAppLog();
-  } else {
-    finishCheckUpdateFinished();
-  }
-}
-
-/**
- * Checks if the update has finished and if it has finished performs checks for
- * the test.
- */
-function finishCheckUpdateFinished() {
+function checkDistributionDir() {
   if (IS_MACOSX) {
     let distributionDir = getApplyDirFile(DIR_MACOS + "distribution", true);
-    Assert.ok(!distributionDir.exists(), MSG_SHOULD_NOT_EXIST);
-    checkUpdateLogContains("removing old distribution directory");
+    Assert.ok(!distributionDir.exists(),
+              MSG_SHOULD_NOT_EXIST + getMsgPath(distributionDir.path));
+    checkUpdateLogContains(REMOVE_OLD_DIST_DIR);
   }
-
-  checkAppBundleModTime();
-  checkFilesAfterUpdateSuccess(getApplyDirFile, false, false);
-  checkUpdateLogContents(LOG_PARTIAL_SUCCESS);
-  standardInit();
-  checkCallbackServiceLog();
 }