Backed out changeset ce357b802532 (bug 1046841) for merge conflicts with bug 977026.
authorRyan VanderMeulen <ryanvm@gmail.com>
Fri, 01 Aug 2014 16:00:35 -0400
changeset 197533 b31b3ee2b42fee8734831db7f674480120600039
parent 197532 ceb3128f93e96ebf82e993467c2ff96e47187010
child 197534 a628362a2af87368070dd9ffbfd973f21b5709dd
push id27249
push userryanvm@gmail.com
push dateMon, 04 Aug 2014 20:14:35 +0000
treeherdermozilla-central@7f81be7db528 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
bugs1046841, 977026
milestone34.0a1
backs outce357b8025322b604378ce1cad35c55b5c7b4268
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Backed out changeset ce357b802532 (bug 1046841) for merge conflicts with bug 977026.
xpcom/components/ManifestParser.cpp
xpcom/components/ManifestParser.h
xpcom/components/Module.h
xpcom/components/ModuleLoader.h
xpcom/components/ModuleUtils.h
xpcom/components/nsCategoryManager.cpp
xpcom/components/nsCategoryManager.h
xpcom/components/nsCategoryManagerUtils.h
xpcom/components/nsComponentManager.cpp
xpcom/components/nsComponentManager.h
xpcom/components/nsNativeModuleLoader.cpp
xpcom/components/nsNativeModuleLoader.h
--- a/xpcom/components/ManifestParser.cpp
+++ b/xpcom/components/ManifestParser.cpp
@@ -52,165 +52,136 @@ struct ManifestDirective
 
   bool allowbootstrap;
 
   // The platform/contentaccessible flags only apply to content directives.
   bool contentflags;
 
   // Function to handle this directive. This isn't a union because C++ still
   // hasn't learned how to initialize unions in a sane way.
-  void (nsComponentManagerImpl::*mgrfunc)(
-    nsComponentManagerImpl::ManifestProcessingContext& cx,
-    int lineno, char* const* argv);
-  void (nsChromeRegistry::*regfunc)(
-    nsChromeRegistry::ManifestProcessingContext& cx,
-    int lineno, char* const* argv,
-    bool platform, bool contentaccessible);
+  void (nsComponentManagerImpl::*mgrfunc)
+    (nsComponentManagerImpl::ManifestProcessingContext& cx,
+     int lineno, char *const * argv);
+  void (nsChromeRegistry::*regfunc)
+    (nsChromeRegistry::ManifestProcessingContext& cx,
+     int lineno, char *const *argv,
+     bool platform, bool contentaccessible);
 
   bool isContract;
 };
 static const ManifestDirective kParsingTable[] = {
-  {
-    "manifest",         1, false, true, true, false,
-    &nsComponentManagerImpl::ManifestManifest, nullptr
-  },
-  {
-    "binary-component", 1, true, false, false, false,
-    &nsComponentManagerImpl::ManifestBinaryComponent, nullptr
-  },
-  {
-    "interfaces",       1, true, false, false, false,
-    &nsComponentManagerImpl::ManifestXPT, nullptr
-  },
-  {
-    "component",        2, true, false, false, false,
-    &nsComponentManagerImpl::ManifestComponent, nullptr
-  },
-  {
-    "contract",         2, true, false, false, false,
-    &nsComponentManagerImpl::ManifestContract, nullptr, true
-  },
-  {
-    "category",         3, true, false, false, false,
-    &nsComponentManagerImpl::ManifestCategory, nullptr
-  },
-  {
-    "content",          2, true, true, true, true,
-    nullptr, &nsChromeRegistry::ManifestContent
-  },
-  {
-    "locale",           3, true, true, true, false,
-    nullptr, &nsChromeRegistry::ManifestLocale
-  },
-  {
-    "skin",             3, false, true, true, false,
-    nullptr, &nsChromeRegistry::ManifestSkin
-  },
-  {
-    "overlay",          2, true, true, false, false,
-    nullptr, &nsChromeRegistry::ManifestOverlay
-  },
-  {
-    "style",            2, false, true, false, false,
-    nullptr, &nsChromeRegistry::ManifestStyle
-  },
-  {
-    "override",         2, true, true, true, false,
-    nullptr, &nsChromeRegistry::ManifestOverride
-  },
-  {
-    "resource",         2, true, true, false, false,
-    nullptr, &nsChromeRegistry::ManifestResource
-  }
+  { "manifest",         1, false, true, true, false,
+    &nsComponentManagerImpl::ManifestManifest, nullptr },
+  { "binary-component", 1, true, false, false, false,
+    &nsComponentManagerImpl::ManifestBinaryComponent, nullptr },
+  { "interfaces",       1, true, false, false, false,
+    &nsComponentManagerImpl::ManifestXPT, nullptr },
+  { "component",        2, true, false, false, false,
+    &nsComponentManagerImpl::ManifestComponent, nullptr },
+  { "contract",         2, true, false, false, false,
+    &nsComponentManagerImpl::ManifestContract, nullptr, true},
+  { "category",         3, true, false, false, false,
+    &nsComponentManagerImpl::ManifestCategory, nullptr },
+  { "content",          2, true, true, true,  true,
+    nullptr, &nsChromeRegistry::ManifestContent },
+  { "locale",           3, true, true, true,  false,
+    nullptr, &nsChromeRegistry::ManifestLocale },
+  { "skin",             3, false, true, true,  false,
+    nullptr, &nsChromeRegistry::ManifestSkin },
+  { "overlay",          2, true, true, false,  false,
+    nullptr, &nsChromeRegistry::ManifestOverlay },
+  { "style",            2, false, true, false,  false,
+    nullptr, &nsChromeRegistry::ManifestStyle },
+  { "override",         2, true, true, true,  false,
+    nullptr, &nsChromeRegistry::ManifestOverride },
+  { "resource",         2, true, true, false,  false,
+    nullptr, &nsChromeRegistry::ManifestResource }
 };
 
 static const char kWhitespace[] = "\t ";
 
-static bool
-IsNewline(char aChar)
+static bool IsNewline(char c)
 {
-  return aChar == '\n' || aChar == '\r';
+  return c == '\n' || c == '\r';
 }
 
 namespace {
 struct AutoPR_smprintf_free
 {
-  AutoPR_smprintf_free(char* aBuf) : mBuf(aBuf) {}
+  AutoPR_smprintf_free(char* buf)
+    : mBuf(buf)
+  {
+  }
 
   ~AutoPR_smprintf_free()
   {
-    if (mBuf) {
+    if (mBuf)
       PR_smprintf_free(mBuf);
-    }
   }
 
-  operator char*() const { return mBuf; }
+  operator char*() const {
+    return mBuf;
+  }
 
   char* mBuf;
 };
 
 } // anonymous namespace
 
-void
-LogMessage(const char* aMsg, ...)
+void LogMessage(const char* aMsg, ...)
 {
   nsCOMPtr<nsIConsoleService> console =
     do_GetService(NS_CONSOLESERVICE_CONTRACTID);
-  if (!console) {
+  if (!console)
     return;
-  }
 
   va_list args;
   va_start(args, aMsg);
   AutoPR_smprintf_free formatted(PR_vsmprintf(aMsg, args));
   va_end(args);
 
   nsCOMPtr<nsIConsoleMessage> error =
     new nsConsoleMessage(NS_ConvertUTF8toUTF16(formatted).get());
   console->LogMessage(error);
 }
 
-void
-LogMessageWithContext(FileLocation& aFile,
-                      uint32_t aLineNumber, const char* aMsg, ...)
+void LogMessageWithContext(FileLocation &aFile,
+                           uint32_t aLineNumber, const char* aMsg, ...)
 {
   va_list args;
   va_start(args, aMsg);
   AutoPR_smprintf_free formatted(PR_vsmprintf(aMsg, args));
   va_end(args);
-  if (!formatted) {
+  if (!formatted)
     return;
-  }
 
   nsCString file;
   aFile.GetURIString(file);
 
   nsCOMPtr<nsIScriptError> error =
     do_CreateInstance(NS_SCRIPTERROR_CONTRACTID);
   if (!error) {
     // This can happen early in component registration. Fall back to a
     // generic console message.
     LogMessage("Warning: in '%s', line %i: %s", file.get(),
                aLineNumber, (char*) formatted);
     return;
   }
 
   nsCOMPtr<nsIConsoleService> console =
     do_GetService(NS_CONSOLESERVICE_CONTRACTID);
-  if (!console) {
+  if (!console)
     return;
-  }
 
   nsresult rv = error->Init(NS_ConvertUTF8toUTF16(formatted),
-                            NS_ConvertUTF8toUTF16(file), EmptyString(),
-                            aLineNumber, 0, nsIScriptError::warningFlag,
-                            "chrome registration");
-  if (NS_FAILED(rv)) {
+			    NS_ConvertUTF8toUTF16(file), EmptyString(),
+			    aLineNumber, 0, nsIScriptError::warningFlag,
+			    "chrome registration");
+  if (NS_FAILED(rv))
     return;
-  }
 
   console->LogMessage(error);
 }
 
 /**
  * Check for a modifier flag of the following forms:
  *   "flag"   (same as "true")
  *   "flag=yes|true|1"
@@ -219,19 +190,18 @@ LogMessageWithContext(FileLocation& aFil
  * @param aData The tokenized data to check; this is lowercased
  *              before being passed in.
  * @param aResult If the flag is found, the value is assigned here.
  * @return Whether the flag was handled.
  */
 static bool
 CheckFlag(const nsSubstring& aFlag, const nsSubstring& aData, bool& aResult)
 {
-  if (!StringBeginsWith(aData, aFlag)) {
+  if (!StringBeginsWith(aData, aFlag))
     return false;
-  }
 
   if (aFlag.Length() == aData.Length()) {
     // the data is simply "flag", which is the same as "flag=yes"
     aResult = true;
     return true;
   }
 
   if (aData.CharAt(aFlag.Length()) != '=') {
@@ -240,34 +210,33 @@ CheckFlag(const nsSubstring& aFlag, cons
   }
 
   if (aData.Length() == aFlag.Length() + 1) {
     aResult = false;
     return true;
   }
 
   switch (aData.CharAt(aFlag.Length() + 1)) {
-    case '1':
-    case 't': //true
-    case 'y': //yes
-      aResult = true;
-      return true;
+  case '1':
+  case 't': //true
+  case 'y': //yes
+    aResult = true;
+    return true;
 
-    case '0':
-    case 'f': //false
-    case 'n': //no
-      aResult = false;
-      return true;
+  case '0':
+  case 'f': //false
+  case 'n': //no
+    aResult = false;
+    return true;
   }
 
   return false;
 }
 
-enum TriState
-{
+enum TriState {
   eUnspecified,
   eBad,
   eOK
 };
 
 /**
  * Check for a modifier flag of the following form:
  *   "flag=string"
@@ -279,43 +248,38 @@ enum TriState
  * @param aResult If this is "ok" when passed in, this is left alone.
  *                Otherwise if the flag is found it is set to eBad or eOK.
  * @return Whether the flag was handled.
  */
 static bool
 CheckStringFlag(const nsSubstring& aFlag, const nsSubstring& aData,
                 const nsSubstring& aValue, TriState& aResult)
 {
-  if (aData.Length() < aFlag.Length() + 1) {
+  if (aData.Length() < aFlag.Length() + 1)
     return false;
-  }
 
-  if (!StringBeginsWith(aData, aFlag)) {
+  if (!StringBeginsWith(aData, aFlag))
     return false;
-  }
 
   bool comparison = true;
   if (aData[aFlag.Length()] != '=') {
     if (aData[aFlag.Length()] == '!' &&
         aData.Length() >= aFlag.Length() + 2 &&
-        aData[aFlag.Length() + 1] == '=') {
+        aData[aFlag.Length() + 1] == '=')
       comparison = false;
-    } else {
+    else
       return false;
-    }
   }
 
   if (aResult != eOK) {
-    nsDependentSubstring testdata =
-      Substring(aData, aFlag.Length() + (comparison ? 1 : 2));
-    if (testdata.Equals(aValue)) {
+    nsDependentSubstring testdata = Substring(aData, aFlag.Length() + (comparison ? 1 : 2));
+    if (testdata.Equals(aValue))
       aResult = comparison ? eOK : eBad;
-    } else {
+    else
       aResult = comparison ? eBad : eOK;
-    }
   }
 
   return true;
 }
 
 /**
  * Check for a modifier flag of the following form:
  *   "flag=version"
@@ -336,110 +300,104 @@ CheckStringFlag(const nsSubstring& aFlag
 #define COMPARE_EQ    1 << 0
 #define COMPARE_LT    1 << 1
 #define COMPARE_GT    1 << 2
 
 static bool
 CheckVersionFlag(const nsString& aFlag, const nsString& aData,
                  const nsString& aValue, TriState& aResult)
 {
-  if (aData.Length() < aFlag.Length() + 2) {
+  if (aData.Length() < aFlag.Length() + 2)
     return false;
-  }
 
-  if (!StringBeginsWith(aData, aFlag)) {
+  if (!StringBeginsWith(aData, aFlag))
     return false;
-  }
 
   if (aValue.Length() == 0) {
-    if (aResult != eOK) {
+    if (aResult != eOK)
       aResult = eBad;
-    }
     return true;
   }
 
   uint32_t comparison;
   nsAutoString testdata;
 
   switch (aData[aFlag.Length()]) {
-    case '=':
-      comparison = COMPARE_EQ;
-      testdata = Substring(aData, aFlag.Length() + 1);
-      break;
+  case '=':
+    comparison = COMPARE_EQ;
+    testdata = Substring(aData, aFlag.Length() + 1);
+    break;
 
-    case '<':
-      if (aData[aFlag.Length() + 1] == '=') {
-        comparison = COMPARE_EQ | COMPARE_LT;
-        testdata = Substring(aData, aFlag.Length() + 2);
-      } else {
-        comparison = COMPARE_LT;
-        testdata = Substring(aData, aFlag.Length() + 1);
-      }
-      break;
+  case '<':
+    if (aData[aFlag.Length() + 1] == '=') {
+      comparison = COMPARE_EQ | COMPARE_LT;
+      testdata = Substring(aData, aFlag.Length() + 2);
+    }
+    else {
+      comparison = COMPARE_LT;
+      testdata = Substring(aData, aFlag.Length() + 1);
+    }
+    break;
 
-    case '>':
-      if (aData[aFlag.Length() + 1] == '=') {
-        comparison = COMPARE_EQ | COMPARE_GT;
-        testdata = Substring(aData, aFlag.Length() + 2);
-      } else {
-        comparison = COMPARE_GT;
-        testdata = Substring(aData, aFlag.Length() + 1);
-      }
-      break;
+  case '>':
+    if (aData[aFlag.Length() + 1] == '=') {
+      comparison = COMPARE_EQ | COMPARE_GT;
+      testdata = Substring(aData, aFlag.Length() + 2);
+    }
+    else {
+      comparison = COMPARE_GT;
+      testdata = Substring(aData, aFlag.Length() + 1);
+    }
+    break;
 
-    default:
-      return false;
+  default:
+    return false;
   }
 
-  if (testdata.Length() == 0) {
+  if (testdata.Length() == 0)
     return false;
-  }
 
   if (aResult != eOK) {
     int32_t c = mozilla::CompareVersions(NS_ConvertUTF16toUTF8(aValue).get(),
                                          NS_ConvertUTF16toUTF8(testdata).get());
     if ((c == 0 && comparison & COMPARE_EQ) ||
-        (c < 0 && comparison & COMPARE_LT) ||
-        (c > 0 && comparison & COMPARE_GT)) {
+	(c < 0 && comparison & COMPARE_LT) ||
+	(c > 0 && comparison & COMPARE_GT))
       aResult = eOK;
-    } else {
+    else
       aResult = eBad;
-    }
   }
 
   return true;
 }
 
 // In-place conversion of ascii characters to lower case
 static void
-ToLowerCase(char* aToken)
+ToLowerCase(char* token)
 {
-  for (; *aToken; ++aToken) {
-    *aToken = NS_ToLower(*aToken);
-  }
+  for (; *token; ++token)
+    *token = NS_ToLower(*token);
 }
 
 namespace {
 
 struct CachedDirective
 {
   int lineno;
   char* argv[4];
 };
 
 } // anonymous namespace
 
 
 void
-ParseManifest(NSLocationType aType, FileLocation& aFile, char* aBuf,
-              bool aChromeOnly)
+ParseManifest(NSLocationType type, FileLocation &file, char* buf, bool aChromeOnly)
 {
-  nsComponentManagerImpl::ManifestProcessingContext mgrcx(aType, aFile,
-                                                          aChromeOnly);
-  nsChromeRegistry::ManifestProcessingContext chromecx(aType, aFile);
+  nsComponentManagerImpl::ManifestProcessingContext mgrcx(type, file, aChromeOnly);
+  nsChromeRegistry::ManifestProcessingContext chromecx(type, file);
   nsresult rv;
 
   NS_NAMED_LITERAL_STRING(kPlatform, "platform");
   NS_NAMED_LITERAL_STRING(kContentAccessible, "contentaccessible");
   NS_NAMED_LITERAL_STRING(kApplication, "application");
   NS_NAMED_LITERAL_STRING(kAppVersion, "appversion");
   NS_NAMED_LITERAL_STRING(kGeckoVersion, "platformversion");
   NS_NAMED_LITERAL_STRING(kOs, "os");
@@ -453,35 +411,32 @@ ParseManifest(NSLocationType aType, File
   NS_NAMED_LITERAL_STRING(kXPCNativeWrappers, "xpcnativewrappers");
 
   nsAutoString appID;
   nsAutoString appVersion;
   nsAutoString geckoVersion;
   nsAutoString osTarget;
   nsAutoString abi;
 
-  nsCOMPtr<nsIXULAppInfo> xapp(do_GetService(XULAPPINFO_SERVICE_CONTRACTID));
+  nsCOMPtr<nsIXULAppInfo> xapp (do_GetService(XULAPPINFO_SERVICE_CONTRACTID));
   if (xapp) {
     nsAutoCString s;
     rv = xapp->GetID(s);
-    if (NS_SUCCEEDED(rv)) {
+    if (NS_SUCCEEDED(rv))
       CopyUTF8toUTF16(s, appID);
-    }
 
     rv = xapp->GetVersion(s);
-    if (NS_SUCCEEDED(rv)) {
+    if (NS_SUCCEEDED(rv))
       CopyUTF8toUTF16(s, appVersion);
-    }
 
     rv = xapp->GetPlatformVersion(s);
-    if (NS_SUCCEEDED(rv)) {
+    if (NS_SUCCEEDED(rv))
       CopyUTF8toUTF16(s, geckoVersion);
-    }
 
-    nsCOMPtr<nsIXULRuntime> xruntime(do_QueryInterface(xapp));
+    nsCOMPtr<nsIXULRuntime> xruntime (do_QueryInterface(xapp));
     if (xruntime) {
       rv = xruntime->GetOS(s);
       if (NS_SUCCEEDED(rv)) {
         ToLowerCase(s);
         CopyUTF8toUTF16(s, osTarget);
       }
 
       rv = xruntime->GetXPCOMABI(s);
@@ -496,118 +451,110 @@ ParseManifest(NSLocationType aType, File
 
   nsAutoString osVersion;
 #if defined(XP_WIN)
 #pragma warning(push)
 #pragma warning(disable:4996) // VC12+ deprecates GetVersionEx
   OSVERSIONINFO info = { sizeof(OSVERSIONINFO) };
   if (GetVersionEx(&info)) {
     nsTextFormatter::ssprintf(osVersion, MOZ_UTF16("%ld.%ld"),
-                              info.dwMajorVersion,
-                              info.dwMinorVersion);
+                                         info.dwMajorVersion,
+                                         info.dwMinorVersion);
   }
 #pragma warning(pop)
 #elif defined(MOZ_WIDGET_COCOA)
   SInt32 majorVersion = nsCocoaFeatures::OSXVersionMajor();
   SInt32 minorVersion = nsCocoaFeatures::OSXVersionMinor();
   nsTextFormatter::ssprintf(osVersion, NS_LITERAL_STRING("%ld.%ld").get(),
-                            majorVersion,
-                            minorVersion);
+                                       majorVersion,
+                                       minorVersion);
 #elif defined(MOZ_WIDGET_GTK)
   nsTextFormatter::ssprintf(osVersion, MOZ_UTF16("%ld.%ld"),
-                            gtk_major_version,
-                            gtk_minor_version);
+                                       gtk_major_version,
+                                       gtk_minor_version);
 #elif defined(MOZ_WIDGET_ANDROID)
   bool isTablet = false;
   if (mozilla::AndroidBridge::Bridge()) {
-    mozilla::AndroidBridge::Bridge()->GetStaticStringField("android/os/Build$VERSION",
-                                                           "RELEASE",
-                                                           osVersion);
+    mozilla::AndroidBridge::Bridge()->GetStaticStringField("android/os/Build$VERSION", "RELEASE", osVersion);
     isTablet = mozilla::widget::android::GeckoAppShell::IsTablet();
   }
 #endif
 
   // Because contracts must be registered after CIDs, we save and process them
   // at the end.
   nsTArray<CachedDirective> contracts;
 
-  char* token;
-  char* newline = aBuf;
+  char *token;
+  char *newline = buf;
   uint32_t line = 0;
 
   // outer loop tokenizes by newline
   while (*newline) {
     while (*newline && IsNewline(*newline)) {
       ++newline;
       ++line;
     }
-    if (!*newline) {
+    if (!*newline)
       break;
-    }
 
     token = newline;
-    while (*newline && !IsNewline(*newline)) {
+    while (*newline && !IsNewline(*newline))
       ++newline;
-    }
 
     if (*newline) {
       *newline = '\0';
       ++newline;
     }
     ++line;
 
-    if (*token == '#') { // ignore lines that begin with # as comments
+    if (*token == '#') // ignore lines that begin with # as comments
       continue;
-    }
 
-    char* whitespace = token;
+    char *whitespace = token;
     token = nsCRT::strtok(whitespace, kWhitespace, &whitespace);
-    if (!token) {
-      continue;
-    }
+    if (!token) continue;
 
     const ManifestDirective* directive = nullptr;
     for (const ManifestDirective* d = kParsingTable;
-         d < ArrayEnd(kParsingTable);
-         ++d) {
+	 d < ArrayEnd(kParsingTable);
+	 ++d) {
       if (!strcmp(d->directive, token)) {
-        directive = d;
-        break;
+	directive = d;
+	break;
       }
     }
 
     if (!directive) {
-      LogMessageWithContext(aFile, line,
+      LogMessageWithContext(file, line,
                             "Ignoring unrecognized chrome manifest directive '%s'.",
                             token);
       continue;
     }
 
-    if (!directive->allowbootstrap && NS_BOOTSTRAPPED_LOCATION == aType) {
-      LogMessageWithContext(aFile, line,
+    if (!directive->allowbootstrap && NS_BOOTSTRAPPED_LOCATION == type) {
+      LogMessageWithContext(file, line,
                             "Bootstrapped manifest not allowed to use '%s' directive.",
                             token);
       continue;
     }
 
-    if (directive->componentonly && NS_SKIN_LOCATION == aType) {
-      LogMessageWithContext(aFile, line,
+    if (directive->componentonly && NS_SKIN_LOCATION == type) {
+      LogMessageWithContext(file, line,
                             "Skin manifest not allowed to use '%s' directive.",
                             token);
       continue;
     }
 
     NS_ASSERTION(directive->argc < 4, "Need to reset argv array length");
     char* argv[4];
-    for (int i = 0; i < directive->argc; ++i) {
+    for (int i = 0; i < directive->argc; ++i)
       argv[i] = nsCRT::strtok(whitespace, kWhitespace, &whitespace);
-    }
 
     if (!argv[directive->argc - 1]) {
-      LogMessageWithContext(aFile, line,
+      LogMessageWithContext(file, line,
                             "Not enough arguments for chrome manifest directive '%s', expected %i.",
                             token, directive->argc);
       continue;
     }
 
     bool ok = true;
     TriState stAppVersion = eUnspecified;
     TriState stGeckoVersion = eUnspecified;
@@ -616,99 +563,95 @@ ParseManifest(NSLocationType aType, File
     TriState stOs = eUnspecified;
     TriState stABI = eUnspecified;
 #if defined(MOZ_WIDGET_ANDROID)
     TriState stTablet = eUnspecified;
 #endif
     bool platform = false;
     bool contentAccessible = false;
 
-    while ((token = nsCRT::strtok(whitespace, kWhitespace, &whitespace)) &&
-           ok) {
+    while (nullptr != (token = nsCRT::strtok(whitespace, kWhitespace, &whitespace)) && ok) {
       ToLowerCase(token);
       NS_ConvertASCIItoUTF16 wtoken(token);
 
       if (CheckStringFlag(kApplication, wtoken, appID, stApp) ||
           CheckStringFlag(kOs, wtoken, osTarget, stOs) ||
           CheckStringFlag(kABI, wtoken, abi, stABI) ||
           CheckVersionFlag(kOsVersion, wtoken, osVersion, stOsVersion) ||
           CheckVersionFlag(kAppVersion, wtoken, appVersion, stAppVersion) ||
-          CheckVersionFlag(kGeckoVersion, wtoken, geckoVersion, stGeckoVersion)) {
+          CheckVersionFlag(kGeckoVersion, wtoken, geckoVersion, stGeckoVersion))
         continue;
-      }
 
 #if defined(MOZ_WIDGET_ANDROID)
       bool tablet = false;
       if (CheckFlag(kTablet, wtoken, tablet)) {
         stTablet = (tablet == isTablet) ? eOK : eBad;
         continue;
       }
 #endif
 
       if (directive->contentflags &&
           (CheckFlag(kPlatform, wtoken, platform) ||
-           CheckFlag(kContentAccessible, wtoken, contentAccessible))) {
+           CheckFlag(kContentAccessible, wtoken, contentAccessible)))
         continue;
-      }
 
       bool xpcNativeWrappers = true; // Dummy for CheckFlag.
       if (CheckFlag(kXPCNativeWrappers, wtoken, xpcNativeWrappers)) {
-        LogMessageWithContext(aFile, line,
+        LogMessageWithContext(file, line,
                               "Ignoring obsolete chrome registration modifier '%s'.",
                               token);
         continue;
       }
 
-      LogMessageWithContext(aFile, line,
+      LogMessageWithContext(file, line,
                             "Unrecognized chrome manifest modifier '%s'.",
                             token);
       ok = false;
     }
 
     if (!ok ||
         stApp == eBad ||
         stAppVersion == eBad ||
         stGeckoVersion == eBad ||
         stOs == eBad ||
         stOsVersion == eBad ||
 #ifdef MOZ_WIDGET_ANDROID
         stTablet == eBad ||
 #endif
-        stABI == eBad) {
+        stABI == eBad)
       continue;
-    }
 
     if (directive->regfunc) {
-      if (GeckoProcessType_Default != XRE_GetProcessType()) {
+      if (GeckoProcessType_Default != XRE_GetProcessType())
         continue;
-      }
 
       if (!nsChromeRegistry::gChromeRegistry) {
         nsCOMPtr<nsIChromeRegistry> cr =
           mozilla::services::GetChromeRegistryService();
         if (!nsChromeRegistry::gChromeRegistry) {
-          LogMessageWithContext(aFile, line,
+          LogMessageWithContext(file, line,
                                 "Chrome registry isn't available yet.");
           continue;
         }
       }
 
-      (nsChromeRegistry::gChromeRegistry->*(directive->regfunc))(
-        chromecx, line, argv, platform, contentAccessible);
-    } else if (directive->ischrome || !aChromeOnly) {
+      (nsChromeRegistry::gChromeRegistry->*(directive->regfunc))
+	(chromecx, line, argv, platform, contentAccessible);
+    }
+    else if (directive->ischrome || !aChromeOnly) {
       if (directive->isContract) {
         CachedDirective* cd = contracts.AppendElement();
         cd->lineno = line;
         cd->argv[0] = argv[0];
         cd->argv[1] = argv[1];
-      } else
-        (nsComponentManagerImpl::gComponentManager->*(directive->mgrfunc))(
-          mgrcx, line, argv);
+      }
+      else
+        (nsComponentManagerImpl::gComponentManager->*(directive->mgrfunc))
+          (mgrcx, line, argv);
     }
   }
 
   for (uint32_t i = 0; i < contracts.Length(); ++i) {
     CachedDirective& d = contracts[i];
-    nsComponentManagerImpl::gComponentManager->ManifestContract(mgrcx,
-                                                                d.lineno,
-                                                                d.argv);
+    nsComponentManagerImpl::gComponentManager->ManifestContract
+      (mgrcx, d.lineno, d.argv);
   }
 }
--- a/xpcom/components/ManifestParser.h
+++ b/xpcom/components/ManifestParser.h
@@ -7,17 +7,17 @@
 #define ManifestParser_h
 
 #include "nsComponentManager.h"
 #include "nsChromeRegistry.h"
 #include "mozilla/FileLocation.h"
 
 class nsIFile;
 
-void ParseManifest(NSLocationType aType, mozilla::FileLocation& aFile,
-                   char* aBuf, bool aChromeOnly);
+void ParseManifest(NSLocationType type, mozilla::FileLocation &file,
+                   char* buf, bool aChromeOnly);
 
 void LogMessage(const char* aMsg, ...);
 
-void LogMessageWithContext(mozilla::FileLocation& aFile,
+void LogMessageWithContext(mozilla::FileLocation &aFile,
                            uint32_t aLineNumber, const char* aMsg, ...);
 
 #endif // ManifestParser_h
--- a/xpcom/components/Module.h
+++ b/xpcom/components/Module.h
@@ -20,18 +20,18 @@ namespace mozilla {
  * via a module loader.
  */
 struct Module
 {
   static const unsigned int kVersion = 34;
 
   struct CIDEntry;
 
-  typedef already_AddRefed<nsIFactory> (*GetFactoryProcPtr)(
-    const Module& module, const CIDEntry& entry);
+  typedef already_AddRefed<nsIFactory> (*GetFactoryProcPtr)
+    (const Module& module, const CIDEntry& entry);
 
   typedef nsresult (*ConstructorProcPtr)(nsISupports* aOuter,
                                          const nsIID& aIID,
                                          void** aResult);
 
   typedef nsresult (*LoadFuncPtr)();
   typedef void (*UnloadFuncPtr)();
 
@@ -57,17 +57,17 @@ struct Module
     GetFactoryProcPtr getFactoryProc;
     ConstructorProcPtr constructorProc;
     ProcessSelector processSelector;
   };
 
   struct ContractIDEntry
   {
     const char* contractid;
-    nsID const* cid;
+    nsID const * cid;
     ProcessSelector processSelector;
   };
 
   struct CategoryEntry
   {
     const char* category;
     const char* entry;
     const char* value;
--- a/xpcom/components/ModuleLoader.h
+++ b/xpcom/components/ModuleLoader.h
@@ -29,15 +29,15 @@ public:
   NS_DECLARE_STATIC_IID_ACCESSOR(MOZILLA_MODULELOADER_PSEUDO_IID)
 
   /**
    * Return the module for a specified file. The caller should cache
    * the module: the implementer should not expect for the same file
    * to be loaded multiple times. The Module object should either be
    * statically or permanently allocated; it will not be freed.
    */
-  virtual const Module* LoadModule(mozilla::FileLocation& aFile) = 0;
+  virtual const Module* LoadModule(mozilla::FileLocation &aFile) = 0;
 };
 NS_DEFINE_STATIC_IID_ACCESSOR(ModuleLoader, MOZILLA_MODULELOADER_PSEUDO_IID)
 
 } // namespace mozilla
 
 #endif // mozilla_ModuleLoader_h
--- a/xpcom/components/ModuleUtils.h
+++ b/xpcom/components/ModuleUtils.h
@@ -99,26 +99,29 @@ static nsresult                         
 
 #include "nsIModule.h"
 #include "nsISupportsUtils.h"
 
 namespace mozilla {
 
 class GenericModule MOZ_FINAL : public nsIModule
 {
-  ~GenericModule() {}
+    ~GenericModule() {}
 
 public:
-  explicit GenericModule(const mozilla::Module* aData) : mData(aData) {}
+    explicit GenericModule(const mozilla::Module* aData)
+        : mData(aData)
+    {
+    }
 
-  NS_DECL_THREADSAFE_ISUPPORTS
-  NS_DECL_NSIMODULE
+    NS_DECL_THREADSAFE_ISUPPORTS
+    NS_DECL_NSIMODULE
 
 private:
-  const mozilla::Module* mData;
+    const mozilla::Module* mData;
 };
 
 } // namespace mozilla
 
 #define NS_IMPL_MOZILLA192_NSGETMODULE(module)     \
 extern "C" NS_EXPORT nsresult                      \
 NSGetModule(nsIComponentManager* aCompMgr,         \
             nsIFile* aLocation,                    \
--- a/xpcom/components/nsCategoryManager.cpp
+++ b/xpcom/components/nsCategoryManager.cpp
@@ -46,115 +46,108 @@ class nsIComponentLoaderManager;
 
   The leaf strings are allocated in an arena, because we assume they're not
   going to change much ;)
 */
 
 #define NS_CATEGORYMANAGER_ARENA_SIZE (1024 * 8)
 
 // pulled in from nsComponentManager.cpp
-char* ArenaStrdup(const char* aStr, PLArenaPool* aArena);
+char* ArenaStrdup(const char* s, PLArenaPool* aArena);
 
 //
 // BaseStringEnumerator is subclassed by EntryEnumerator and
 // CategoryEnumerator
 //
 class BaseStringEnumerator
-  : public nsISimpleEnumerator
-  , private nsIUTF8StringEnumerator
+  : public nsISimpleEnumerator,
+    private nsIUTF8StringEnumerator
 {
 public:
   NS_DECL_ISUPPORTS
   NS_DECL_NSISIMPLEENUMERATOR
   NS_DECL_NSIUTF8STRINGENUMERATOR
 
 protected:
   // Callback function for NS_QuickSort to sort mArray
-  static int SortCallback(const void*, const void*, void*);
+  static int SortCallback(const void *, const void *, void *);
 
   BaseStringEnumerator()
-    : mArray(nullptr)
-    , mCount(0)
-    , mSimpleCurItem(0)
-    , mStringCurItem(0)
-  {
-  }
+    : mArray(nullptr),
+      mCount(0),
+      mSimpleCurItem(0),
+      mStringCurItem(0) { }
 
   // A virtual destructor is needed here because subclasses of
   // BaseStringEnumerator do not implement their own Release() method.
 
   virtual ~BaseStringEnumerator()
   {
-    if (mArray) {
+    if (mArray)
       delete[] mArray;
-    }
   }
 
   void Sort();
 
   const char** mArray;
   uint32_t mCount;
   uint32_t mSimpleCurItem;
   uint32_t mStringCurItem;
 };
 
-NS_IMPL_ISUPPORTS(BaseStringEnumerator, nsISimpleEnumerator,
-                  nsIUTF8StringEnumerator)
+NS_IMPL_ISUPPORTS(BaseStringEnumerator, nsISimpleEnumerator, nsIUTF8StringEnumerator)
 
 NS_IMETHODIMP
-BaseStringEnumerator::HasMoreElements(bool* aResult)
+BaseStringEnumerator::HasMoreElements(bool *_retval)
 {
-  *aResult = (mSimpleCurItem < mCount);
+  *_retval = (mSimpleCurItem < mCount);
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
-BaseStringEnumerator::GetNext(nsISupports** aResult)
+BaseStringEnumerator::GetNext(nsISupports **_retval)
 {
-  if (mSimpleCurItem >= mCount) {
+  if (mSimpleCurItem >= mCount)
     return NS_ERROR_FAILURE;
-  }
 
   nsSupportsDependentCString* str =
     new nsSupportsDependentCString(mArray[mSimpleCurItem++]);
-  if (!str) {
+  if (!str)
     return NS_ERROR_OUT_OF_MEMORY;
-  }
 
-  *aResult = str;
-  NS_ADDREF(*aResult);
+  *_retval = str;
+  NS_ADDREF(*_retval);
   return NS_OK;
 }
 
 NS_IMETHODIMP
-BaseStringEnumerator::HasMore(bool* aResult)
+BaseStringEnumerator::HasMore(bool *_retval)
 {
-  *aResult = (mStringCurItem < mCount);
+  *_retval = (mStringCurItem < mCount);
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
-BaseStringEnumerator::GetNext(nsACString& aResult)
+BaseStringEnumerator::GetNext(nsACString& _retval)
 {
-  if (mStringCurItem >= mCount) {
+  if (mStringCurItem >= mCount)
     return NS_ERROR_FAILURE;
-  }
 
-  aResult = nsDependentCString(mArray[mStringCurItem++]);
+  _retval = nsDependentCString(mArray[mStringCurItem++]);
   return NS_OK;
 }
 
 int
-BaseStringEnumerator::SortCallback(const void* aE1, const void* aE2,
-                                   void* /*unused*/)
+BaseStringEnumerator::SortCallback(const void *e1, const void *e2,
+                                   void * /*unused*/)
 {
-  char const* const* s1 = reinterpret_cast<char const* const*>(aE1);
-  char const* const* s2 = reinterpret_cast<char const* const*>(aE2);
+  char const *const *s1 = reinterpret_cast<char const *const *>(e1);
+  char const *const *s2 = reinterpret_cast<char const *const *>(e2);
 
   return strcmp(*s1, *s2);
 }
 
 void
 BaseStringEnumerator::Sort()
 {
   NS_QuickSort(mArray, mCount, sizeof(mArray[0]), SortCallback, nullptr);
@@ -165,39 +158,37 @@ BaseStringEnumerator::Sort()
 //
 class EntryEnumerator
   : public BaseStringEnumerator
 {
 public:
   static EntryEnumerator* Create(nsTHashtable<CategoryLeaf>& aTable);
 
 private:
-  static PLDHashOperator enumfunc_createenumerator(CategoryLeaf* aLeaf,
-                                                   void* aUserArg);
+  static PLDHashOperator
+    enumfunc_createenumerator(CategoryLeaf* aLeaf, void* userArg);
 };
 
 
 PLDHashOperator
-EntryEnumerator::enumfunc_createenumerator(CategoryLeaf* aLeaf, void* aUserArg)
+EntryEnumerator::enumfunc_createenumerator(CategoryLeaf* aLeaf, void* userArg)
 {
-  EntryEnumerator* mythis = static_cast<EntryEnumerator*>(aUserArg);
-  if (aLeaf->value) {
+  EntryEnumerator* mythis = static_cast<EntryEnumerator*>(userArg);
+  if (aLeaf->value)
     mythis->mArray[mythis->mCount++] = aLeaf->GetKey();
-  }
 
   return PL_DHASH_NEXT;
 }
 
 EntryEnumerator*
 EntryEnumerator::Create(nsTHashtable<CategoryLeaf>& aTable)
 {
   EntryEnumerator* enumObj = new EntryEnumerator();
-  if (!enumObj) {
+  if (!enumObj)
     return nullptr;
-  }
 
   enumObj->mArray = new char const* [aTable.Count()];
   if (!enumObj->mArray) {
     delete enumObj;
     return nullptr;
   }
 
   aTable.EnumerateEntries(enumfunc_createenumerator, enumObj);
@@ -211,19 +202,18 @@ EntryEnumerator::Create(nsTHashtable<Cat
 //
 // CategoryNode implementations
 //
 
 CategoryNode*
 CategoryNode::Create(PLArenaPool* aArena)
 {
   CategoryNode* node = new(aArena) CategoryNode();
-  if (!node) {
+  if (!node)
     return nullptr;
-  }
 
   return node;
 }
 
 CategoryNode::~CategoryNode()
 {
 }
 
@@ -232,72 +222,67 @@ CategoryNode::operator new(size_t aSize,
 {
   void* p;
   PL_ARENA_ALLOCATE(p, aArena, aSize);
   return p;
 }
 
 NS_METHOD
 CategoryNode::GetLeaf(const char* aEntryName,
-                      char** aResult)
+                      char** _retval)
 {
   MutexAutoLock lock(mLock);
   nsresult rv = NS_ERROR_NOT_AVAILABLE;
-  CategoryLeaf* ent = mTable.GetEntry(aEntryName);
+  CategoryLeaf* ent =
+    mTable.GetEntry(aEntryName);
 
   if (ent && ent->value) {
-    *aResult = NS_strdup(ent->value);
-    if (*aResult) {
+    *_retval = NS_strdup(ent->value);
+    if (*_retval)
       rv = NS_OK;
-    }
   }
 
   return rv;
 }
 
 NS_METHOD
 CategoryNode::AddLeaf(const char* aEntryName,
                       const char* aValue,
                       bool aReplace,
-                      char** aResult,
+                      char** _retval,
                       PLArenaPool* aArena)
 {
-  if (aResult) {
-    *aResult = nullptr;
-  }
+  if (_retval)
+    *_retval = nullptr;
 
   MutexAutoLock lock(mLock);
-  CategoryLeaf* leaf = mTable.GetEntry(aEntryName);
+  CategoryLeaf* leaf = 
+    mTable.GetEntry(aEntryName);
 
   if (!leaf) {
     const char* arenaEntryName = ArenaStrdup(aEntryName, aArena);
-    if (!arenaEntryName) {
+    if (!arenaEntryName)
       return NS_ERROR_OUT_OF_MEMORY;
-    }
 
     leaf = mTable.PutEntry(arenaEntryName);
-    if (!leaf) {
+    if (!leaf)
       return NS_ERROR_OUT_OF_MEMORY;
-    }
   }
 
-  if (leaf->value && !aReplace) {
+  if (leaf->value && !aReplace)
     return NS_ERROR_INVALID_ARG;
-  }
 
   const char* arenaValue = ArenaStrdup(aValue, aArena);
-  if (!arenaValue) {
+  if (!arenaValue)
     return NS_ERROR_OUT_OF_MEMORY;
-  }
 
-  if (aResult && leaf->value) {
-    *aResult = ToNewCString(nsDependentCString(leaf->value));
-    if (!*aResult) {
+  if (_retval && leaf->value) {
+    *_retval = ToNewCString(nsDependentCString(leaf->value));
+    if (!*_retval)
       return NS_ERROR_OUT_OF_MEMORY;
-    }
   }
 
   leaf->value = arenaValue;
   return NS_OK;
 }
 
 void
 CategoryNode::DeleteLeaf(const char* aEntryName)
@@ -305,120 +290,112 @@ CategoryNode::DeleteLeaf(const char* aEn
   // we don't throw any errors, because it normally doesn't matter
   // and it makes JS a lot cleaner
   MutexAutoLock lock(mLock);
 
   // we can just remove the entire hash entry without introspection
   mTable.RemoveEntry(aEntryName);
 }
 
-NS_METHOD
-CategoryNode::Enumerate(nsISimpleEnumerator** aResult)
+NS_METHOD 
+CategoryNode::Enumerate(nsISimpleEnumerator **_retval)
 {
-  if (NS_WARN_IF(!aResult)) {
+  if (NS_WARN_IF(!_retval))
     return NS_ERROR_INVALID_ARG;
-  }
 
   MutexAutoLock lock(mLock);
   EntryEnumerator* enumObj = EntryEnumerator::Create(mTable);
 
-  if (!enumObj) {
+  if (!enumObj)
     return NS_ERROR_OUT_OF_MEMORY;
-  }
 
-  *aResult = enumObj;
-  NS_ADDREF(*aResult);
+  *_retval = enumObj;
+  NS_ADDREF(*_retval);
   return NS_OK;
 }
 
 size_t
 CategoryNode::SizeOfExcludingThis(MallocSizeOf aMallocSizeOf)
 {
-  // We don't measure the strings pointed to by the entries because the
-  // pointers are non-owning.
-  return mTable.SizeOfExcludingThis(nullptr, aMallocSizeOf);
+    // We don't measure the strings pointed to by the entries because the
+    // pointers are non-owning.
+    return mTable.SizeOfExcludingThis(nullptr, aMallocSizeOf);
 }
 
-struct persistent_userstruct
-{
+struct persistent_userstruct {
   PRFileDesc* fd;
   const char* categoryName;
   bool        success;
 };
 
 PLDHashOperator
-enumfunc_pentries(CategoryLeaf* aLeaf, void* aUserArg)
+enumfunc_pentries(CategoryLeaf* aLeaf, void* userArg)
 {
-  persistent_userstruct* args = static_cast<persistent_userstruct*>(aUserArg);
+  persistent_userstruct* args =
+    static_cast<persistent_userstruct*>(userArg);
 
   PLDHashOperator status = PL_DHASH_NEXT;
 
   if (aLeaf->value) {
     if (PR_fprintf(args->fd,
                    "%s,%s,%s\n",
                    args->categoryName,
                    aLeaf->GetKey(),
-                   aLeaf->value) == (uint32_t)-1) {
+                   aLeaf->value) == (uint32_t) -1) {
       args->success = false;
       status = PL_DHASH_STOP;
     }
   }
 
   return status;
 }
 
 //
 // CategoryEnumerator class
 //
 
 class CategoryEnumerator
   : public BaseStringEnumerator
 {
 public:
-  static CategoryEnumerator* Create(nsClassHashtable<nsDepCharHashKey,
-                                                     CategoryNode>& aTable);
+  static CategoryEnumerator* Create(nsClassHashtable<nsDepCharHashKey, CategoryNode>& aTable);
 
 private:
   static PLDHashOperator
   enumfunc_createenumerator(const char* aStr,
                             CategoryNode* aNode,
-                            void* aUserArg);
+                            void* userArg);
 };
 
 CategoryEnumerator*
-CategoryEnumerator::Create(nsClassHashtable<nsDepCharHashKey, CategoryNode>&
-                           aTable)
+CategoryEnumerator::Create(nsClassHashtable<nsDepCharHashKey, CategoryNode>& aTable)
 {
   CategoryEnumerator* enumObj = new CategoryEnumerator();
-  if (!enumObj) {
+  if (!enumObj)
     return nullptr;
-  }
 
   enumObj->mArray = new const char* [aTable.Count()];
   if (!enumObj->mArray) {
     delete enumObj;
     return nullptr;
   }
 
   aTable.EnumerateRead(enumfunc_createenumerator, enumObj);
 
   return enumObj;
 }
 
 PLDHashOperator
-CategoryEnumerator::enumfunc_createenumerator(const char* aStr,
-                                              CategoryNode* aNode,
-                                              void* aUserArg)
+CategoryEnumerator::enumfunc_createenumerator(const char* aStr, CategoryNode* aNode, void* userArg)
 {
-  CategoryEnumerator* mythis = static_cast<CategoryEnumerator*>(aUserArg);
+  CategoryEnumerator* mythis = static_cast<CategoryEnumerator*>(userArg);
 
   // if a category has no entries, we pretend it doesn't exist
-  if (aNode->Count()) {
+  if (aNode->Count())
     mythis->mArray[mythis->mCount++] = aStr;
-  }
 
   return PL_DHASH_NEXT;
 }
 
 
 //
 // nsCategoryManager implementations
 //
@@ -437,35 +414,33 @@ nsCategoryManager::Release()
   return 1;
 }
 
 nsCategoryManager* nsCategoryManager::gCategoryManager;
 
 /* static */ nsCategoryManager*
 nsCategoryManager::GetSingleton()
 {
-  if (!gCategoryManager) {
+  if (!gCategoryManager)
     gCategoryManager = new nsCategoryManager();
-  }
   return gCategoryManager;
 }
 
 /* static */ void
 nsCategoryManager::Destroy()
 {
   delete gCategoryManager;
   gCategoryManager = nullptr;
 }
 
 nsresult
 nsCategoryManager::Create(nsISupports* aOuter, REFNSIID aIID, void** aResult)
 {
-  if (aOuter) {
+  if (aOuter)
     return NS_ERROR_NO_AGGREGATION;
-  }
 
   return GetSingleton()->QueryInterface(aIID, aResult);
 }
 
 nsCategoryManager::nsCategoryManager()
   : mLock("nsCategoryManager")
   , mSuppressNotifications(false)
 {
@@ -487,46 +462,45 @@ nsCategoryManager::~nsCategoryManager()
   // destroyed, or else you will have PRLocks undestroyed and other Really
   // Bad Stuff (TM)
   mTable.Clear();
 
   PL_FinishArenaPool(&mArena);
 }
 
 inline CategoryNode*
-nsCategoryManager::get_category(const char* aName)
-{
+nsCategoryManager::get_category(const char* aName) {
   CategoryNode* node;
   if (!mTable.Get(aName, &node)) {
     return nullptr;
   }
   return node;
 }
 
 MOZ_DEFINE_MALLOC_SIZE_OF(CategoryManagerMallocSizeOf)
 
 NS_IMETHODIMP
 nsCategoryManager::CollectReports(nsIHandleReportCallback* aHandleReport,
                                   nsISupports* aData, bool aAnonymize)
 {
-  return MOZ_COLLECT_REPORT("explicit/xpcom/category-manager",
-                            KIND_HEAP, UNITS_BYTES,
-                            SizeOfIncludingThis(CategoryManagerMallocSizeOf),
-                            "Memory used for the XPCOM category manager.");
+  return MOZ_COLLECT_REPORT(
+    "explicit/xpcom/category-manager", KIND_HEAP, UNITS_BYTES,
+    SizeOfIncludingThis(CategoryManagerMallocSizeOf),
+    "Memory used for the XPCOM category manager.");
 }
 
 static size_t
 SizeOfCategoryManagerTableEntryExcludingThis(nsDepCharHashKey::KeyType aKey,
-                                             const nsAutoPtr<CategoryNode>& aData,
+                                             const nsAutoPtr<CategoryNode> &aData,
                                              MallocSizeOf aMallocSizeOf,
                                              void* aUserArg)
 {
-  // We don't measure the string pointed to by aKey because it's a non-owning
-  // pointer.
-  return aData.get()->SizeOfExcludingThis(aMallocSizeOf);
+    // We don't measure the string pointed to by aKey because it's a non-owning
+    // pointer.
+    return aData.get()->SizeOfExcludingThis(aMallocSizeOf);
 }
 
 size_t
 nsCategoryManager::SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf)
 {
   size_t n = aMallocSizeOf(this);
 
   n += PL_SizeOfArenaPoolExcludingPool(&mArena, aMallocSizeOf);
@@ -543,183 +517,173 @@ class CategoryNotificationRunnable : pub
 {
 public:
   CategoryNotificationRunnable(nsISupports* aSubject,
                                const char* aTopic,
                                const char* aData)
     : mSubject(aSubject)
     , mTopic(aTopic)
     , mData(aData)
-  {
-  }
+  { }
 
   NS_DECL_NSIRUNNABLE
 
 private:
   nsCOMPtr<nsISupports> mSubject;
   const char* mTopic;
   NS_ConvertUTF8toUTF16 mData;
 };
 
 NS_IMETHODIMP
 CategoryNotificationRunnable::Run()
 {
   nsCOMPtr<nsIObserverService> observerService =
     mozilla::services::GetObserverService();
-  if (observerService) {
+  if (observerService)
     observerService->NotifyObservers(mSubject, mTopic, mData.get());
-  }
 
   return NS_OK;
 }
-
+  
 } // anonymous namespace
 
 
 void
-nsCategoryManager::NotifyObservers(const char* aTopic,
-                                   const char* aCategoryName,
-                                   const char* aEntryName)
+nsCategoryManager::NotifyObservers( const char *aTopic,
+                                    const char *aCategoryName,
+                                    const char *aEntryName )
 {
-  if (mSuppressNotifications) {
+  if (mSuppressNotifications)
     return;
-  }
 
   nsRefPtr<CategoryNotificationRunnable> r;
 
   if (aEntryName) {
-    nsCOMPtr<nsISupportsCString> entry =
-      do_CreateInstance(NS_SUPPORTS_CSTRING_CONTRACTID);
-    if (!entry) {
+    nsCOMPtr<nsISupportsCString> entry
+      (do_CreateInstance (NS_SUPPORTS_CSTRING_CONTRACTID));
+    if (!entry)
       return;
-    }
 
     nsresult rv = entry->SetData(nsDependentCString(aEntryName));
-    if (NS_FAILED(rv)) {
+    if (NS_FAILED(rv))
       return;
-    }
 
     r = new CategoryNotificationRunnable(entry, aTopic, aCategoryName);
   } else {
-    r = new CategoryNotificationRunnable(NS_ISUPPORTS_CAST(nsICategoryManager*,
-                                                           this),
-                                         aTopic, aCategoryName);
+    r = new CategoryNotificationRunnable(
+              NS_ISUPPORTS_CAST(nsICategoryManager*, this),
+              aTopic, aCategoryName);
   }
 
   NS_DispatchToMainThread(r);
 }
 
 NS_IMETHODIMP
-nsCategoryManager::GetCategoryEntry(const char* aCategoryName,
-                                    const char* aEntryName,
-                                    char** aResult)
+nsCategoryManager::GetCategoryEntry( const char *aCategoryName,
+                                     const char *aEntryName,
+                                     char **_retval )
 {
   if (NS_WARN_IF(!aCategoryName) ||
       NS_WARN_IF(!aEntryName) ||
-      NS_WARN_IF(!aResult)) {
-    return NS_ERROR_INVALID_ARG;
-  }
+      NS_WARN_IF(!_retval))
+    return NS_ERROR_INVALID_ARG;;
 
   nsresult status = NS_ERROR_NOT_AVAILABLE;
 
   CategoryNode* category;
   {
     MutexAutoLock lock(mLock);
     category = get_category(aCategoryName);
   }
 
   if (category) {
-    status = category->GetLeaf(aEntryName, aResult);
+    status = category->GetLeaf(aEntryName, _retval);
   }
 
   return status;
 }
 
 NS_IMETHODIMP
-nsCategoryManager::AddCategoryEntry(const char* aCategoryName,
-                                    const char* aEntryName,
-                                    const char* aValue,
-                                    bool aPersist,
-                                    bool aReplace,
-                                    char** aResult)
+nsCategoryManager::AddCategoryEntry( const char *aCategoryName,
+                                     const char *aEntryName,
+                                     const char *aValue,
+                                     bool aPersist,
+                                     bool aReplace,
+                                     char **_retval )
 {
   if (aPersist) {
     NS_ERROR("Category manager doesn't support persistence.");
     return NS_ERROR_INVALID_ARG;
   }
 
-  AddCategoryEntry(aCategoryName, aEntryName, aValue, aReplace, aResult);
+  AddCategoryEntry(aCategoryName, aEntryName, aValue, aReplace, _retval);
   return NS_OK;
 }
 
 void
-nsCategoryManager::AddCategoryEntry(const char* aCategoryName,
-                                    const char* aEntryName,
-                                    const char* aValue,
+nsCategoryManager::AddCategoryEntry(const char *aCategoryName,
+                                    const char *aEntryName,
+                                    const char *aValue,
                                     bool aReplace,
                                     char** aOldValue)
 {
-  if (aOldValue) {
+  if (aOldValue)
     *aOldValue = nullptr;
-  }
 
   // Before we can insert a new entry, we'll need to
   //  find the |CategoryNode| to put it in...
   CategoryNode* category;
   {
     MutexAutoLock lock(mLock);
     category = get_category(aCategoryName);
 
     if (!category) {
       // That category doesn't exist yet; let's make it.
       category = CategoryNode::Create(&mArena);
-
+        
       char* categoryName = ArenaStrdup(aCategoryName, &mArena);
       mTable.Put(categoryName, category);
     }
   }
 
-  if (!category) {
+  if (!category)
     return;
-  }
 
   // We will need the return value of AddLeaf even if the called doesn't want it
-  char* oldEntry = nullptr;
+  char *oldEntry = nullptr;
 
   nsresult rv = category->AddLeaf(aEntryName,
                                   aValue,
                                   aReplace,
                                   &oldEntry,
                                   &mArena);
 
   if (NS_SUCCEEDED(rv)) {
     if (oldEntry) {
       NotifyObservers(NS_XPCOM_CATEGORY_ENTRY_REMOVED_OBSERVER_ID,
                       aCategoryName, aEntryName);
     }
     NotifyObservers(NS_XPCOM_CATEGORY_ENTRY_ADDED_OBSERVER_ID,
                     aCategoryName, aEntryName);
 
-    if (aOldValue) {
+    if (aOldValue)
       *aOldValue = oldEntry;
-    } else {
+    else
       NS_Free(oldEntry);
-    }
   }
 }
 
 NS_IMETHODIMP
-nsCategoryManager::DeleteCategoryEntry(const char* aCategoryName,
-                                       const char* aEntryName,
-                                       bool aDontPersist)
+nsCategoryManager::DeleteCategoryEntry( const char *aCategoryName,
+                                        const char *aEntryName,
+                                        bool aDontPersist)
 {
   if (NS_WARN_IF(!aCategoryName) ||
-      NS_WARN_IF(!aEntryName)) {
+      NS_WARN_IF(!aEntryName))
     return NS_ERROR_INVALID_ARG;
-  }
 
   /*
     Note: no errors are reported since failure to delete
     probably won't hurt you, and returning errors seriously
     inconveniences JS clients
   */
 
   CategoryNode* category;
@@ -734,21 +698,20 @@ nsCategoryManager::DeleteCategoryEntry(c
     NotifyObservers(NS_XPCOM_CATEGORY_ENTRY_REMOVED_OBSERVER_ID,
                     aCategoryName, aEntryName);
   }
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsCategoryManager::DeleteCategory(const char* aCategoryName)
+nsCategoryManager::DeleteCategory( const char *aCategoryName )
 {
-  if (NS_WARN_IF(!aCategoryName)) {
+  if (NS_WARN_IF(!aCategoryName))
     return NS_ERROR_INVALID_ARG;
-  }
 
   // the categories are arena-allocated, so we don't
   // actually delete them. We just remove all of the
   // leaf nodes.
 
   CategoryNode* category;
   {
     MutexAutoLock lock(mLock);
@@ -760,131 +723,122 @@ nsCategoryManager::DeleteCategory(const 
     NotifyObservers(NS_XPCOM_CATEGORY_CLEARED_OBSERVER_ID,
                     aCategoryName, nullptr);
   }
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsCategoryManager::EnumerateCategory(const char* aCategoryName,
-                                     nsISimpleEnumerator** aResult)
+nsCategoryManager::EnumerateCategory( const char *aCategoryName,
+                                      nsISimpleEnumerator **_retval )
 {
   if (NS_WARN_IF(!aCategoryName) ||
-      NS_WARN_IF(!aResult)) {
+      NS_WARN_IF(!_retval))
     return NS_ERROR_INVALID_ARG;
-  }
 
   CategoryNode* category;
   {
     MutexAutoLock lock(mLock);
     category = get_category(aCategoryName);
   }
-
+  
   if (!category) {
-    return NS_NewEmptyEnumerator(aResult);
+    return NS_NewEmptyEnumerator(_retval);
   }
 
-  return category->Enumerate(aResult);
+  return category->Enumerate(_retval);
 }
 
-NS_IMETHODIMP
-nsCategoryManager::EnumerateCategories(nsISimpleEnumerator** aResult)
+NS_IMETHODIMP 
+nsCategoryManager::EnumerateCategories(nsISimpleEnumerator **_retval)
 {
-  if (NS_WARN_IF(!aResult)) {
+  if (NS_WARN_IF(!_retval))
     return NS_ERROR_INVALID_ARG;
-  }
 
   MutexAutoLock lock(mLock);
   CategoryEnumerator* enumObj = CategoryEnumerator::Create(mTable);
 
-  if (!enumObj) {
+  if (!enumObj)
     return NS_ERROR_OUT_OF_MEMORY;
-  }
 
-  *aResult = enumObj;
-  NS_ADDREF(*aResult);
+  *_retval = enumObj;
+  NS_ADDREF(*_retval);
   return NS_OK;
 }
 
-struct writecat_struct
-{
+struct writecat_struct {
   PRFileDesc* fd;
   bool        success;
 };
 
 NS_METHOD
 nsCategoryManager::SuppressNotifications(bool aSuppress)
 {
   mSuppressNotifications = aSuppress;
   return NS_OK;
 }
 
 /*
  * CreateServicesFromCategory()
  *
- * Given a category, this convenience functions enumerates the category and
+ * Given a category, this convenience functions enumerates the category and 
  * creates a service of every CID or ContractID registered under the category.
  * If observerTopic is non null and the service implements nsIObserver,
  * this will attempt to notify the observer with the origin, observerTopic string
  * as parameter.
  */
 void
-NS_CreateServicesFromCategory(const char* aCategory,
-                              nsISupports* aOrigin,
-                              const char* aObserverTopic)
+NS_CreateServicesFromCategory(const char *category,
+                              nsISupports *origin,
+                              const char *observerTopic)
 {
   nsresult rv;
 
-  nsCOMPtr<nsICategoryManager> categoryManager =
+  nsCOMPtr<nsICategoryManager> categoryManager = 
     do_GetService("@mozilla.org/categorymanager;1");
-  if (!categoryManager) {
+  if (!categoryManager)
     return;
-  }
 
   nsCOMPtr<nsISimpleEnumerator> enumerator;
-  rv = categoryManager->EnumerateCategory(aCategory,
+  rv = categoryManager->EnumerateCategory(category, 
                                           getter_AddRefs(enumerator));
-  if (NS_FAILED(rv)) {
+  if (NS_FAILED(rv))
     return;
-  }
 
   nsCOMPtr<nsIUTF8StringEnumerator> senumerator =
     do_QueryInterface(enumerator);
   if (!senumerator) {
     NS_WARNING("Category enumerator doesn't support nsIUTF8StringEnumerator.");
     return;
   }
 
   bool hasMore;
   while (NS_SUCCEEDED(senumerator->HasMore(&hasMore)) && hasMore) {
     // From here on just skip any error we get.
     nsAutoCString entryString;
-    if (NS_FAILED(senumerator->GetNext(entryString))) {
+    if (NS_FAILED(senumerator->GetNext(entryString)))
       continue;
-    }
-
+      
     nsXPIDLCString contractID;
-    rv = categoryManager->GetCategoryEntry(aCategory, entryString.get(),
+    rv = categoryManager->GetCategoryEntry(category,entryString.get(),
                                            getter_Copies(contractID));
-    if (NS_FAILED(rv)) {
+    if (NS_FAILED(rv))
       continue;
-    }
 
     nsCOMPtr<nsISupports> instance = do_GetService(contractID);
     if (!instance) {
       LogMessage("While creating services from category '%s', could not create service for entry '%s', contract ID '%s'",
-                 aCategory, entryString.get(), contractID.get());
+                 category, entryString.get(), contractID.get());
       continue;
     }
 
-    if (aObserverTopic) {
+    if (observerTopic) {
       // try an observer, if it implements it.
       nsCOMPtr<nsIObserver> observer = do_QueryInterface(instance);
-      if (observer) {
-        observer->Observe(aOrigin, aObserverTopic, EmptyString().get());
-      } else {
+      if (observer)
+        observer->Observe(origin, observerTopic, EmptyString().get());
+      else
         LogMessage("While creating services from category '%s', service for entry '%s', contract ID '%s' does not implement nsIObserver.",
-                   aCategory, entryString.get(), contractID.get());
-      }
+                   category, entryString.get(), contractID.get());
     }
   }
 }
--- a/xpcom/components/nsCategoryManager.h
+++ b/xpcom/components/nsCategoryManager.h
@@ -29,64 +29,66 @@ class nsIMemoryReporter;
  * we need to keep a "persistent value" (which will be written to the registry)
  * and a non-persistent value (for the current runtime): these are usually
  * the same, except when aPersist==false. The strings are permanently arena-
  * allocated, and will never go away.
  */
 class CategoryLeaf : public nsDepCharHashKey
 {
 public:
-  CategoryLeaf(const char* aKey) : nsDepCharHashKey(aKey), value(nullptr) {}
+  CategoryLeaf(const char* aKey)
+    : nsDepCharHashKey(aKey),
+      value(nullptr) { }
   const char* value;
 };
 
 
 /**
  * CategoryNode keeps a hashtable of its entries.
  * the CategoryNode itself is permanently allocated in
  * the arena.
  */
 class CategoryNode
 {
 public:
   NS_METHOD GetLeaf(const char* aEntryName,
-                    char** aResult);
+                    char** _retval);
 
   NS_METHOD AddLeaf(const char* aEntryName,
                     const char* aValue,
                     bool aReplace,
-                    char** aResult,
+                    char** _retval,
                     PLArenaPool* aArena);
 
   void DeleteLeaf(const char* aEntryName);
 
-  void Clear()
-  {
+  void Clear() {
     mozilla::MutexAutoLock lock(mLock);
     mTable.Clear();
   }
 
-  uint32_t Count()
-  {
+  uint32_t Count() {
     mozilla::MutexAutoLock lock(mLock);
     uint32_t tCount = mTable.Count();
     return tCount;
   }
 
-  NS_METHOD Enumerate(nsISimpleEnumerator** aResult);
+  NS_METHOD Enumerate(nsISimpleEnumerator** _retval);
 
   // CategoryNode is arena-allocated, with the strings
   static CategoryNode* Create(PLArenaPool* aArena);
   ~CategoryNode();
-  void operator delete(void*) {}
+  void operator delete(void*) { }
 
   size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf);
 
 private:
-  CategoryNode() : mLock("CategoryLeaf") {}
+  CategoryNode()
+    : mLock("CategoryLeaf")
+  { }
 
   void* operator new(size_t aSize, PLArenaPool* aArena);
 
   nsTHashtable<CategoryLeaf> mTable;
   mozilla::Mutex mLock;
 };
 
 
--- a/xpcom/components/nsCategoryManagerUtils.h
+++ b/xpcom/components/nsCategoryManagerUtils.h
@@ -4,13 +4,13 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef nsCategoryManagerUtils_h__
 #define nsCategoryManagerUtils_h__
 
 #include "nsICategoryManager.h"
 
 void
-NS_CreateServicesFromCategory(const char* aCategory,
-                              nsISupports* aOrigin,
-                              const char* aObserverTopic);
+NS_CreateServicesFromCategory(const char *category,
+                              nsISupports *origin,
+                              const char *observerTopic);
 
 #endif
--- a/xpcom/components/nsComponentManager.cpp
+++ b/xpcom/components/nsComponentManager.cpp
@@ -86,207 +86,193 @@ PRLogModuleInfo* nsComponentManagerLog =
 #endif
 
 // Bloated registry buffer size to improve startup performance -- needs to
 // be big enough to fit the entire file into memory or it'll thrash.
 // 512K is big enough to allow for some future growth in the registry.
 #define BIG_REGISTRY_BUFLEN   (512*1024)
 
 // Common Key Names
-const char xpcomComponentsKeyName[] = "software/mozilla/XPCOM/components";
-const char xpcomKeyName[] = "software/mozilla/XPCOM";
+const char xpcomComponentsKeyName[]="software/mozilla/XPCOM/components";
+const char xpcomKeyName[]="software/mozilla/XPCOM";
 
 // Common Value Names
-const char fileSizeValueName[] = "FileSize";
-const char lastModValueName[] = "LastModTimeStamp";
-const char nativeComponentType[] = "application/x-mozilla-native";
-const char staticComponentType[] = "application/x-mozilla-static";
+const char fileSizeValueName[]="FileSize";
+const char lastModValueName[]="LastModTimeStamp";
+const char nativeComponentType[]="application/x-mozilla-native";
+const char staticComponentType[]="application/x-mozilla-static";
 
 NS_DEFINE_CID(kCategoryManagerCID, NS_CATEGORYMANAGER_CID);
 
 #define UID_STRING_LENGTH 39
 
 nsresult
-nsGetServiceFromCategory::operator()(const nsIID& aIID,
-                                     void** aInstancePtr) const
+nsGetServiceFromCategory::operator()(const nsIID& aIID, void** aInstancePtr) const
 {
-  nsresult rv;
-  nsXPIDLCString value;
-  nsCOMPtr<nsICategoryManager> catman;
-  nsComponentManagerImpl* compMgr = nsComponentManagerImpl::gComponentManager;
-  if (!compMgr) {
-    rv = NS_ERROR_NOT_INITIALIZED;
-    goto error;
-  }
+    nsresult rv;
+    nsXPIDLCString value;
+    nsCOMPtr<nsICategoryManager> catman;
+    nsComponentManagerImpl *compMgr = nsComponentManagerImpl::gComponentManager;
+    if (!compMgr) {
+        rv = NS_ERROR_NOT_INITIALIZED;
+        goto error;
+    }
 
-  if (!mCategory || !mEntry) {
-    // when categories have defaults, use that for null mEntry
-    rv = NS_ERROR_NULL_POINTER;
-    goto error;
-  }
+    if (!mCategory || !mEntry) {
+        // when categories have defaults, use that for null mEntry
+        rv = NS_ERROR_NULL_POINTER;
+        goto error;
+    }
 
-  rv = compMgr->nsComponentManagerImpl::GetService(kCategoryManagerCID,
-                                                   NS_GET_IID(nsICategoryManager),
-                                                   getter_AddRefs(catman));
-  if (NS_FAILED(rv)) {
-    goto error;
-  }
+    rv = compMgr->nsComponentManagerImpl::GetService(kCategoryManagerCID,
+                                                     NS_GET_IID(nsICategoryManager),
+                                                     getter_AddRefs(catman));
+    if (NS_FAILED(rv)) goto error;
 
-  /* find the contractID for category.entry */
-  rv = catman->GetCategoryEntry(mCategory, mEntry,
-                                getter_Copies(value));
-  if (NS_FAILED(rv)) {
-    goto error;
-  }
-  if (!value) {
-    rv = NS_ERROR_SERVICE_NOT_AVAILABLE;
-    goto error;
-  }
+    /* find the contractID for category.entry */
+    rv = catman->GetCategoryEntry(mCategory, mEntry,
+                                  getter_Copies(value));
+    if (NS_FAILED(rv)) goto error;
+    if (!value) {
+        rv = NS_ERROR_SERVICE_NOT_AVAILABLE;
+        goto error;
+    }
 
-  rv = compMgr->nsComponentManagerImpl::GetServiceByContractID(value,
-                                                               aIID,
-                                                               aInstancePtr);
-  if (NS_FAILED(rv)) {
-error:
-    *aInstancePtr = 0;
-  }
-  if (mErrorPtr) {
-    *mErrorPtr = rv;
-  }
-  return rv;
+    rv = compMgr->
+        nsComponentManagerImpl::GetServiceByContractID(value,
+                                                       aIID, aInstancePtr);
+    if (NS_FAILED(rv)) {
+    error:
+        *aInstancePtr = 0;
+    }
+    if (mErrorPtr)
+        *mErrorPtr = rv;
+    return rv;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Arena helper functions
 ////////////////////////////////////////////////////////////////////////////////
-char*
-ArenaStrndup(const char* aStr, uint32_t aLen, PLArenaPool* aArena)
+char *
+ArenaStrndup(const char *s, uint32_t len, PLArenaPool *arena)
 {
-  void* mem;
-  // Include trailing null in the aLen
-  PL_ARENA_ALLOCATE(mem, aArena, aLen + 1);
-  if (mem) {
-    memcpy(mem, aStr, aLen + 1);
-  }
-  return static_cast<char*>(mem);
+    void *mem;
+    // Include trailing null in the len
+    PL_ARENA_ALLOCATE(mem, arena, len+1);
+    if (mem)
+        memcpy(mem, s, len+1);
+    return static_cast<char *>(mem);
 }
 
 char*
-ArenaStrdup(const char* aStr, PLArenaPool* aArena)
+ArenaStrdup(const char *s, PLArenaPool *arena)
 {
-  return ArenaStrndup(aStr, strlen(aStr), aArena);
+    return ArenaStrndup(s, strlen(s), arena);
 }
 
 // GetService and a few other functions need to exit their mutex mid-function
 // without reentering it later in the block. This class supports that
 // style of early-exit that MutexAutoUnlock doesn't.
 
 namespace {
 
 class MOZ_STACK_CLASS MutexLock
 {
 public:
-  MutexLock(SafeMutex& aMutex)
-    : mMutex(aMutex)
-    , mLocked(false)
-  {
-    Lock();
-  }
+    MutexLock(SafeMutex& aMutex)
+        : mMutex(aMutex)
+        , mLocked(false)
+    {
+        Lock();
+    }
 
-  ~MutexLock()
-  {
-    if (mLocked) {
-      Unlock();
+    ~MutexLock()
+    {
+        if (mLocked)
+            Unlock();
     }
-  }
 
-  void Lock()
-  {
-    NS_ASSERTION(!mLocked, "Re-entering a mutex");
-    mMutex.Lock();
-    mLocked = true;
-  }
+    void Lock()
+    {
+        NS_ASSERTION(!mLocked, "Re-entering a mutex");
+        mMutex.Lock();
+        mLocked = true;
+    }
 
-  void Unlock()
-  {
-    NS_ASSERTION(mLocked, "Exiting a mutex that isn't held!");
-    mMutex.Unlock();
-    mLocked = false;
-  }
+    void Unlock()
+    {
+        NS_ASSERTION(mLocked, "Exiting a mutex that isn't held!");
+        mMutex.Unlock();
+        mLocked = false;
+    }
 
 private:
-  SafeMutex& mMutex;
-  bool mLocked;
+    SafeMutex& mMutex;
+    bool mLocked;
 };
 
 } // anonymous namespace
 
 // this is safe to call during InitXPCOM
 static already_AddRefed<nsIFile>
-GetLocationFromDirectoryService(const char* aProp)
+GetLocationFromDirectoryService(const char* prop)
 {
-  nsCOMPtr<nsIProperties> directoryService;
-  nsDirectoryService::Create(nullptr,
-                             NS_GET_IID(nsIProperties),
-                             getter_AddRefs(directoryService));
+    nsCOMPtr<nsIProperties> directoryService;
+    nsDirectoryService::Create(nullptr,
+                               NS_GET_IID(nsIProperties),
+                               getter_AddRefs(directoryService));
 
-  if (!directoryService) {
-    return nullptr;
-  }
+    if (!directoryService)
+        return nullptr;
 
-  nsCOMPtr<nsIFile> file;
-  nsresult rv = directoryService->Get(aProp,
-                                      NS_GET_IID(nsIFile),
-                                      getter_AddRefs(file));
-  if (NS_FAILED(rv)) {
-    return nullptr;
-  }
+    nsCOMPtr<nsIFile> file;
+    nsresult rv = directoryService->Get(prop,
+                                        NS_GET_IID(nsIFile),
+                                        getter_AddRefs(file));
+    if (NS_FAILED(rv))
+        return nullptr;
 
-  return file.forget();
+    return file.forget();
 }
 
 static already_AddRefed<nsIFile>
-CloneAndAppend(nsIFile* aBase, const nsACString& aAppend)
+CloneAndAppend(nsIFile* aBase, const nsACString& append)
 {
-  nsCOMPtr<nsIFile> f;
-  aBase->Clone(getter_AddRefs(f));
-  if (!f) {
-    return nullptr;
-  }
+    nsCOMPtr<nsIFile> f;
+    aBase->Clone(getter_AddRefs(f));
+    if (!f)
+        return nullptr;
 
-  f->AppendNative(aAppend);
-  return f.forget();
+    f->AppendNative(append);
+    return f.forget();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // nsComponentManagerImpl
 ////////////////////////////////////////////////////////////////////////////////
 
 nsresult
-nsComponentManagerImpl::Create(nsISupports* aOuter, REFNSIID aIID,
-                               void** aResult)
+nsComponentManagerImpl::Create(nsISupports* aOuter, REFNSIID aIID, void** aResult)
 {
-  if (aOuter) {
-    return NS_ERROR_NO_AGGREGATION;
-  }
+    if (aOuter)
+        return NS_ERROR_NO_AGGREGATION;
 
-  if (!gComponentManager) {
-    return NS_ERROR_FAILURE;
-  }
+    if (!gComponentManager)
+        return NS_ERROR_FAILURE;
 
-  return gComponentManager->QueryInterface(aIID, aResult);
+    return gComponentManager->QueryInterface(aIID, aResult);
 }
 
 static const int CONTRACTID_HASHTABLE_INITIAL_SIZE = 2048;
 
 nsComponentManagerImpl::nsComponentManagerImpl()
-  : mFactories(CONTRACTID_HASHTABLE_INITIAL_SIZE)
-  , mContractIDs(CONTRACTID_HASHTABLE_INITIAL_SIZE)
-  , mLock("nsComponentManagerImpl.mLock")
-  , mStatus(NOT_INITIALIZED)
+    : mFactories(CONTRACTID_HASHTABLE_INITIAL_SIZE)
+    , mContractIDs(CONTRACTID_HASHTABLE_INITIAL_SIZE)
+    , mLock("nsComponentManagerImpl.mLock")
+    , mStatus(NOT_INITIALIZED)
 {
 }
 
 nsTArray<const mozilla::Module*>* nsComponentManagerImpl::sStaticModules;
 
 NSMODULE_DEFN(start_kPStaticModules);
 NSMODULE_DEFN(end_kPStaticModules);
 
@@ -294,884 +280,850 @@ NSMODULE_DEFN(end_kPStaticModules);
  * by the linker from various objects containing symbols in a specific section.
  * ASAN considers (rightfully) the use of this content as a global buffer
  * overflow. But this is a deliberate and well-considered choice, with no proper
  * way to make ASAN happy. */
 MOZ_ASAN_BLACKLIST
 /* static */ void
 nsComponentManagerImpl::InitializeStaticModules()
 {
-  if (sStaticModules) {
-    return;
-  }
+    if (sStaticModules)
+        return;
 
-  sStaticModules = new nsTArray<const mozilla::Module*>;
-  for (const mozilla::Module * const* staticModules =
-         &NSMODULE_NAME(start_kPStaticModules) + 1;
-       staticModules < &NSMODULE_NAME(end_kPStaticModules); ++staticModules)
-    if (*staticModules) { // ASAN adds padding
-      sStaticModules->AppendElement(*staticModules);
-    }
+    sStaticModules = new nsTArray<const mozilla::Module*>;
+    for (const mozilla::Module *const *staticModules = &NSMODULE_NAME(start_kPStaticModules) + 1;
+         staticModules < &NSMODULE_NAME(end_kPStaticModules); ++staticModules)
+        if (*staticModules) // ASAN adds padding
+            sStaticModules->AppendElement(*staticModules);
 }
 
 nsTArray<nsComponentManagerImpl::ComponentLocation>*
 nsComponentManagerImpl::sModuleLocations;
 
 /* static */ void
 nsComponentManagerImpl::InitializeModuleLocations()
 {
-  if (sModuleLocations) {
-    return;
-  }
+    if (sModuleLocations)
+        return;
 
-  sModuleLocations = new nsTArray<ComponentLocation>;
+    sModuleLocations = new nsTArray<ComponentLocation>;
 }
 
-nsresult
-nsComponentManagerImpl::Init()
+nsresult nsComponentManagerImpl::Init()
 {
-  PR_ASSERT(NOT_INITIALIZED == mStatus);
+    PR_ASSERT(NOT_INITIALIZED == mStatus);
 
-  if (!nsComponentManagerLog) {
-    nsComponentManagerLog = PR_NewLogModule("nsComponentManager");
-  }
+    if (nsComponentManagerLog == nullptr)
+    {
+        nsComponentManagerLog = PR_NewLogModule("nsComponentManager");
+    }
 
-  // Initialize our arena
-  PL_INIT_ARENA_POOL(&mArena, "ComponentManagerArena", NS_CM_BLOCK_SIZE);
+    // Initialize our arena
+    PL_INIT_ARENA_POOL(&mArena, "ComponentManagerArena", NS_CM_BLOCK_SIZE);
 
-  nsCOMPtr<nsIFile> greDir =
-    GetLocationFromDirectoryService(NS_GRE_DIR);
-  nsCOMPtr<nsIFile> appDir =
-    GetLocationFromDirectoryService(NS_XPCOM_CURRENT_PROCESS_DIR);
+    nsCOMPtr<nsIFile> greDir =
+        GetLocationFromDirectoryService(NS_GRE_DIR);
+    nsCOMPtr<nsIFile> appDir =
+        GetLocationFromDirectoryService(NS_XPCOM_CURRENT_PROCESS_DIR);
 
-  InitializeStaticModules();
-  InitializeModuleLocations();
+    InitializeStaticModules();
+    InitializeModuleLocations();
 
-  ComponentLocation* cl = sModuleLocations->InsertElementAt(0);
-  nsCOMPtr<nsIFile> lf = CloneAndAppend(appDir,
-                                        NS_LITERAL_CSTRING("chrome.manifest"));
-  cl->type = NS_COMPONENT_LOCATION;
-  cl->location.Init(lf);
+    ComponentLocation* cl = sModuleLocations->InsertElementAt(0);
+    nsCOMPtr<nsIFile> lf = CloneAndAppend(appDir, NS_LITERAL_CSTRING("chrome.manifest"));
+    cl->type = NS_COMPONENT_LOCATION;
+    cl->location.Init(lf);
 
-  bool equals = false;
-  appDir->Equals(greDir, &equals);
-  if (!equals) {
-    cl = sModuleLocations->InsertElementAt(0);
-    cl->type = NS_COMPONENT_LOCATION;
-    lf = CloneAndAppend(greDir, NS_LITERAL_CSTRING("chrome.manifest"));
-    cl->location.Init(lf);
-  }
+    bool equals = false;
+    appDir->Equals(greDir, &equals);
+    if (!equals) {
+        cl = sModuleLocations->InsertElementAt(0);
+        cl->type = NS_COMPONENT_LOCATION;
+        lf = CloneAndAppend(greDir, NS_LITERAL_CSTRING("chrome.manifest"));
+        cl->location.Init(lf);
+    }
 
-  PR_LOG(nsComponentManagerLog, PR_LOG_DEBUG,
-         ("nsComponentManager: Initialized."));
+    PR_LOG(nsComponentManagerLog, PR_LOG_DEBUG,
+           ("nsComponentManager: Initialized."));
 
-  nsresult rv = mNativeModuleLoader.Init();
-  if (NS_FAILED(rv)) {
-    return rv;
-  }
+    nsresult rv = mNativeModuleLoader.Init();
+    if (NS_FAILED(rv))
+        return rv;
 
-  nsCategoryManager::GetSingleton()->SuppressNotifications(true);
-
-  RegisterModule(&kXPCOMModule, nullptr);
+    nsCategoryManager::GetSingleton()->SuppressNotifications(true);
 
-  for (uint32_t i = 0; i < sStaticModules->Length(); ++i) {
-    RegisterModule((*sStaticModules)[i], nullptr);
-  }
+    RegisterModule(&kXPCOMModule, nullptr);
+
+    for (uint32_t i = 0; i < sStaticModules->Length(); ++i)
+        RegisterModule((*sStaticModules)[i], nullptr);
 
-  nsRefPtr<nsZipArchive> appOmnijar =
-    mozilla::Omnijar::GetReader(mozilla::Omnijar::APP);
-  if (appOmnijar) {
-    cl = sModuleLocations->InsertElementAt(1); // Insert after greDir
-    cl->type = NS_COMPONENT_LOCATION;
-    cl->location.Init(appOmnijar, "chrome.manifest");
-  }
-  nsRefPtr<nsZipArchive> greOmnijar =
-    mozilla::Omnijar::GetReader(mozilla::Omnijar::GRE);
-  if (greOmnijar) {
-    cl = sModuleLocations->InsertElementAt(0);
-    cl->type = NS_COMPONENT_LOCATION;
-    cl->location.Init(greOmnijar, "chrome.manifest");
-  }
+    nsRefPtr<nsZipArchive> appOmnijar = mozilla::Omnijar::GetReader(mozilla::Omnijar::APP);
+    if (appOmnijar) {
+        cl = sModuleLocations->InsertElementAt(1); // Insert after greDir
+        cl->type = NS_COMPONENT_LOCATION;
+        cl->location.Init(appOmnijar, "chrome.manifest");
+    }
+    nsRefPtr<nsZipArchive> greOmnijar = mozilla::Omnijar::GetReader(mozilla::Omnijar::GRE);
+    if (greOmnijar) {
+        cl = sModuleLocations->InsertElementAt(0);
+        cl->type = NS_COMPONENT_LOCATION;
+        cl->location.Init(greOmnijar, "chrome.manifest");
+    }
 
-  RereadChromeManifests(false);
+    RereadChromeManifests(false);
 
-  nsCategoryManager::GetSingleton()->SuppressNotifications(false);
+    nsCategoryManager::GetSingleton()->SuppressNotifications(false);
 
-  RegisterWeakMemoryReporter(this);
+    RegisterWeakMemoryReporter(this);
 
-  // Unfortunately, we can't register the nsCategoryManager memory reporter
-  // in its constructor (which is triggered by the GetSingleton() call
-  // above) because the memory reporter manager isn't initialized at that
-  // point.  So we wait until now.
-  nsCategoryManager::GetSingleton()->InitMemoryReporter();
+    // Unfortunately, we can't register the nsCategoryManager memory reporter
+    // in its constructor (which is triggered by the GetSingleton() call
+    // above) because the memory reporter manager isn't initialized at that
+    // point.  So we wait until now.
+    nsCategoryManager::GetSingleton()->InitMemoryReporter();
 
-  mStatus = NORMAL;
+    mStatus = NORMAL;
 
-  return NS_OK;
+    return NS_OK;
 }
 
 void
 nsComponentManagerImpl::RegisterModule(const mozilla::Module* aModule,
                                        FileLocation* aFile)
 {
-  mLock.AssertNotCurrentThreadOwns();
+    mLock.AssertNotCurrentThreadOwns();
+
+    {
+        // Scope the monitor so that we don't hold it while calling into the
+        // category manager.
+        MutexLock lock(mLock);
 
-  {
-    // Scope the monitor so that we don't hold it while calling into the
-    // category manager.
-    MutexLock lock(mLock);
+        KnownModule* m;
+        if (aFile) {
+            nsCString uri;
+            aFile->GetURIString(uri);
+            NS_ASSERTION(!mKnownModules.Get(uri),
+                         "Must not register a binary module twice.");
 
-    KnownModule* m;
-    if (aFile) {
-      nsCString uri;
-      aFile->GetURIString(uri);
-      NS_ASSERTION(!mKnownModules.Get(uri),
-                   "Must not register a binary module twice.");
+            m = new KnownModule(aModule, *aFile);
+            mKnownModules.Put(uri, m);
+        } else {
+            m = new KnownModule(aModule);
+            mKnownStaticModules.AppendElement(m);
+        }
 
-      m = new KnownModule(aModule, *aFile);
-      mKnownModules.Put(uri, m);
-    } else {
-      m = new KnownModule(aModule);
-      mKnownStaticModules.AppendElement(m);
+        if (aModule->mCIDs) {
+            const mozilla::Module::CIDEntry* entry;
+            for (entry = aModule->mCIDs; entry->cid; ++entry)
+                RegisterCIDEntryLocked(entry, m);
+        }
+
+        if (aModule->mContractIDs) {
+            const mozilla::Module::ContractIDEntry* entry;
+            for (entry = aModule->mContractIDs; entry->contractid; ++entry)
+                RegisterContractIDLocked(entry);
+            MOZ_ASSERT(!entry->cid, "Incorrectly terminated contract list");
+        }
     }
 
-    if (aModule->mCIDs) {
-      const mozilla::Module::CIDEntry* entry;
-      for (entry = aModule->mCIDs; entry->cid; ++entry) {
-        RegisterCIDEntryLocked(entry, m);
-      }
+    if (aModule->mCategoryEntries) {
+        const mozilla::Module::CategoryEntry* entry;
+        for (entry = aModule->mCategoryEntries; entry->category; ++entry)
+            nsCategoryManager::GetSingleton()->
+                AddCategoryEntry(entry->category,
+                                 entry->entry,
+                                 entry->value);
     }
-
-    if (aModule->mContractIDs) {
-      const mozilla::Module::ContractIDEntry* entry;
-      for (entry = aModule->mContractIDs; entry->contractid; ++entry) {
-        RegisterContractIDLocked(entry);
-      }
-      MOZ_ASSERT(!entry->cid, "Incorrectly terminated contract list");
-    }
-  }
-
-  if (aModule->mCategoryEntries) {
-    const mozilla::Module::CategoryEntry* entry;
-    for (entry = aModule->mCategoryEntries; entry->category; ++entry)
-      nsCategoryManager::GetSingleton()->AddCategoryEntry(entry->category,
-                                                          entry->entry,
-                                                          entry->value);
-  }
 }
 
 static bool
-ProcessSelectorMatches(Module::ProcessSelector aSelector)
+ProcessSelectorMatches(Module::ProcessSelector selector)
 {
-  if (aSelector == Module::ANY_PROCESS) {
-    return true;
-  }
+    if (selector == Module::ANY_PROCESS) {
+        return true;
+    }
 
-  GeckoProcessType type = XRE_GetProcessType();
-  switch (aSelector) {
-    case Module::MAIN_PROCESS_ONLY:
-      return type == GeckoProcessType_Default;
-    case Module::CONTENT_PROCESS_ONLY:
-      return type == GeckoProcessType_Content;
-    default:
-      MOZ_CRASH("invalid process aSelector");
-  }
+    GeckoProcessType type = XRE_GetProcessType();
+    switch (selector) {
+      case Module::MAIN_PROCESS_ONLY:
+        return type == GeckoProcessType_Default;
+      case Module::CONTENT_PROCESS_ONLY:
+        return type == GeckoProcessType_Content;
+      default:
+        MOZ_CRASH("invalid process selector");
+    }
 }
 
 void
 nsComponentManagerImpl::RegisterCIDEntryLocked(
     const mozilla::Module::CIDEntry* aEntry,
     KnownModule* aModule)
 {
-  mLock.AssertCurrentThreadOwns();
+    mLock.AssertCurrentThreadOwns();
 
-  if (!ProcessSelectorMatches(aEntry->processSelector)) {
-    return;
-  }
+    if (!ProcessSelectorMatches(aEntry->processSelector)) {
+        return;
+    }
 
-  nsFactoryEntry* f = mFactories.Get(*aEntry->cid);
-  if (f) {
-    NS_WARNING("Re-registering a CID?");
+    nsFactoryEntry* f = mFactories.Get(*aEntry->cid);
+    if (f) {
+        NS_WARNING("Re-registering a CID?");
 
-    char idstr[NSID_LENGTH];
-    aEntry->cid->ToProvidedString(idstr);
+        char idstr[NSID_LENGTH];
+        aEntry->cid->ToProvidedString(idstr);
 
-    nsCString existing;
-    if (f->mModule) {
-      existing = f->mModule->Description();
-    } else {
-      existing = "<unknown module>";
+        nsCString existing;
+        if (f->mModule)
+            existing = f->mModule->Description();
+        else
+            existing = "<unknown module>";
+        SafeMutexAutoUnlock unlock(mLock);
+        LogMessage("While registering XPCOM module %s, trying to re-register CID '%s' already registered by %s.",
+                   aModule->Description().get(),
+                   idstr,
+                   existing.get());
+        return;
     }
-    SafeMutexAutoUnlock unlock(mLock);
-    LogMessage("While registering XPCOM module %s, trying to re-register CID '%s' already registered by %s.",
-               aModule->Description().get(),
-               idstr,
-               existing.get());
-    return;
-  }
 
-  f = new nsFactoryEntry(aEntry, aModule);
-  mFactories.Put(*aEntry->cid, f);
+    f = new nsFactoryEntry(aEntry, aModule);
+    mFactories.Put(*aEntry->cid, f);
 }
 
 void
 nsComponentManagerImpl::RegisterContractIDLocked(
     const mozilla::Module::ContractIDEntry* aEntry)
 {
-  mLock.AssertCurrentThreadOwns();
+    mLock.AssertCurrentThreadOwns();
 
-  if (!ProcessSelectorMatches(aEntry->processSelector)) {
-    return;
-  }
+    if (!ProcessSelectorMatches(aEntry->processSelector)) {
+        return;
+    }
 
-  nsFactoryEntry* f = mFactories.Get(*aEntry->cid);
-  if (!f) {
-    NS_ERROR("No CID found when attempting to map contract ID");
+    nsFactoryEntry* f = mFactories.Get(*aEntry->cid);
+    if (!f) {
+        NS_ERROR("No CID found when attempting to map contract ID");
 
-    char idstr[NSID_LENGTH];
-    aEntry->cid->ToProvidedString(idstr);
+        char idstr[NSID_LENGTH];
+        aEntry->cid->ToProvidedString(idstr);
 
-    LogMessage("Could not map contract ID '%s' to CID %s because no implementation of the CID is registered.",
-               aEntry->contractid,
-               idstr);
+        LogMessage("Could not map contract ID '%s' to CID %s because no implementation of the CID is registered.",
+                   aEntry->contractid,
+                   idstr);
+                   
+        return;
+    }
 
-    return;
-  }
-
-  mContractIDs.Put(nsDependentCString(aEntry->contractid), f);
+    mContractIDs.Put(nsDependentCString(aEntry->contractid), f);
 }
 
 static void
-CutExtension(nsCString& aPath)
+CutExtension(nsCString& path)
 {
-  int32_t dotPos = aPath.RFindChar('.');
-  if (kNotFound == dotPos) {
-    aPath.Truncate();
-  } else {
-    aPath.Cut(0, dotPos + 1);
-  }
+    int32_t dotPos = path.RFindChar('.');
+    if (kNotFound == dotPos)
+        path.Truncate();
+    else
+        path.Cut(0, dotPos + 1);
 }
 
 void
 nsComponentManagerImpl::RegisterManifest(NSLocationType aType,
-                                         FileLocation& aFile,
+                                         FileLocation &aFile,
                                          bool aChromeOnly)
 {
-  uint32_t len;
-  FileLocation::Data data;
-  nsAutoArrayPtr<char> buf;
-  nsresult rv = aFile.GetData(data);
-  if (NS_SUCCEEDED(rv)) {
-    rv = data.GetSize(&len);
-  }
-  if (NS_SUCCEEDED(rv)) {
-    buf = new char[len + 1];
-    rv = data.Copy(buf, len);
-  }
-  if (NS_SUCCEEDED(rv)) {
-    buf[len] = '\0';
-    ParseManifest(aType, aFile, buf, aChromeOnly);
-  } else if (NS_BOOTSTRAPPED_LOCATION != aType) {
-    nsCString uri;
-    aFile.GetURIString(uri);
-    LogMessage("Could not read chrome manifest '%s'.", uri.get());
-  }
+    uint32_t len;
+    FileLocation::Data data;
+    nsAutoArrayPtr<char> buf;
+    nsresult rv = aFile.GetData(data);
+    if (NS_SUCCEEDED(rv)) {
+        rv = data.GetSize(&len);
+    }
+    if (NS_SUCCEEDED(rv)) {
+        buf = new char[len + 1];
+        rv = data.Copy(buf, len);
+    }
+    if (NS_SUCCEEDED(rv)) {
+        buf[len] = '\0';
+        ParseManifest(aType, aFile, buf, aChromeOnly);
+    } else if (NS_BOOTSTRAPPED_LOCATION != aType) {
+        nsCString uri;
+        aFile.GetURIString(uri);
+        LogMessage("Could not read chrome manifest '%s'.", uri.get());
+    }
 }
 
 void
-nsComponentManagerImpl::ManifestManifest(ManifestProcessingContext& aCx,
-                                         int aLineNo, char* const* aArgv)
+nsComponentManagerImpl::ManifestManifest(ManifestProcessingContext& cx, int lineno, char *const * argv)
 {
-  char* file = aArgv[0];
-  FileLocation f(aCx.mFile, file);
-  RegisterManifest(aCx.mType, f, aCx.mChromeOnly);
+    char* file = argv[0];
+    FileLocation f(cx.mFile, file);
+    RegisterManifest(cx.mType, f, cx.mChromeOnly);
 }
 
 void
-nsComponentManagerImpl::ManifestBinaryComponent(ManifestProcessingContext& aCx,
-                                                int aLineNo,
-                                                char* const* aArgv)
+nsComponentManagerImpl::ManifestBinaryComponent(ManifestProcessingContext& cx, int lineno, char *const * argv)
 {
-  if (aCx.mFile.IsZip()) {
-    NS_WARNING("Cannot load binary components from a jar.");
-    LogMessageWithContext(aCx.mFile, aLineNo,
-                          "Cannot load binary components from a jar.");
-    return;
-  }
+    if (cx.mFile.IsZip()) {
+        NS_WARNING("Cannot load binary components from a jar.");
+        LogMessageWithContext(cx.mFile, lineno,
+                              "Cannot load binary components from a jar.");
+        return;
+    }
 
-  FileLocation f(aCx.mFile, aArgv[0]);
-  nsCString uri;
-  f.GetURIString(uri);
+    FileLocation f(cx.mFile, argv[0]);
+    nsCString uri;
+    f.GetURIString(uri);
 
-  if (mKnownModules.Get(uri)) {
-    NS_WARNING("Attempting to register a binary component twice.");
-    LogMessageWithContext(aCx.mFile, aLineNo,
-                          "Attempting to register a binary component twice.");
-    return;
-  }
+    if (mKnownModules.Get(uri)) {
+        NS_WARNING("Attempting to register a binary component twice.");
+        LogMessageWithContext(cx.mFile, lineno,
+                              "Attempting to register a binary component twice.");
+        return;
+    }
 
-  const mozilla::Module* m = mNativeModuleLoader.LoadModule(f);
-  // The native module loader should report an error here, we don't have to
-  if (!m) {
-    return;
-  }
+    const mozilla::Module* m = mNativeModuleLoader.LoadModule(f);
+    // The native module loader should report an error here, we don't have to
+    if (!m)
+        return;
 
-  RegisterModule(m, &f);
+    RegisterModule(m, &f);
 }
 
 void
-nsComponentManagerImpl::ManifestXPT(ManifestProcessingContext& aCx, int aLineNo,
-                                    char* const* aArgv)
+nsComponentManagerImpl::ManifestXPT(ManifestProcessingContext& cx, int lineno, char *const * argv)
 {
-  FileLocation f(aCx.mFile, aArgv[0]);
-  uint32_t len;
-  FileLocation::Data data;
-  nsAutoArrayPtr<char> buf;
-  nsresult rv = f.GetData(data);
-  if (NS_SUCCEEDED(rv)) {
-    rv = data.GetSize(&len);
-  }
-  if (NS_SUCCEEDED(rv)) {
-    buf = new char[len];
-    rv = data.Copy(buf, len);
-  }
-  if (NS_SUCCEEDED(rv)) {
-    XPTInterfaceInfoManager::GetSingleton()->RegisterBuffer(buf, len);
-  } else {
-    nsCString uri;
-    f.GetURIString(uri);
-    LogMessage("Could not read '%s'.", uri.get());
-  }
+    FileLocation f(cx.mFile, argv[0]);
+    uint32_t len;
+    FileLocation::Data data;
+    nsAutoArrayPtr<char> buf;
+    nsresult rv = f.GetData(data);
+    if (NS_SUCCEEDED(rv)) {
+        rv = data.GetSize(&len);
+    }
+    if (NS_SUCCEEDED(rv)) {
+        buf = new char[len];
+        rv = data.Copy(buf, len);
+    }
+    if (NS_SUCCEEDED(rv)) {
+        XPTInterfaceInfoManager::GetSingleton()->RegisterBuffer(buf, len);
+    } else {
+        nsCString uri;
+        f.GetURIString(uri);
+        LogMessage("Could not read '%s'.", uri.get());
+    }
 }
 
 void
-nsComponentManagerImpl::ManifestComponent(ManifestProcessingContext& aCx,
-                                          int aLineNo, char* const* aArgv)
+nsComponentManagerImpl::ManifestComponent(ManifestProcessingContext& cx, int lineno, char *const * argv)
 {
-  mLock.AssertNotCurrentThreadOwns();
-
-  char* id = aArgv[0];
-  char* file = aArgv[1];
-
-  nsID cid;
-  if (!cid.Parse(id)) {
-    LogMessageWithContext(aCx.mFile, aLineNo,
-                          "Malformed CID: '%s'.", id);
-    return;
-  }
+    mLock.AssertNotCurrentThreadOwns();
 
-  // Precompute the hash/file data outside of the lock
-  FileLocation fl(aCx.mFile, file);
-  nsCString hash;
-  fl.GetURIString(hash);
+    char* id = argv[0];
+    char* file = argv[1];
 
-  MutexLock lock(mLock);
-  nsFactoryEntry* f = mFactories.Get(cid);
-  if (f) {
-    char idstr[NSID_LENGTH];
-    cid.ToProvidedString(idstr);
-
-    nsCString existing;
-    if (f->mModule) {
-      existing = f->mModule->Description();
-    } else {
-      existing = "<unknown module>";
+    nsID cid;
+    if (!cid.Parse(id)) {
+        LogMessageWithContext(cx.mFile, lineno,
+                              "Malformed CID: '%s'.", id);
+        return;
     }
 
-    lock.Unlock();
+    // Precompute the hash/file data outside of the lock
+    FileLocation fl(cx.mFile, file);
+    nsCString hash;
+    fl.GetURIString(hash);
 
-    LogMessageWithContext(aCx.mFile, aLineNo,
-                          "Trying to re-register CID '%s' already registered by %s.",
-                          idstr,
-                          existing.get());
-    return;
-  }
+    MutexLock lock(mLock);
+    nsFactoryEntry* f = mFactories.Get(cid);
+    if (f) {
+        char idstr[NSID_LENGTH];
+        cid.ToProvidedString(idstr);
 
-  KnownModule* km;
+        nsCString existing;
+        if (f->mModule)
+            existing = f->mModule->Description();
+        else
+            existing = "<unknown module>";
+
+        lock.Unlock();
 
-  km = mKnownModules.Get(hash);
-  if (!km) {
-    km = new KnownModule(fl);
-    mKnownModules.Put(hash, km);
-  }
+        LogMessageWithContext(cx.mFile, lineno,
+                              "Trying to re-register CID '%s' already registered by %s.",
+                              idstr,
+                              existing.get());
+        return;
+    }
 
-  void* place;
+    KnownModule* km;
 
-  PL_ARENA_ALLOCATE(place, &mArena, sizeof(nsCID));
-  nsID* permanentCID = static_cast<nsID*>(place);
-  *permanentCID = cid;
+    km = mKnownModules.Get(hash);
+    if (!km) {
+        km = new KnownModule(fl);
+        mKnownModules.Put(hash, km);
+    }
+
+    void* place;
 
-  PL_ARENA_ALLOCATE(place, &mArena, sizeof(mozilla::Module::CIDEntry));
-  mozilla::Module::CIDEntry* e = new (place) mozilla::Module::CIDEntry();
-  e->cid = permanentCID;
+    PL_ARENA_ALLOCATE(place, &mArena, sizeof(nsCID));
+    nsID* permanentCID = static_cast<nsID*>(place);
+    *permanentCID = cid;
 
-  f = new nsFactoryEntry(e, km);
-  mFactories.Put(cid, f);
+    PL_ARENA_ALLOCATE(place, &mArena, sizeof(mozilla::Module::CIDEntry));
+    mozilla::Module::CIDEntry* e = new (place) mozilla::Module::CIDEntry();
+    e->cid = permanentCID;
+
+    f = new nsFactoryEntry(e, km);
+    mFactories.Put(cid, f);
 }
 
 void
-nsComponentManagerImpl::ManifestContract(ManifestProcessingContext& aCx,
-                                         int aLineNo, char* const* aArgv)
+nsComponentManagerImpl::ManifestContract(ManifestProcessingContext& cx, int lineno, char *const * argv)
 {
-  mLock.AssertNotCurrentThreadOwns();
+    mLock.AssertNotCurrentThreadOwns();
 
-  char* contract = aArgv[0];
-  char* id = aArgv[1];
+    char* contract = argv[0];
+    char* id = argv[1];
 
-  nsID cid;
-  if (!cid.Parse(id)) {
-    LogMessageWithContext(aCx.mFile, aLineNo,
-                          "Malformed CID: '%s'.", id);
-    return;
-  }
+    nsID cid;
+    if (!cid.Parse(id)) {
+        LogMessageWithContext(cx.mFile, lineno,
+                              "Malformed CID: '%s'.", id);
+        return;
+    }
 
-  MutexLock lock(mLock);
-  nsFactoryEntry* f = mFactories.Get(cid);
-  if (!f) {
-    lock.Unlock();
-    LogMessageWithContext(aCx.mFile, aLineNo,
-                          "Could not map contract ID '%s' to CID %s because no implementation of the CID is registered.",
-                          contract, id);
-    return;
-  }
+    MutexLock lock(mLock);
+    nsFactoryEntry* f = mFactories.Get(cid);
+    if (!f) {
+        lock.Unlock();
+        LogMessageWithContext(cx.mFile, lineno,
+                              "Could not map contract ID '%s' to CID %s because no implementation of the CID is registered.",
+                              contract, id);
+        return;
+    }
 
-  mContractIDs.Put(nsDependentCString(contract), f);
+    mContractIDs.Put(nsDependentCString(contract), f);
 }
 
 void
-nsComponentManagerImpl::ManifestCategory(ManifestProcessingContext& aCx,
-                                         int aLineNo, char* const* aArgv)
+nsComponentManagerImpl::ManifestCategory(ManifestProcessingContext& cx, int lineno, char *const * argv)
 {
-  char* category = aArgv[0];
-  char* key = aArgv[1];
-  char* value = aArgv[2];
+    char* category = argv[0];
+    char* key = argv[1];
+    char* value = argv[2];
 
-  nsCategoryManager::GetSingleton()->
-  AddCategoryEntry(category, key, value);
+    nsCategoryManager::GetSingleton()->
+        AddCategoryEntry(category, key, value);
 }
 
 void
 nsComponentManagerImpl::RereadChromeManifests(bool aChromeOnly)
 {
-  for (uint32_t i = 0; i < sModuleLocations->Length(); ++i) {
-    ComponentLocation& l = sModuleLocations->ElementAt(i);
-    RegisterManifest(l.type, l.location, aChromeOnly);
-  }
+    for (uint32_t i = 0; i < sModuleLocations->Length(); ++i) {
+        ComponentLocation& l = sModuleLocations->ElementAt(i);
+        RegisterManifest(l.type, l.location, aChromeOnly);
+    }
 }
 
 bool
 nsComponentManagerImpl::KnownModule::EnsureLoader()
 {
-  if (!mLoader) {
-    nsCString extension;
-    mFile.GetURIString(extension);
-    CutExtension(extension);
-    mLoader =
-      nsComponentManagerImpl::gComponentManager->LoaderForExtension(extension);
-  }
-  return !!mLoader;
+    if (!mLoader) {
+        nsCString extension;
+        mFile.GetURIString(extension);
+        CutExtension(extension);
+        mLoader = nsComponentManagerImpl::gComponentManager->LoaderForExtension(extension);
+    }
+    return !!mLoader;
 }
 
 bool
 nsComponentManagerImpl::KnownModule::Load()
 {
-  if (mFailed) {
-    return false;
-  }
-  if (!mModule) {
-    if (!EnsureLoader()) {
-      return false;
-    }
-
-    mModule = mLoader->LoadModule(mFile);
-
+    if (mFailed)
+        return false;
     if (!mModule) {
-      mFailed = true;
-      return false;
+        if (!EnsureLoader())
+            return false;
+
+        mModule = mLoader->LoadModule(mFile);
+
+        if (!mModule) {
+            mFailed = true;
+            return false;
+        }
     }
-  }
-  if (!mLoaded) {
-    if (mModule->loadProc) {
-      nsresult rv = mModule->loadProc();
-      if (NS_FAILED(rv)) {
-        mFailed = true;
-        return false;
-      }
+    if (!mLoaded) {
+        if (mModule->loadProc) {
+            nsresult rv = mModule->loadProc();
+            if (NS_FAILED(rv)) {
+                mFailed = true;
+                return false;
+            }
+        }
+        mLoaded = true;
     }
-    mLoaded = true;
-  }
-  return true;
+    return true;
 }
 
 nsCString
 nsComponentManagerImpl::KnownModule::Description() const
 {
-  nsCString s;
-  if (mFile) {
-    mFile.GetURIString(s);
-  } else {
-    s = "<static module>";
-  }
-  return s;
+    nsCString s;
+    if (mFile)
+        mFile.GetURIString(s);
+    else
+        s = "<static module>";
+    return s;
 }
 
-nsresult
-nsComponentManagerImpl::Shutdown(void)
+nsresult nsComponentManagerImpl::Shutdown(void)
 {
-  PR_ASSERT(NORMAL == mStatus);
+    PR_ASSERT(NORMAL == mStatus);
 
-  mStatus = SHUTDOWN_IN_PROGRESS;
+    mStatus = SHUTDOWN_IN_PROGRESS;
 
-  // Shutdown the component manager
-  PR_LOG(nsComponentManagerLog, PR_LOG_DEBUG,
-         ("nsComponentManager: Beginning Shutdown."));
+    // Shutdown the component manager
+    PR_LOG(nsComponentManagerLog, PR_LOG_DEBUG, ("nsComponentManager: Beginning Shutdown."));
 
-  UnregisterWeakMemoryReporter(this);
+    UnregisterWeakMemoryReporter(this);
 
-  // Release all cached factories
-  mContractIDs.Clear();
-  mFactories.Clear(); // XXX release the objects, don't just clear
-  mLoaderMap.Clear();
-  mKnownModules.Clear();
-  mKnownStaticModules.Clear();
+    // Release all cached factories
+    mContractIDs.Clear();
+    mFactories.Clear(); // XXX release the objects, don't just clear
+    mLoaderMap.Clear();
+    mKnownModules.Clear();
+    mKnownStaticModules.Clear();
 
-  delete sStaticModules;
-  delete sModuleLocations;
+    delete sStaticModules;
+    delete sModuleLocations;
 
-  // Unload libraries
-  mNativeModuleLoader.UnloadLibraries();
+    // Unload libraries
+    mNativeModuleLoader.UnloadLibraries();
 
-  // delete arena for strings and small objects
-  PL_FinishArenaPool(&mArena);
+    // delete arena for strings and small objects
+    PL_FinishArenaPool(&mArena);
 
-  mStatus = SHUTDOWN_COMPLETE;
+    mStatus = SHUTDOWN_COMPLETE;
 
-  PR_LOG(nsComponentManagerLog, PR_LOG_DEBUG,
-         ("nsComponentManager: Shutdown complete."));
+    PR_LOG(nsComponentManagerLog, PR_LOG_DEBUG, ("nsComponentManager: Shutdown complete."));
 
-  return NS_OK;
+    return NS_OK;
 }
 
 nsComponentManagerImpl::~nsComponentManagerImpl()
 {
-  PR_LOG(nsComponentManagerLog, PR_LOG_DEBUG,
-         ("nsComponentManager: Beginning destruction."));
+    PR_LOG(nsComponentManagerLog, PR_LOG_DEBUG, ("nsComponentManager: Beginning destruction."));
 
-  if (SHUTDOWN_COMPLETE != mStatus) {
-    Shutdown();
-  }
+    if (SHUTDOWN_COMPLETE != mStatus)
+        Shutdown();
 
-  PR_LOG(nsComponentManagerLog, PR_LOG_DEBUG,
-         ("nsComponentManager: Destroyed."));
+    PR_LOG(nsComponentManagerLog, PR_LOG_DEBUG, ("nsComponentManager: Destroyed."));
 }
 
-NS_IMPL_ISUPPORTS(nsComponentManagerImpl,
-                  nsIComponentManager,
-                  nsIServiceManager,
-                  nsIComponentRegistrar,
-                  nsISupportsWeakReference,
-                  nsIInterfaceRequestor,
-                  nsIMemoryReporter)
+NS_IMPL_ISUPPORTS(
+    nsComponentManagerImpl,
+    nsIComponentManager,
+    nsIServiceManager,
+    nsIComponentRegistrar,
+    nsISupportsWeakReference,
+    nsIInterfaceRequestor,
+    nsIMemoryReporter)
 
 nsresult
-nsComponentManagerImpl::GetInterface(const nsIID& aUuid, void** aResult)
+nsComponentManagerImpl::GetInterface(const nsIID & uuid, void **result)
 {
-  NS_WARNING("This isn't supported");
-  // fall through to QI as anything QIable is a superset of what can be
-  // got via the GetInterface()
-  return  QueryInterface(aUuid, aResult);
+    NS_WARNING("This isn't supported");
+    // fall through to QI as anything QIable is a superset of what can be
+    // got via the GetInterface()
+    return  QueryInterface(uuid, result);
 }
 
-nsFactoryEntry*
-nsComponentManagerImpl::GetFactoryEntry(const char* aContractID,
+nsFactoryEntry *
+nsComponentManagerImpl::GetFactoryEntry(const char *aContractID,
                                         uint32_t aContractIDLen)
 {
-  SafeMutexAutoLock lock(mLock);
-  return mContractIDs.Get(nsDependentCString(aContractID, aContractIDLen));
+    SafeMutexAutoLock lock(mLock);
+    return mContractIDs.Get(nsDependentCString(aContractID, aContractIDLen));
 }
 
 
-nsFactoryEntry*
-nsComponentManagerImpl::GetFactoryEntry(const nsCID& aClass)
+nsFactoryEntry *
+nsComponentManagerImpl::GetFactoryEntry(const nsCID &aClass)
 {
-  SafeMutexAutoLock lock(mLock);
-  return mFactories.Get(aClass);
+    SafeMutexAutoLock lock(mLock);
+    return mFactories.Get(aClass);
 }
 
 already_AddRefed<nsIFactory>
 nsComponentManagerImpl::FindFactory(const nsCID& aClass)
 {
-  nsFactoryEntry* e = GetFactoryEntry(aClass);
-  if (!e) {
-    return nullptr;
-  }
+    nsFactoryEntry* e = GetFactoryEntry(aClass);
+    if (!e)
+        return nullptr;
 
-  return e->GetFactory();
+    return e->GetFactory();
 }
 
 already_AddRefed<nsIFactory>
-nsComponentManagerImpl::FindFactory(const char* aContractID,
+nsComponentManagerImpl::FindFactory(const char *contractID,
                                     uint32_t aContractIDLen)
 {
-  nsFactoryEntry* entry = GetFactoryEntry(aContractID, aContractIDLen);
-  if (!entry) {
-    return nullptr;
-  }
+    nsFactoryEntry *entry = GetFactoryEntry(contractID, aContractIDLen);
+    if (!entry)
+        return nullptr;
 
-  return entry->GetFactory();
+    return entry->GetFactory();
 }
 
 /**
  * GetClassObject()
  *
  * Given a classID, this finds the singleton ClassObject that implements the CID.
  * Returns an interface of type aIID off the singleton classobject.
  */
 NS_IMETHODIMP
-nsComponentManagerImpl::GetClassObject(const nsCID& aClass, const nsIID& aIID,
-                                       void** aResult)
+nsComponentManagerImpl::GetClassObject(const nsCID &aClass, const nsIID &aIID,
+                                       void **aResult)
 {
-  nsresult rv;
+    nsresult rv;
 
 #ifdef PR_LOGGING
-  if (PR_LOG_TEST(nsComponentManagerLog, PR_LOG_DEBUG)) {
-    char* buf = aClass.ToString();
-    PR_LogPrint("nsComponentManager: GetClassObject(%s)", buf);
-    if (buf) {
-      NS_Free(buf);
+    if (PR_LOG_TEST(nsComponentManagerLog, PR_LOG_DEBUG))
+    {
+        char *buf = aClass.ToString();
+        PR_LogPrint("nsComponentManager: GetClassObject(%s)", buf);
+        if (buf)
+            NS_Free(buf);
     }
-  }
 #endif
 
-  PR_ASSERT(aResult != nullptr);
+    PR_ASSERT(aResult != nullptr);
 
-  nsCOMPtr<nsIFactory> factory = FindFactory(aClass);
-  if (!factory) {
-    return NS_ERROR_FACTORY_NOT_REGISTERED;
-  }
+    nsCOMPtr<nsIFactory> factory = FindFactory(aClass);
+    if (!factory)
+        return NS_ERROR_FACTORY_NOT_REGISTERED;
 
-  rv = factory->QueryInterface(aIID, aResult);
+    rv = factory->QueryInterface(aIID, aResult);
 
-  PR_LOG(nsComponentManagerLog, PR_LOG_WARNING,
-         ("\t\tGetClassObject() %s", NS_SUCCEEDED(rv) ? "succeeded" : "FAILED"));
+    PR_LOG(nsComponentManagerLog, PR_LOG_WARNING,
+           ("\t\tGetClassObject() %s", NS_SUCCEEDED(rv) ? "succeeded" : "FAILED"));
 
-  return rv;
+    return rv;
 }
 
 
 NS_IMETHODIMP
-nsComponentManagerImpl::GetClassObjectByContractID(const char* aContractID,
-                                                   const nsIID& aIID,
-                                                   void** aResult)
+nsComponentManagerImpl::GetClassObjectByContractID(const char *contractID,
+                                                   const nsIID &aIID,
+                                                   void **aResult)
 {
-  if (NS_WARN_IF(!aResult) ||
-      NS_WARN_IF(!aContractID)) {
-    return NS_ERROR_INVALID_ARG;
-  }
+    if (NS_WARN_IF(!aResult) ||
+        NS_WARN_IF(!contractID))
+        return NS_ERROR_INVALID_ARG;
 
-  nsresult rv;
+    nsresult rv;
 
 
 #ifdef PR_LOGGING
-  if (PR_LOG_TEST(nsComponentManagerLog, PR_LOG_DEBUG)) {
-    PR_LogPrint("nsComponentManager: GetClassObject(%s)", aContractID);
-  }
+    if (PR_LOG_TEST(nsComponentManagerLog, PR_LOG_DEBUG))
+    {
+        PR_LogPrint("nsComponentManager: GetClassObject(%s)", contractID);
+    }
 #endif
 
-  nsCOMPtr<nsIFactory> factory = FindFactory(aContractID, strlen(aContractID));
-  if (!factory) {
-    return NS_ERROR_FACTORY_NOT_REGISTERED;
-  }
+    nsCOMPtr<nsIFactory> factory = FindFactory(contractID, strlen(contractID));
+    if (!factory)
+        return NS_ERROR_FACTORY_NOT_REGISTERED;
 
-  rv = factory->QueryInterface(aIID, aResult);
+    rv = factory->QueryInterface(aIID, aResult);
 
-  PR_LOG(nsComponentManagerLog, PR_LOG_WARNING,
-         ("\t\tGetClassObject() %s", NS_SUCCEEDED(rv) ? "succeeded" : "FAILED"));
+    PR_LOG(nsComponentManagerLog, PR_LOG_WARNING,
+           ("\t\tGetClassObject() %s", NS_SUCCEEDED(rv) ? "succeeded" : "FAILED"));
 
-  return rv;
+    return rv;
 }
 
 /**
  * CreateInstance()
  *
  * Create an instance of an object that implements an interface and belongs
  * to the implementation aClass using the factory. The factory is immediately
  * released and not held onto for any longer.
  */
 NS_IMETHODIMP
-nsComponentManagerImpl::CreateInstance(const nsCID& aClass,
-                                       nsISupports* aDelegate,
-                                       const nsIID& aIID,
-                                       void** aResult)
+nsComponentManagerImpl::CreateInstance(const nsCID &aClass,
+                                       nsISupports *aDelegate,
+                                       const nsIID &aIID,
+                                       void **aResult)
 {
-  // test this first, since there's no point in creating a component during
-  // shutdown -- whether it's available or not would depend on the order it
-  // occurs in the list
-  if (gXPCOMShuttingDown) {
-    // When processing shutdown, don't process new GetService() requests
+    // test this first, since there's no point in creating a component during
+    // shutdown -- whether it's available or not would depend on the order it
+    // occurs in the list
+    if (gXPCOMShuttingDown) {
+        // When processing shutdown, don't process new GetService() requests
 #ifdef SHOW_DENIED_ON_SHUTDOWN
-    nsXPIDLCString cid, iid;
-    cid.Adopt(aClass.ToString());
-    iid.Adopt(aIID.ToString());
-    fprintf(stderr, "Creating new instance on shutdown. Denied.\n"
-            "         CID: %s\n         IID: %s\n", cid.get(), iid.get());
+        nsXPIDLCString cid, iid;
+        cid.Adopt(aClass.ToString());
+        iid.Adopt(aIID.ToString());
+        fprintf(stderr, "Creating new instance on shutdown. Denied.\n"
+               "         CID: %s\n         IID: %s\n", cid.get(), iid.get());
 #endif /* SHOW_DENIED_ON_SHUTDOWN */
-    return NS_ERROR_UNEXPECTED;
-  }
+        return NS_ERROR_UNEXPECTED;
+    }
 
-  if (!aResult) {
-    return NS_ERROR_NULL_POINTER;
-  }
-  *aResult = nullptr;
+    if (aResult == nullptr)
+    {
+        return NS_ERROR_NULL_POINTER;
+    }
+    *aResult = nullptr;
 
-  nsFactoryEntry* entry = GetFactoryEntry(aClass);
+    nsFactoryEntry *entry = GetFactoryEntry(aClass);
 
-  if (!entry) {
-    return NS_ERROR_FACTORY_NOT_REGISTERED;
-  }
+    if (!entry)
+        return NS_ERROR_FACTORY_NOT_REGISTERED;
 
 #ifdef SHOW_CI_ON_EXISTING_SERVICE
-  if (entry->mServiceObject) {
-    nsXPIDLCString cid;
-    cid.Adopt(aClass.ToString());
-    nsAutoCString message;
-    message = NS_LITERAL_CSTRING("You are calling CreateInstance \"") +
-              cid +
-              NS_LITERAL_CSTRING("\" when a service for this CID already exists!");
-    NS_ERROR(message.get());
-  }
+    if (entry->mServiceObject) {
+        nsXPIDLCString cid;
+        cid.Adopt(aClass.ToString());
+        nsAutoCString message;
+        message = NS_LITERAL_CSTRING("You are calling CreateInstance \"") +
+                  cid + NS_LITERAL_CSTRING("\" when a service for this CID already exists!");
+        NS_ERROR(message.get());
+    }
 #endif
 
-  nsresult rv;
-  nsCOMPtr<nsIFactory> factory = entry->GetFactory();
-  if (factory) {
-    rv = factory->CreateInstance(aDelegate, aIID, aResult);
-    if (NS_SUCCEEDED(rv) && !*aResult) {
-      NS_ERROR("Factory did not return an object but returned success!");
-      rv = NS_ERROR_SERVICE_NOT_FOUND;
+    nsresult rv;
+    nsCOMPtr<nsIFactory> factory = entry->GetFactory();
+    if (factory)
+    {
+        rv = factory->CreateInstance(aDelegate, aIID, aResult);
+        if (NS_SUCCEEDED(rv) && !*aResult) {
+            NS_ERROR("Factory did not return an object but returned success!");
+            rv = NS_ERROR_SERVICE_NOT_FOUND;
+        }
     }
-  } else {
-    // Translate error values
-    rv = NS_ERROR_FACTORY_NOT_REGISTERED;
-  }
+    else {
+        // Translate error values
+        rv = NS_ERROR_FACTORY_NOT_REGISTERED;
+    }
 
 #ifdef PR_LOGGING
-  if (PR_LOG_TEST(nsComponentManagerLog, PR_LOG_WARNING)) {
-    char* buf = aClass.ToString();
-    PR_LOG(nsComponentManagerLog, PR_LOG_WARNING,
-           ("nsComponentManager: CreateInstance(%s) %s", buf,
-            NS_SUCCEEDED(rv) ? "succeeded" : "FAILED"));
-    if (buf) {
-      NS_Free(buf);
+    if (PR_LOG_TEST(nsComponentManagerLog, PR_LOG_WARNING))
+    {
+        char *buf = aClass.ToString();
+        PR_LOG(nsComponentManagerLog, PR_LOG_WARNING,
+               ("nsComponentManager: CreateInstance(%s) %s", buf,
+                NS_SUCCEEDED(rv) ? "succeeded" : "FAILED"));
+        if (buf)
+            NS_Free(buf);
     }
-  }
 #endif
 
-  return rv;
+    return rv;
 }
 
 /**
  * CreateInstanceByContractID()
  *
  * A variant of CreateInstance() that creates an instance of the object that
  * implements the interface aIID and whose implementation has a contractID aContractID.
  *
  * This is only a convenience routine that turns around can calls the
  * CreateInstance() with classid and iid.
  */
 NS_IMETHODIMP
-nsComponentManagerImpl::CreateInstanceByContractID(const char* aContractID,
-                                                   nsISupports* aDelegate,
-                                                   const nsIID& aIID,
-                                                   void** aResult)
+nsComponentManagerImpl::CreateInstanceByContractID(const char *aContractID,
+                                                   nsISupports *aDelegate,
+                                                   const nsIID &aIID,
+                                                   void **aResult)
 {
-  if (NS_WARN_IF(!aContractID)) {
-    return NS_ERROR_INVALID_ARG;
-  }
+    if (NS_WARN_IF(!aContractID))
+        return NS_ERROR_INVALID_ARG;
 
-  // test this first, since there's no point in creating a component during
-  // shutdown -- whether it's available or not would depend on the order it
-  // occurs in the list
-  if (gXPCOMShuttingDown) {
-    // When processing shutdown, don't process new GetService() requests
+    // test this first, since there's no point in creating a component during
+    // shutdown -- whether it's available or not would depend on the order it
+    // occurs in the list
+    if (gXPCOMShuttingDown) {
+        // When processing shutdown, don't process new GetService() requests
 #ifdef SHOW_DENIED_ON_SHUTDOWN
-    nsXPIDLCString iid;
-    iid.Adopt(aIID.ToString());
-    fprintf(stderr, "Creating new instance on shutdown. Denied.\n"
-            "  ContractID: %s\n         IID: %s\n", aContractID, iid.get());
+        nsXPIDLCString iid;
+        iid.Adopt(aIID.ToString());
+        fprintf(stderr, "Creating new instance on shutdown. Denied.\n"
+               "  ContractID: %s\n         IID: %s\n", aContractID, iid.get());
 #endif /* SHOW_DENIED_ON_SHUTDOWN */
-    return NS_ERROR_UNEXPECTED;
-  }
+        return NS_ERROR_UNEXPECTED;
+    }
 
-  if (!aResult) {
-    return NS_ERROR_NULL_POINTER;
-  }
-  *aResult = nullptr;
+    if (aResult == nullptr)
+    {
+        return NS_ERROR_NULL_POINTER;
+    }
+    *aResult = nullptr;
 
-  nsFactoryEntry* entry = GetFactoryEntry(aContractID, strlen(aContractID));
+    nsFactoryEntry *entry = GetFactoryEntry(aContractID, strlen(aContractID));
 
-  if (!entry) {
-    return NS_ERROR_FACTORY_NOT_REGISTERED;
-  }
+    if (!entry)
+        return NS_ERROR_FACTORY_NOT_REGISTERED;
 
 #ifdef SHOW_CI_ON_EXISTING_SERVICE
-  if (entry->mServiceObject) {
-    nsAutoCString message;
-    message =
-      NS_LITERAL_CSTRING("You are calling CreateInstance \"") +
-      nsDependentCString(aContractID) +
-      NS_LITERAL_CSTRING("\" when a service for this CID already exists! "
-                         "Add it to abusedContracts to track down the service consumer.");
-    NS_ERROR(message.get());
-  }
+    if (entry->mServiceObject) {
+        nsAutoCString message;
+        message =
+          NS_LITERAL_CSTRING("You are calling CreateInstance \"") +
+          nsDependentCString(aContractID) +
+          NS_LITERAL_CSTRING("\" when a service for this CID already exists! "
+            "Add it to abusedContracts to track down the service consumer.");
+        NS_ERROR(message.get());
+    }
 #endif
 
-  nsresult rv;
-  nsCOMPtr<nsIFactory> factory = entry->GetFactory();
-  if (factory) {
+    nsresult rv;
+    nsCOMPtr<nsIFactory> factory = entry->GetFactory();
+    if (factory)
+    {
 
-    rv = factory->CreateInstance(aDelegate, aIID, aResult);
-    if (NS_SUCCEEDED(rv) && !*aResult) {
-      NS_ERROR("Factory did not return an object but returned success!");
-      rv = NS_ERROR_SERVICE_NOT_FOUND;
+        rv = factory->CreateInstance(aDelegate, aIID, aResult);
+        if (NS_SUCCEEDED(rv) && !*aResult) {
+            NS_ERROR("Factory did not return an object but returned success!");
+            rv = NS_ERROR_SERVICE_NOT_FOUND;
+        }
     }
-  } else {
-    // Translate error values
-    rv = NS_ERROR_FACTORY_NOT_REGISTERED;
-  }
+    else {
+        // Translate error values
+        rv = NS_ERROR_FACTORY_NOT_REGISTERED;
+    }
 
-  PR_LOG(nsComponentManagerLog, PR_LOG_WARNING,
-         ("nsComponentManager: CreateInstanceByContractID(%s) %s", aContractID,
-          NS_SUCCEEDED(rv) ? "succeeded" : "FAILED"));
+    PR_LOG(nsComponentManagerLog, PR_LOG_WARNING,
+           ("nsComponentManager: CreateInstanceByContractID(%s) %s", aContractID,
+            NS_SUCCEEDED(rv) ? "succeeded" : "FAILED"));
 
-  return rv;
+    return rv;
 }
 
 static PLDHashOperator
 FreeFactoryEntries(const nsID& aCID,
                    nsFactoryEntry* aEntry,
-                   void* aArg)
+                   void* arg)
 {
-  aEntry->mFactory = nullptr;
-  aEntry->mServiceObject = nullptr;
-  return PL_DHASH_NEXT;
+    aEntry->mFactory = nullptr;
+    aEntry->mServiceObject = nullptr;
+    return PL_DHASH_NEXT;
 }
 
 nsresult
 nsComponentManagerImpl::FreeServices()
 {
-  NS_ASSERTION(gXPCOMShuttingDown,
-               "Must be shutting down in order to free all services");
+    NS_ASSERTION(gXPCOMShuttingDown, "Must be shutting down in order to free all services");
 
-  if (!gXPCOMShuttingDown) {
-    return NS_ERROR_FAILURE;
-  }
+    if (!gXPCOMShuttingDown)
+        return NS_ERROR_FAILURE;
 
-  mFactories.EnumerateRead(FreeFactoryEntries, nullptr);
-  return NS_OK;
+    mFactories.EnumerateRead(FreeFactoryEntries, nullptr);
+    return NS_OK;
 }
 
 // This should only ever be called within the monitor!
 nsComponentManagerImpl::PendingServiceInfo*
 nsComponentManagerImpl::AddPendingService(const nsCID& aServiceCID,
                                           PRThread* aThread)
 {
   PendingServiceInfo* newInfo = mPendingServices.AppendElement();
@@ -1208,859 +1160,818 @@ nsComponentManagerImpl::GetPendingServic
     }
   }
   return nullptr;
 }
 
 NS_IMETHODIMP
 nsComponentManagerImpl::GetService(const nsCID& aClass,
                                    const nsIID& aIID,
-                                   void** aResult)
+                                   void* *result)
 {
-  // test this first, since there's no point in returning a service during
-  // shutdown -- whether it's available or not would depend on the order it
-  // occurs in the list
-  if (gXPCOMShuttingDown) {
-    // When processing shutdown, don't process new GetService() requests
+    // test this first, since there's no point in returning a service during
+    // shutdown -- whether it's available or not would depend on the order it
+    // occurs in the list
+    if (gXPCOMShuttingDown) {
+        // When processing shutdown, don't process new GetService() requests
 #ifdef SHOW_DENIED_ON_SHUTDOWN
-    nsXPIDLCString cid, iid;
-    cid.Adopt(aClass.ToString());
-    iid.Adopt(aIID.ToString());
-    fprintf(stderr, "Getting service on shutdown. Denied.\n"
-            "         CID: %s\n         IID: %s\n", cid.get(), iid.get());
+        nsXPIDLCString cid, iid;
+        cid.Adopt(aClass.ToString());
+        iid.Adopt(aIID.ToString());
+        fprintf(stderr, "Getting service on shutdown. Denied.\n"
+               "         CID: %s\n         IID: %s\n", cid.get(), iid.get());
 #endif /* SHOW_DENIED_ON_SHUTDOWN */
-    return NS_ERROR_UNEXPECTED;
-  }
-
-  // `service` must be released after the lock is released, so it must be
-  // declared before the lock in this C++ block.
-  nsCOMPtr<nsISupports> service;
-  MutexLock lock(mLock);
-
-  nsFactoryEntry* entry = mFactories.Get(aClass);
-  if (!entry) {
-    return NS_ERROR_FACTORY_NOT_REGISTERED;
-  }
-
-  if (entry->mServiceObject) {
-    lock.Unlock();
-    return entry->mServiceObject->QueryInterface(aIID, aResult);
-  }
-
-  PRThread* currentPRThread = PR_GetCurrentThread();
-  MOZ_ASSERT(currentPRThread, "This should never be null!");
-
-  // Needed to optimize the event loop below.
-  nsIThread* currentThread = nullptr;
-
-  PRThread* pendingPRThread;
-  while ((pendingPRThread = GetPendingServiceThread(aClass))) {
-    if (pendingPRThread == currentPRThread) {
-      NS_ERROR("Recursive GetService!");
-      return NS_ERROR_NOT_AVAILABLE;
+        return NS_ERROR_UNEXPECTED;
     }
 
-
-    SafeMutexAutoUnlock unlockPending(mLock);
+    // `service` must be released after the lock is released, so it must be
+    // declared before the lock in this C++ block.
+    nsCOMPtr<nsISupports> service;
+    MutexLock lock(mLock);
 
-    if (!currentThread) {
-      currentThread = NS_GetCurrentThread();
-      MOZ_ASSERT(currentThread, "This should never be null!");
+    nsFactoryEntry* entry = mFactories.Get(aClass);
+    if (!entry)
+        return NS_ERROR_FACTORY_NOT_REGISTERED;
+
+    if (entry->mServiceObject) {
+        lock.Unlock();
+        return entry->mServiceObject->QueryInterface(aIID, result);
     }
 
-    // This will process a single event or yield the thread if no event is
-    // pending.
-    if (!NS_ProcessNextEvent(currentThread, false)) {
-      PR_Sleep(PR_INTERVAL_NO_WAIT);
-    }
-  }
+    PRThread* currentPRThread = PR_GetCurrentThread();
+    MOZ_ASSERT(currentPRThread, "This should never be null!");
+
+    // Needed to optimize the event loop below.
+    nsIThread* currentThread = nullptr;
+
+    PRThread* pendingPRThread;
+    while ((pendingPRThread = GetPendingServiceThread(aClass))) {
+        if (pendingPRThread == currentPRThread) {
+            NS_ERROR("Recursive GetService!");
+            return NS_ERROR_NOT_AVAILABLE;
+        }
+
+
+        SafeMutexAutoUnlock unlockPending(mLock);
 
-  // It's still possible that the other thread failed to create the
-  // service so we're not guaranteed to have an entry or service yet.
-  if (entry->mServiceObject) {
-    lock.Unlock();
-    return entry->mServiceObject->QueryInterface(aIID, aResult);
-  }
+        if (!currentThread) {
+            currentThread = NS_GetCurrentThread();
+            MOZ_ASSERT(currentThread, "This should never be null!");
+        }
+
+        // This will process a single event or yield the thread if no event is
+        // pending.
+        if (!NS_ProcessNextEvent(currentThread, false)) {
+            PR_Sleep(PR_INTERVAL_NO_WAIT);
+        }
+    }
+
+    // It's still possible that the other thread failed to create the
+    // service so we're not guaranteed to have an entry or service yet.
+    if (entry->mServiceObject) {
+        lock.Unlock();
+        return entry->mServiceObject->QueryInterface(aIID, result);
+    }
 
 #ifdef DEBUG
-  PendingServiceInfo* newInfo =
+    PendingServiceInfo* newInfo =
 #endif
     AddPendingService(aClass, currentPRThread);
-  NS_ASSERTION(newInfo, "Failed to add info to the array!");
+    NS_ASSERTION(newInfo, "Failed to add info to the array!");
 
-  // We need to not be holding the service manager's lock while calling
-  // CreateInstance, because it invokes user code which could try to re-enter
-  // the service manager:
+    // We need to not be holding the service manager's lock while calling
+    // CreateInstance, because it invokes user code which could try to re-enter
+    // the service manager:
 
-  nsresult rv;
-  {
-    SafeMutexAutoUnlock unlock(mLock);
-    rv = CreateInstance(aClass, nullptr, aIID, getter_AddRefs(service));
-  }
-  if (NS_SUCCEEDED(rv) && !service) {
-    NS_ERROR("Factory did not return an object but returned success");
-    return NS_ERROR_SERVICE_NOT_FOUND;
-  }
+    nsresult rv;
+    {
+        SafeMutexAutoUnlock unlock(mLock);
+        rv = CreateInstance(aClass, nullptr, aIID, getter_AddRefs(service));
+    }
+    if (NS_SUCCEEDED(rv) && !service) {
+        NS_ERROR("Factory did not return an object but returned success");
+        return NS_ERROR_SERVICE_NOT_FOUND;
+    }
 
 #ifdef DEBUG
-  pendingPRThread = GetPendingServiceThread(aClass);
-  MOZ_ASSERT(pendingPRThread == currentPRThread,
-             "Pending service array has been changed!");
+    pendingPRThread = GetPendingServiceThread(aClass);
+    MOZ_ASSERT(pendingPRThread == currentPRThread,
+               "Pending service array has been changed!");
 #endif
-  RemovePendingService(aClass);
+    RemovePendingService(aClass);
 
-  if (NS_FAILED(rv)) {
-    return rv;
-  }
+    if (NS_FAILED(rv))
+        return rv;
 
-  NS_ASSERTION(!entry->mServiceObject, "Created two instances of a service!");
+    NS_ASSERTION(!entry->mServiceObject, "Created two instances of a service!");
 
-  entry->mServiceObject = service.forget();
+    entry->mServiceObject = service.forget();
 
-  lock.Unlock();
-  nsISupports** sresult = reinterpret_cast<nsISupports**>(aResult);
-  *sresult = entry->mServiceObject;
-  (*sresult)->AddRef();
+    lock.Unlock();
+    nsISupports** sresult = reinterpret_cast<nsISupports**>(result);
+    *sresult = entry->mServiceObject;
+    (*sresult)->AddRef();
 
-  return NS_OK;
+    return NS_OK;
 }
 
 NS_IMETHODIMP
-nsComponentManagerImpl::IsServiceInstantiated(const nsCID& aClass,
+nsComponentManagerImpl::IsServiceInstantiated(const nsCID & aClass,
                                               const nsIID& aIID,
-                                              bool* aResult)
+                                              bool *result)
 {
-  // Now we want to get the service if we already got it. If not, we don't want
-  // to create an instance of it. mmh!
+    // Now we want to get the service if we already got it. If not, we don't want
+    // to create an instance of it. mmh!
 
-  // test this first, since there's no point in returning a service during
-  // shutdown -- whether it's available or not would depend on the order it
-  // occurs in the list
-  if (gXPCOMShuttingDown) {
-    // When processing shutdown, don't process new GetService() requests
+    // test this first, since there's no point in returning a service during
+    // shutdown -- whether it's available or not would depend on the order it
+    // occurs in the list
+    if (gXPCOMShuttingDown) {
+        // When processing shutdown, don't process new GetService() requests
 #ifdef SHOW_DENIED_ON_SHUTDOWN
-    nsXPIDLCString cid, iid;
-    cid.Adopt(aClass.ToString());
-    iid.Adopt(aIID.ToString());
-    fprintf(stderr, "Checking for service on shutdown. Denied.\n"
-            "         CID: %s\n         IID: %s\n", cid.get(), iid.get());
+        nsXPIDLCString cid, iid;
+        cid.Adopt(aClass.ToString());
+        iid.Adopt(aIID.ToString());
+        fprintf(stderr, "Checking for service on shutdown. Denied.\n"
+               "         CID: %s\n         IID: %s\n", cid.get(), iid.get());
 #endif /* SHOW_DENIED_ON_SHUTDOWN */
-    return NS_ERROR_UNEXPECTED;
-  }
+        return NS_ERROR_UNEXPECTED;
+    }
 
-  nsresult rv = NS_ERROR_SERVICE_NOT_AVAILABLE;
-  nsFactoryEntry* entry;
+    nsresult rv = NS_ERROR_SERVICE_NOT_AVAILABLE;
+    nsFactoryEntry* entry;
 
-  {
-    SafeMutexAutoLock lock(mLock);
-    entry = mFactories.Get(aClass);
-  }
+    {
+        SafeMutexAutoLock lock(mLock);
+        entry = mFactories.Get(aClass);
+    }
 
-  if (entry && entry->mServiceObject) {
-    nsCOMPtr<nsISupports> service;
-    rv = entry->mServiceObject->QueryInterface(aIID, getter_AddRefs(service));
-    *aResult = (service != nullptr);
-  }
+    if (entry && entry->mServiceObject) {
+        nsCOMPtr<nsISupports> service;
+        rv = entry->mServiceObject->QueryInterface(aIID, getter_AddRefs(service));
+        *result = (service!=nullptr);
+    }
 
-  return rv;
+    return rv;
 }
 
-NS_IMETHODIMP
-nsComponentManagerImpl::IsServiceInstantiatedByContractID(
-    const char* aContractID,
-    const nsIID& aIID,
-    bool* aResult)
+NS_IMETHODIMP nsComponentManagerImpl::IsServiceInstantiatedByContractID(const char *aContractID,
+                                                                        const nsIID& aIID,
+                                                                        bool *result)
 {
-  // Now we want to get the service if we already got it. If not, we don't want
-  // to create an instance of it. mmh!
+    // Now we want to get the service if we already got it. If not, we don't want
+    // to create an instance of it. mmh!
 
-  // test this first, since there's no point in returning a service during
-  // shutdown -- whether it's available or not would depend on the order it
-  // occurs in the list
-  if (gXPCOMShuttingDown) {
-    // When processing shutdown, don't process new GetService() requests
+    // test this first, since there's no point in returning a service during
+    // shutdown -- whether it's available or not would depend on the order it
+    // occurs in the list
+    if (gXPCOMShuttingDown) {
+        // When processing shutdown, don't process new GetService() requests
 #ifdef SHOW_DENIED_ON_SHUTDOWN
-    nsXPIDLCString iid;
-    iid.Adopt(aIID.ToString());
-    fprintf(stderr, "Checking for service on shutdown. Denied.\n"
-            "  ContractID: %s\n         IID: %s\n", aContractID, iid.get());
+        nsXPIDLCString iid;
+        iid.Adopt(aIID.ToString());
+        fprintf(stderr, "Checking for service on shutdown. Denied.\n"
+               "  ContractID: %s\n         IID: %s\n", aContractID, iid.get());
 #endif /* SHOW_DENIED_ON_SHUTDOWN */
-    return NS_ERROR_UNEXPECTED;
-  }
+        return NS_ERROR_UNEXPECTED;
+    }
 
-  nsresult rv = NS_ERROR_SERVICE_NOT_AVAILABLE;
-  nsFactoryEntry* entry;
-  {
-    SafeMutexAutoLock lock(mLock);
-    entry = mContractIDs.Get(nsDependentCString(aContractID));
-  }
+    nsresult rv = NS_ERROR_SERVICE_NOT_AVAILABLE;
+    nsFactoryEntry *entry;
+    {
+        SafeMutexAutoLock lock(mLock);
+        entry = mContractIDs.Get(nsDependentCString(aContractID));
+    }
 
-  if (entry && entry->mServiceObject) {
-    nsCOMPtr<nsISupports> service;
-    rv = entry->mServiceObject->QueryInterface(aIID, getter_AddRefs(service));
-    *aResult = (service != nullptr);
-  }
-  return rv;
+    if (entry && entry->mServiceObject) {
+        nsCOMPtr<nsISupports> service;
+        rv = entry->mServiceObject->QueryInterface(aIID, getter_AddRefs(service));
+        *result = (service!=nullptr);
+    }
+    return rv;
 }
 
 
 NS_IMETHODIMP
 nsComponentManagerImpl::GetServiceByContractID(const char* aContractID,
                                                const nsIID& aIID,
-                                               void** aResult)
+                                               void* *result)
 {
-  // test this first, since there's no point in returning a service during
-  // shutdown -- whether it's available or not would depend on the order it
-  // occurs in the list
-  if (gXPCOMShuttingDown) {
-    // When processing shutdown, don't process new GetService() requests
+    // test this first, since there's no point in returning a service during
+    // shutdown -- whether it's available or not would depend on the order it
+    // occurs in the list
+    if (gXPCOMShuttingDown) {
+        // When processing shutdown, don't process new GetService() requests
 #ifdef SHOW_DENIED_ON_SHUTDOWN
-    nsXPIDLCString iid;
-    iid.Adopt(aIID.ToString());
-    fprintf(stderr, "Getting service on shutdown. Denied.\n"
-            "  ContractID: %s\n         IID: %s\n", aContractID, iid.get());
+        nsXPIDLCString iid;
+        iid.Adopt(aIID.ToString());
+        fprintf(stderr, "Getting service on shutdown. Denied.\n"
+               "  ContractID: %s\n         IID: %s\n", aContractID, iid.get());
 #endif /* SHOW_DENIED_ON_SHUTDOWN */
-    return NS_ERROR_UNEXPECTED;
-  }
-
-  // `service` must be released after the lock is released, so it must be
-  // declared before the lock in this C++ block.
-  nsCOMPtr<nsISupports> service;
-  MutexLock lock(mLock);
-
-  nsFactoryEntry* entry = mContractIDs.Get(nsDependentCString(aContractID));
-  if (!entry) {
-    return NS_ERROR_FACTORY_NOT_REGISTERED;
-  }
-
-  if (entry->mServiceObject) {
-    // We need to not be holding the service manager's monitor while calling
-    // QueryInterface, because it invokes user code which could try to re-enter
-    // the service manager, or try to grab some other lock/monitor/condvar
-    // and deadlock, e.g. bug 282743.
-    // `entry` is valid until XPCOM shutdown, so we can safely use it after
-    // exiting the lock.
-    lock.Unlock();
-    return entry->mServiceObject->QueryInterface(aIID, aResult);
-  }
-
-  PRThread* currentPRThread = PR_GetCurrentThread();
-  MOZ_ASSERT(currentPRThread, "This should never be null!");
-
-  // Needed to optimize the event loop below.
-  nsIThread* currentThread = nullptr;
-
-  PRThread* pendingPRThread;
-  while ((pendingPRThread = GetPendingServiceThread(*entry->mCIDEntry->cid))) {
-    if (pendingPRThread == currentPRThread) {
-      NS_ERROR("Recursive GetService!");
-      return NS_ERROR_NOT_AVAILABLE;
+        return NS_ERROR_UNEXPECTED;
     }
 
-    SafeMutexAutoUnlock unlockPending(mLock);
+    // `service` must be released after the lock is released, so it must be
+    // declared before the lock in this C++ block.
+    nsCOMPtr<nsISupports> service;
+    MutexLock lock(mLock);
+
+    nsFactoryEntry *entry = mContractIDs.Get(nsDependentCString(aContractID));
+    if (!entry)
+        return NS_ERROR_FACTORY_NOT_REGISTERED;
 
-    if (!currentThread) {
-      currentThread = NS_GetCurrentThread();
-      MOZ_ASSERT(currentThread, "This should never be null!");
+    if (entry->mServiceObject) {
+        // We need to not be holding the service manager's monitor while calling
+        // QueryInterface, because it invokes user code which could try to re-enter
+        // the service manager, or try to grab some other lock/monitor/condvar
+        // and deadlock, e.g. bug 282743.
+        // `entry` is valid until XPCOM shutdown, so we can safely use it after
+        // exiting the lock.
+        lock.Unlock();
+        return entry->mServiceObject->QueryInterface(aIID, result);
     }
 
-    // This will process a single event or yield the thread if no event is
-    // pending.
-    if (!NS_ProcessNextEvent(currentThread, false)) {
-      PR_Sleep(PR_INTERVAL_NO_WAIT);
-    }
-  }
+    PRThread* currentPRThread = PR_GetCurrentThread();
+    MOZ_ASSERT(currentPRThread, "This should never be null!");
+
+    // Needed to optimize the event loop below.
+    nsIThread* currentThread = nullptr;
+
+    PRThread* pendingPRThread;
+    while ((pendingPRThread = GetPendingServiceThread(*entry->mCIDEntry->cid))) {
+        if (pendingPRThread == currentPRThread) {
+            NS_ERROR("Recursive GetService!");
+            return NS_ERROR_NOT_AVAILABLE;
+        }
+
+        SafeMutexAutoUnlock unlockPending(mLock);
 
-  if (currentThread && entry->mServiceObject) {
-    // If we have a currentThread then we must have waited on another thread
-    // to create the service. Grab it now if that succeeded.
-    lock.Unlock();
-    return entry->mServiceObject->QueryInterface(aIID, aResult);
-  }
+        if (!currentThread) {
+            currentThread = NS_GetCurrentThread();
+            MOZ_ASSERT(currentThread, "This should never be null!");
+        }
+
+        // This will process a single event or yield the thread if no event is
+        // pending.
+        if (!NS_ProcessNextEvent(currentThread, false)) {
+            PR_Sleep(PR_INTERVAL_NO_WAIT);
+        }
+    }
+
+    if (currentThread && entry->mServiceObject) {
+        // If we have a currentThread then we must have waited on another thread
+        // to create the service. Grab it now if that succeeded.
+        lock.Unlock();
+        return entry->mServiceObject->QueryInterface(aIID, result);
+    }
 
 #ifdef DEBUG
-  PendingServiceInfo* newInfo =
+    PendingServiceInfo* newInfo =
 #endif
     AddPendingService(*entry->mCIDEntry->cid, currentPRThread);
-  NS_ASSERTION(newInfo, "Failed to add info to the array!");
+    NS_ASSERTION(newInfo, "Failed to add info to the array!");
 
-  // We need to not be holding the service manager's lock while calling
-  // CreateInstance, because it invokes user code which could try to re-enter
-  // the service manager:
+    // We need to not be holding the service manager's lock while calling
+    // CreateInstance, because it invokes user code which could try to re-enter
+    // the service manager:
 
-  nsresult rv;
-  {
-    SafeMutexAutoUnlock unlock(mLock);
-    rv = CreateInstanceByContractID(aContractID, nullptr, aIID,
-                                    getter_AddRefs(service));
-  }
-  if (NS_SUCCEEDED(rv) && !service) {
-    NS_ERROR("Factory did not return an object but returned success");
-    return NS_ERROR_SERVICE_NOT_FOUND;
-  }
+    nsresult rv;
+    {
+        SafeMutexAutoUnlock unlock(mLock);
+        rv = CreateInstanceByContractID(aContractID, nullptr, aIID,
+                                        getter_AddRefs(service));
+    }
+    if (NS_SUCCEEDED(rv) && !service) {
+        NS_ERROR("Factory did not return an object but returned success");
+        return NS_ERROR_SERVICE_NOT_FOUND;
+    }
 
 #ifdef DEBUG
-  pendingPRThread = GetPendingServiceThread(*entry->mCIDEntry->cid);
-  MOZ_ASSERT(pendingPRThread == currentPRThread,
-             "Pending service array has been changed!");
+    pendingPRThread = GetPendingServiceThread(*entry->mCIDEntry->cid);
+    MOZ_ASSERT(pendingPRThread == currentPRThread,
+               "Pending service array has been changed!");
 #endif
-  RemovePendingService(*entry->mCIDEntry->cid);
+    RemovePendingService(*entry->mCIDEntry->cid);
 
-  if (NS_FAILED(rv)) {
-    return rv;
-  }
+    if (NS_FAILED(rv))
+        return rv;
 
-  NS_ASSERTION(!entry->mServiceObject, "Created two instances of a service!");
+    NS_ASSERTION(!entry->mServiceObject, "Created two instances of a service!");
 
-  entry->mServiceObject = service.forget();
+    entry->mServiceObject = service.forget();
 
-  lock.Unlock();
+    lock.Unlock();
 
-  nsISupports** sresult = reinterpret_cast<nsISupports**>(aResult);
-  *sresult = entry->mServiceObject;
-  (*sresult)->AddRef();
+    nsISupports** sresult = reinterpret_cast<nsISupports**>(result);
+    *sresult = entry->mServiceObject;
+    (*sresult)->AddRef();
 
-  return NS_OK;
+    return NS_OK;
 }
 
 already_AddRefed<mozilla::ModuleLoader>
 nsComponentManagerImpl::LoaderForExtension(const nsACString& aExt)
 {
-  nsCOMPtr<mozilla::ModuleLoader> loader = mLoaderMap.Get(aExt);
-  if (!loader) {
-    loader = do_GetServiceFromCategory("module-loader",
-                                       PromiseFlatCString(aExt).get());
+    nsCOMPtr<mozilla::ModuleLoader> loader = mLoaderMap.Get(aExt);
     if (!loader) {
-      return nullptr;
+        loader = do_GetServiceFromCategory("module-loader",
+                                           PromiseFlatCString(aExt).get());
+        if (!loader)
+            return nullptr;
+
+        mLoaderMap.Put(aExt, loader);
     }
 
-    mLoaderMap.Put(aExt, loader);
-  }
-
-  return loader.forget();
+    return loader.forget();
 }
 
 NS_IMETHODIMP
 nsComponentManagerImpl::RegisterFactory(const nsCID& aClass,
                                         const char* aName,
                                         const char* aContractID,
                                         nsIFactory* aFactory)
 {
-  if (!aFactory) {
-    // If a null factory is passed in, this call just wants to reset
-    // the contract ID to point to an existing CID entry.
-    if (!aContractID) {
-      return NS_ERROR_INVALID_ARG;
+    if (!aFactory) {
+        // If a null factory is passed in, this call just wants to reset
+        // the contract ID to point to an existing CID entry.
+        if (!aContractID)
+            return NS_ERROR_INVALID_ARG;
+
+        SafeMutexAutoLock lock(mLock);
+        nsFactoryEntry* oldf = mFactories.Get(aClass);
+        if (!oldf)
+            return NS_ERROR_FACTORY_NOT_REGISTERED;
+
+        mContractIDs.Put(nsDependentCString(aContractID), oldf);
+        return NS_OK;
     }
 
+    nsAutoPtr<nsFactoryEntry> f(new nsFactoryEntry(aClass, aFactory));
+
     SafeMutexAutoLock lock(mLock);
     nsFactoryEntry* oldf = mFactories.Get(aClass);
-    if (!oldf) {
-      return NS_ERROR_FACTORY_NOT_REGISTERED;
-    }
-
-    mContractIDs.Put(nsDependentCString(aContractID), oldf);
-    return NS_OK;
-  }
-
-  nsAutoPtr<nsFactoryEntry> f(new nsFactoryEntry(aClass, aFactory));
+    if (oldf)
+        return NS_ERROR_FACTORY_EXISTS;
 
-  SafeMutexAutoLock lock(mLock);
-  nsFactoryEntry* oldf = mFactories.Get(aClass);
-  if (oldf) {
-    return NS_ERROR_FACTORY_EXISTS;
-  }
+    if (aContractID)
+        mContractIDs.Put(nsDependentCString(aContractID), f);
 
-  if (aContractID) {
-    mContractIDs.Put(nsDependentCString(aContractID), f);
-  }
+    mFactories.Put(aClass, f.forget());
 
-  mFactories.Put(aClass, f.forget());
-
-  return NS_OK;
+    return NS_OK;
 }
 
 NS_IMETHODIMP
 nsComponentManagerImpl::UnregisterFactory(const nsCID& aClass,
                                           nsIFactory* aFactory)
 {
-  // Don't release the dying factory or service object until releasing
-  // the component manager monitor.
-  nsCOMPtr<nsIFactory> dyingFactory;
-  nsCOMPtr<nsISupports> dyingServiceObject;
+    // Don't release the dying factory or service object until releasing
+    // the component manager monitor.
+    nsCOMPtr<nsIFactory> dyingFactory;
+    nsCOMPtr<nsISupports> dyingServiceObject;
 
-  {
-    SafeMutexAutoLock lock(mLock);
-    nsFactoryEntry* f = mFactories.Get(aClass);
-    if (!f || f->mFactory != aFactory) {
-      return NS_ERROR_FACTORY_NOT_REGISTERED;
+    {
+        SafeMutexAutoLock lock(mLock);
+        nsFactoryEntry* f = mFactories.Get(aClass);
+        if (!f || f->mFactory != aFactory)
+            return NS_ERROR_FACTORY_NOT_REGISTERED;
+
+        mFactories.Remove(aClass);
+
+        // This might leave a stale contractid -> factory mapping in
+        // place, so null out the factory entry (see
+        // nsFactoryEntry::GetFactory)
+        f->mFactory.swap(dyingFactory);
+        f->mServiceObject.swap(dyingServiceObject);
     }
 
-    mFactories.Remove(aClass);
-
-    // This might leave a stale contractid -> factory mapping in
-    // place, so null out the factory entry (see
-    // nsFactoryEntry::GetFactory)
-    f->mFactory.swap(dyingFactory);
-    f->mServiceObject.swap(dyingServiceObject);
-  }
-
-  return NS_OK;
+    return NS_OK;
 }
 
 NS_IMETHODIMP
 nsComponentManagerImpl::AutoRegister(nsIFile* aLocation)
 {
-  XRE_AddManifestLocation(NS_COMPONENT_LOCATION, aLocation);
-  return NS_OK;
+    XRE_AddManifestLocation(NS_COMPONENT_LOCATION, aLocation);
+    return NS_OK;
 }
 
 NS_IMETHODIMP
 nsComponentManagerImpl::AutoUnregister(nsIFile* aLocation)
 {
-  NS_ERROR("AutoUnregister not implemented.");
-  return NS_ERROR_NOT_IMPLEMENTED;
+    NS_ERROR("AutoUnregister not implemented.");
+    return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
 nsComponentManagerImpl::RegisterFactoryLocation(const nsCID& aCID,
                                                 const char* aClassName,
                                                 const char* aContractID,
                                                 nsIFile* aFile,
                                                 const char* aLoaderStr,
                                                 const char* aType)
 {
-  NS_ERROR("RegisterFactoryLocation not implemented.");
-  return NS_ERROR_NOT_IMPLEMENTED;
+    NS_ERROR("RegisterFactoryLocation not implemented.");
+    return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
 nsComponentManagerImpl::UnregisterFactoryLocation(const nsCID& aCID,
                                                   nsIFile* aFile)
 {
-  NS_ERROR("UnregisterFactoryLocation not implemented.");
-  return NS_ERROR_NOT_IMPLEMENTED;
+    NS_ERROR("UnregisterFactoryLocation not implemented.");
+    return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-nsComponentManagerImpl::IsCIDRegistered(const nsCID& aClass,
-                                        bool* aResult)
+nsComponentManagerImpl::IsCIDRegistered(const nsCID & aClass,
+                                        bool *_retval)
 {
-  *aResult = (nullptr != GetFactoryEntry(aClass));
-  return NS_OK;
+    *_retval = (nullptr != GetFactoryEntry(aClass));
+    return NS_OK;
 }
 
 NS_IMETHODIMP
-nsComponentManagerImpl::IsContractIDRegistered(const char* aClass,
-                                               bool* aResult)
+nsComponentManagerImpl::IsContractIDRegistered(const char *aClass,
+                                               bool *_retval)
 {
-  if (NS_WARN_IF(!aClass)) {
-    return NS_ERROR_INVALID_ARG;
-  }
+    if (NS_WARN_IF(!aClass))
+        return NS_ERROR_INVALID_ARG;
 
-  nsFactoryEntry* entry = GetFactoryEntry(aClass, strlen(aClass));
+    nsFactoryEntry *entry = GetFactoryEntry(aClass, strlen(aClass));
 
-  if (entry) {
-    *aResult = true;
-  } else {
-    *aResult = false;
-  }
-  return NS_OK;
+    if (entry)
+        *_retval = true;
+    else
+        *_retval = false;
+    return NS_OK;
 }
 
 static PLDHashOperator
-EnumerateCIDHelper(const nsID& aId, nsFactoryEntry* aEntry, void* aClosure)
+EnumerateCIDHelper(const nsID& id, nsFactoryEntry* entry, void* closure)
 {
-  nsCOMArray<nsISupports>* array =
-    static_cast<nsCOMArray<nsISupports>*>(aClosure);
-  nsCOMPtr<nsISupportsID> wrapper = new nsSupportsIDImpl();
-  wrapper->SetData(&aId);
-  array->AppendObject(wrapper);
-  return PL_DHASH_NEXT;
+    nsCOMArray<nsISupports> *array = static_cast<nsCOMArray<nsISupports>*>(closure);
+    nsCOMPtr<nsISupportsID> wrapper = new nsSupportsIDImpl();
+    wrapper->SetData(&id);
+    array->AppendObject(wrapper);
+    return PL_DHASH_NEXT;
 }
 
 NS_IMETHODIMP
-nsComponentManagerImpl::EnumerateCIDs(nsISimpleEnumerator** aEnumerator)
+nsComponentManagerImpl::EnumerateCIDs(nsISimpleEnumerator **aEnumerator)
 {
-  nsCOMArray<nsISupports> array;
-  mFactories.EnumerateRead(EnumerateCIDHelper, &array);
+    nsCOMArray<nsISupports> array;
+    mFactories.EnumerateRead(EnumerateCIDHelper, &array);
 
-  return NS_NewArrayEnumerator(aEnumerator, array);
+    return NS_NewArrayEnumerator(aEnumerator, array);
 }
 
 static PLDHashOperator
-EnumerateContractsHelper(const nsACString& aContract, nsFactoryEntry* aEntry,
-                         void* aClosure)
+EnumerateContractsHelper(const nsACString& contract, nsFactoryEntry* entry, void* closure)
 {
-  nsTArray<nsCString>* array = static_cast<nsTArray<nsCString>*>(aClosure);
-  array->AppendElement(aContract);
-  return PL_DHASH_NEXT;
+    nsTArray<nsCString>* array = static_cast<nsTArray<nsCString>*>(closure);
+    array->AppendElement(contract);
+    return PL_DHASH_NEXT;
 }
 
 NS_IMETHODIMP
-nsComponentManagerImpl::EnumerateContractIDs(nsISimpleEnumerator** aEnumerator)
+nsComponentManagerImpl::EnumerateContractIDs(nsISimpleEnumerator **aEnumerator)
 {
-  nsTArray<nsCString>* array = new nsTArray<nsCString>;
-  mContractIDs.EnumerateRead(EnumerateContractsHelper, array);
+    nsTArray<nsCString>* array = new nsTArray<nsCString>;
+    mContractIDs.EnumerateRead(EnumerateContractsHelper, array);
 
-  nsCOMPtr<nsIUTF8StringEnumerator> e;
-  nsresult rv = NS_NewAdoptingUTF8StringEnumerator(getter_AddRefs(e), array);
-  if (NS_FAILED(rv)) {
-    return rv;
-  }
+    nsCOMPtr<nsIUTF8StringEnumerator> e;
+    nsresult rv = NS_NewAdoptingUTF8StringEnumerator(getter_AddRefs(e), array);
+    if (NS_FAILED(rv))
+        return rv;
 
-  return CallQueryInterface(e, aEnumerator);
+    return CallQueryInterface(e, aEnumerator);
 }
 
 NS_IMETHODIMP
-nsComponentManagerImpl::CIDToContractID(const nsCID& aClass,
-                                        char** aResult)
+nsComponentManagerImpl::CIDToContractID(const nsCID & aClass,
+                                        char **_retval)
 {
-  NS_ERROR("CIDTOContractID not implemented");
-  return NS_ERROR_FACTORY_NOT_REGISTERED;
+    NS_ERROR("CIDTOContractID not implemented");
+    return NS_ERROR_FACTORY_NOT_REGISTERED;
 }
 
 NS_IMETHODIMP
-nsComponentManagerImpl::ContractIDToCID(const char* aContractID,
-                                        nsCID** aResult)
+nsComponentManagerImpl::ContractIDToCID(const char *aContractID,
+                                        nsCID * *_retval)
 {
-  {
-    SafeMutexAutoLock lock(mLock);
-    nsFactoryEntry* entry = mContractIDs.Get(nsDependentCString(aContractID));
-    if (entry) {
-      *aResult = (nsCID*)NS_Alloc(sizeof(nsCID));
-      **aResult = *entry->mCIDEntry->cid;
-      return NS_OK;
+    {
+        SafeMutexAutoLock lock(mLock);
+        nsFactoryEntry* entry = mContractIDs.Get(nsDependentCString(aContractID));
+        if (entry) {
+            *_retval = (nsCID*) NS_Alloc(sizeof(nsCID));
+            **_retval = *entry->mCIDEntry->cid;
+            return NS_OK;
+        }
     }
-  }
-  *aResult = nullptr;
-  return NS_ERROR_FACTORY_NOT_REGISTERED;
+    *_retval = nullptr;
+    return NS_ERROR_FACTORY_NOT_REGISTERED;
 }
 
 static size_t
 SizeOfFactoriesEntryExcludingThis(nsIDHashKey::KeyType aKey,
-                                  nsFactoryEntry* const& aData,
+                                  nsFactoryEntry* const &aData,
                                   MallocSizeOf aMallocSizeOf,
                                   void* aUserArg)
 {
-  return aData->SizeOfIncludingThis(aMallocSizeOf);
+    return aData->SizeOfIncludingThis(aMallocSizeOf);
 }
 
 static size_t
 SizeOfContractIDsEntryExcludingThis(nsCStringHashKey::KeyType aKey,
-                                    nsFactoryEntry* const& aData,
+                                    nsFactoryEntry* const &aData,
                                     MallocSizeOf aMallocSizeOf,
                                     void* aUserArg)
 {
-  // We don't measure the nsFactoryEntry data because its owned by mFactories
-  // (which measures them in SizeOfFactoriesEntryExcludingThis).
-  return aKey.SizeOfExcludingThisMustBeUnshared(aMallocSizeOf);
+    // We don't measure the nsFactoryEntry data because its owned by mFactories
+    // (which measures them in SizeOfFactoriesEntryExcludingThis).
+    return aKey.SizeOfExcludingThisMustBeUnshared(aMallocSizeOf);
 }
 
 MOZ_DEFINE_MALLOC_SIZE_OF(ComponentManagerMallocSizeOf)
 
 NS_IMETHODIMP
 nsComponentManagerImpl::CollectReports(nsIHandleReportCallback* aHandleReport,
                                        nsISupports* aData, bool aAnonymize)
 {
-  return MOZ_COLLECT_REPORT("explicit/xpcom/component-manager",
-                            KIND_HEAP, UNITS_BYTES,
-                            SizeOfIncludingThis(ComponentManagerMallocSizeOf),
-                            "Memory used for the XPCOM component manager.");
+    return MOZ_COLLECT_REPORT(
+        "explicit/xpcom/component-manager", KIND_HEAP, UNITS_BYTES,
+        SizeOfIncludingThis(ComponentManagerMallocSizeOf),
+        "Memory used for the XPCOM component manager.");
 }
 
 size_t
 nsComponentManagerImpl::SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf)
 {
-  size_t n = aMallocSizeOf(this);
-  n += mLoaderMap.SizeOfExcludingThis(nullptr, aMallocSizeOf);
-  n += mFactories.SizeOfExcludingThis(SizeOfFactoriesEntryExcludingThis,
-                                      aMallocSizeOf);
-  n += mContractIDs.SizeOfExcludingThis(SizeOfContractIDsEntryExcludingThis,
-                                        aMallocSizeOf);
+    size_t n = aMallocSizeOf(this);
+    n += mLoaderMap.SizeOfExcludingThis(nullptr, aMallocSizeOf);
+    n += mFactories.SizeOfExcludingThis(SizeOfFactoriesEntryExcludingThis, aMallocSizeOf);
+    n += mContractIDs.SizeOfExcludingThis(SizeOfContractIDsEntryExcludingThis, aMallocSizeOf);
 
-  n += sStaticModules->SizeOfIncludingThis(aMallocSizeOf);
-  n += sModuleLocations->SizeOfIncludingThis(aMallocSizeOf);
+    n += sStaticModules->SizeOfIncludingThis(aMallocSizeOf);
+    n += sModuleLocations->SizeOfIncludingThis(aMallocSizeOf);
 
-  n += mKnownStaticModules.SizeOfExcludingThis(aMallocSizeOf);
-  n += mKnownModules.SizeOfExcludingThis(nullptr, aMallocSizeOf);
+    n += mKnownStaticModules.SizeOfExcludingThis(aMallocSizeOf);
+    n += mKnownModules.SizeOfExcludingThis(nullptr, aMallocSizeOf);
+
+    n += PL_SizeOfArenaPoolExcludingPool(&mArena, aMallocSizeOf);
 
-  n += PL_SizeOfArenaPoolExcludingPool(&mArena, aMallocSizeOf);
-
-  n += mPendingServices.SizeOfExcludingThis(aMallocSizeOf);
+    n += mPendingServices.SizeOfExcludingThis(aMallocSizeOf);
 
-  // Measurement of the following members may be added later if DMD finds it is
-  // worthwhile:
-  // - mLoaderMap's keys and values
-  // - mMon
-  // - sStaticModules' entries
-  // - sModuleLocations' entries
-  // - mNativeModuleLoader
-  // - mKnownStaticModules' entries?
-  // - mKnownModules' keys and values?
+    // Measurement of the following members may be added later if DMD finds it is
+    // worthwhile:
+    // - mLoaderMap's keys and values
+    // - mMon
+    // - sStaticModules' entries
+    // - sModuleLocations' entries
+    // - mNativeModuleLoader
+    // - mKnownStaticModules' entries?
+    // - mKnownModules' keys and values?
 
-  return n;
+    return n;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // nsFactoryEntry
 ////////////////////////////////////////////////////////////////////////////////
 
-nsFactoryEntry::nsFactoryEntry(const mozilla::Module::CIDEntry* aEntry,
-                               nsComponentManagerImpl::KnownModule* aModule)
-  : mCIDEntry(aEntry)
-  , mModule(aModule)
+nsFactoryEntry::nsFactoryEntry(const mozilla::Module::CIDEntry* entry,
+                               nsComponentManagerImpl::KnownModule* module)
+    : mCIDEntry(entry)
+    , mModule(module)
 {
 }
 
-nsFactoryEntry::nsFactoryEntry(const nsCID& aCID, nsIFactory* aFactory)
-  : mCIDEntry(nullptr)
-  , mModule(nullptr)
-  , mFactory(aFactory)
+nsFactoryEntry::nsFactoryEntry(const nsCID& aCID, nsIFactory* factory)
+    : mCIDEntry(nullptr)
+    , mModule(nullptr)
+    , mFactory(factory)
 {
-  mozilla::Module::CIDEntry* e = new mozilla::Module::CIDEntry();
-  nsCID* cid = new nsCID;
-  *cid = aCID;
-  e->cid = cid;
-  mCIDEntry = e;
+    mozilla::Module::CIDEntry* e = new mozilla::Module::CIDEntry();
+    nsCID* cid = new nsCID;
+    *cid = aCID;
+    e->cid = cid;
+    mCIDEntry = e;
 }
 
 nsFactoryEntry::~nsFactoryEntry()
 {
-  // If this was a RegisterFactory entry, we own the CIDEntry/CID
-  if (!mModule) {
-    delete mCIDEntry->cid;
-    delete mCIDEntry;
-  }
+    // If this was a RegisterFactory entry, we own the CIDEntry/CID
+    if (!mModule) {
+        delete mCIDEntry->cid;
+        delete mCIDEntry;
+    }
 }
 
 already_AddRefed<nsIFactory>
 nsFactoryEntry::GetFactory()
 {
-  nsComponentManagerImpl::gComponentManager->mLock.AssertNotCurrentThreadOwns();
+    nsComponentManagerImpl::gComponentManager->mLock.AssertNotCurrentThreadOwns();
 
-  if (!mFactory) {
-    // RegisterFactory then UnregisterFactory can leave an entry in mContractIDs
-    // pointing to an unusable nsFactoryEntry.
-    if (!mModule) {
-      return nullptr;
-    }
+    if (!mFactory) {
+        // RegisterFactory then UnregisterFactory can leave an entry in mContractIDs
+        // pointing to an unusable nsFactoryEntry.
+        if (!mModule)
+            return nullptr;
 
-    if (!mModule->Load()) {
-      return nullptr;
-    }
+        if (!mModule->Load())
+            return nullptr;
 
-    // Don't set mFactory directly, it needs to be locked
-    nsCOMPtr<nsIFactory> factory;
+        // Don't set mFactory directly, it needs to be locked
+        nsCOMPtr<nsIFactory> factory;
 
-    if (mModule->Module()->getFactoryProc) {
-      factory = mModule->Module()->getFactoryProc(*mModule->Module(),
-                                                  *mCIDEntry);
-    } else if (mCIDEntry->getFactoryProc) {
-      factory = mCIDEntry->getFactoryProc(*mModule->Module(), *mCIDEntry);
-    } else {
-      NS_ASSERTION(mCIDEntry->constructorProc, "no getfactory or constructor");
-      factory = new mozilla::GenericFactory(mCIDEntry->constructorProc);
+        if (mModule->Module()->getFactoryProc) {
+            factory = mModule->Module()->getFactoryProc(*mModule->Module(),
+                                                        *mCIDEntry);
+        }
+        else if (mCIDEntry->getFactoryProc) {
+            factory = mCIDEntry->getFactoryProc(*mModule->Module(), *mCIDEntry);
+        }
+        else {
+            NS_ASSERTION(mCIDEntry->constructorProc, "no getfactory or constructor");
+            factory = new mozilla::GenericFactory(mCIDEntry->constructorProc);
+        }
+        if (!factory)
+            return nullptr;
+
+        SafeMutexAutoLock lock(nsComponentManagerImpl::gComponentManager->mLock);
+        // Threads can race to set mFactory
+        if (!mFactory) {
+            factory.swap(mFactory);
+        }
     }
-    if (!factory) {
-      return nullptr;
-    }
-
-    SafeMutexAutoLock lock(nsComponentManagerImpl::gComponentManager->mLock);
-    // Threads can race to set mFactory
-    if (!mFactory) {
-      factory.swap(mFactory);
-    }
-  }
-  nsCOMPtr<nsIFactory> factory = mFactory;
-  return factory.forget();
+    nsCOMPtr<nsIFactory> factory = mFactory;
+    return factory.forget();
 }
 
 size_t
 nsFactoryEntry::SizeOfIncludingThis(MallocSizeOf aMallocSizeOf)
 {
-  size_t n = aMallocSizeOf(this);
+    size_t n = aMallocSizeOf(this);
 
-  // Measurement of the following members may be added later if DMD finds it is
-  // worthwhile:
-  // - mCIDEntry;
-  // - mModule;
-  // - mFactory;
-  // - mServiceObject;
+    // Measurement of the following members may be added later if DMD finds it is
+    // worthwhile:
+    // - mCIDEntry;
+    // - mModule;
+    // - mFactory;
+    // - mServiceObject;
 
-  return n;
+    return n;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Static Access Functions
 ////////////////////////////////////////////////////////////////////////////////
 
 nsresult
-NS_GetComponentManager(nsIComponentManager** aResult)
+NS_GetComponentManager(nsIComponentManager* *result)
 {
-  if (!nsComponentManagerImpl::gComponentManager) {
-    return NS_ERROR_NOT_INITIALIZED;
-  }
+    if (!nsComponentManagerImpl::gComponentManager)
+        return NS_ERROR_NOT_INITIALIZED;
 
-  NS_ADDREF(*aResult = nsComponentManagerImpl::gComponentManager);
-  return NS_OK;
+    NS_ADDREF(*result = nsComponentManagerImpl::gComponentManager);
+    return NS_OK;
 }
 
 nsresult
-NS_GetServiceManager(nsIServiceManager** aResult)
+NS_GetServiceManager(nsIServiceManager* *result)
 {
-  if (!nsComponentManagerImpl::gComponentManager) {
-    return NS_ERROR_NOT_INITIALIZED;
-  }
+    if (!nsComponentManagerImpl::gComponentManager)
+        return NS_ERROR_NOT_INITIALIZED;
 
-  NS_ADDREF(*aResult = nsComponentManagerImpl::gComponentManager);
-  return NS_OK;
+    NS_ADDREF(*result = nsComponentManagerImpl::gComponentManager);
+    return NS_OK;
 }
 
 
 nsresult
-NS_GetComponentRegistrar(nsIComponentRegistrar** aResult)
+NS_GetComponentRegistrar(nsIComponentRegistrar* *result)
 {
-  if (!nsComponentManagerImpl::gComponentManager) {
-    return NS_ERROR_NOT_INITIALIZED;
-  }
+    if (!nsComponentManagerImpl::gComponentManager)
+        return NS_ERROR_NOT_INITIALIZED;
 
-  NS_ADDREF(*aResult = nsComponentManagerImpl::gComponentManager);
-  return NS_OK;
+    NS_ADDREF(*result = nsComponentManagerImpl::gComponentManager);
+    return NS_OK;
 }
 
 EXPORT_XPCOM_API(nsresult)
 XRE_AddStaticComponent(const mozilla::Module* aComponent)
 {
-  nsComponentManagerImpl::InitializeStaticModules();
-  nsComponentManagerImpl::sStaticModules->AppendElement(aComponent);
+    nsComponentManagerImpl::InitializeStaticModules();
+    nsComponentManagerImpl::sStaticModules->AppendElement(aComponent);
 
-  if (nsComponentManagerImpl::gComponentManager &&
-      nsComponentManagerImpl::NORMAL ==
-        nsComponentManagerImpl::gComponentManager->mStatus) {
-    nsComponentManagerImpl::gComponentManager->RegisterModule(aComponent,
-                                                              nullptr);
-  }
+    if (nsComponentManagerImpl::gComponentManager &&
+        nsComponentManagerImpl::NORMAL == nsComponentManagerImpl::gComponentManager->mStatus)
+        nsComponentManagerImpl::gComponentManager->RegisterModule(aComponent, nullptr);
 
-  return NS_OK;
+    return NS_OK;
 }
 
 NS_IMETHODIMP
 nsComponentManagerImpl::AddBootstrappedManifestLocation(nsIFile* aLocation)
 {
   nsString path;
   nsresult rv = aLocation->GetPath(path);
-  if (NS_FAILED(rv)) {
+  if (NS_FAILED(rv))
     return rv;
-  }
 
   if (Substring(path, path.Length() - 4).EqualsLiteral(".xpi")) {
     return XRE_AddJarManifestLocation(NS_BOOTSTRAPPED_LOCATION, aLocation);
   }
 
   nsCOMPtr<nsIFile> manifest =
     CloneAndAppend(aLocation, NS_LITERAL_CSTRING("chrome.manifest"));
   return XRE_AddManifestLocation(NS_BOOTSTRAPPED_LOCATION, manifest);
 }
 
 NS_IMETHODIMP
 nsComponentManagerImpl::RemoveBootstrappedManifestLocation(nsIFile* aLocation)
 {
   nsCOMPtr<nsIChromeRegistry> cr = mozilla::services::GetChromeRegistryService();
-  if (!cr) {
+  if (!cr)
     return NS_ERROR_FAILURE;
-  }
 
   nsCOMPtr<nsIFile> manifest;
   nsString path;
   nsresult rv = aLocation->GetPath(path);
-  if (NS_FAILED(rv)) {
+  if (NS_FAILED(rv))
     return rv;
-  }
 
   nsComponentManagerImpl::ComponentLocation elem;
   elem.type = NS_BOOTSTRAPPED_LOCATION;
 
   if (Substring(path, path.Length() - 4).EqualsLiteral(".xpi")) {
     elem.location.Init(aLocation, "chrome.manifest");
   } else {
-    nsCOMPtr<nsIFile> lf =
-      CloneAndAppend(aLocation, NS_LITERAL_CSTRING("chrome.manifest"));
+    nsCOMPtr<nsIFile> lf = CloneAndAppend(aLocation, NS_LITERAL_CSTRING("chrome.manifest"));
     elem.location.Init(lf);
   }
 
   // Remove reference.
-  nsComponentManagerImpl::sModuleLocations->RemoveElement(elem,
-                                                          ComponentLocationComparator());
+  nsComponentManagerImpl::sModuleLocations->RemoveElement(elem, ComponentLocationComparator());
 
   rv = cr->CheckForNewChrome();
   return rv;
 }
 
 NS_IMETHODIMP
-nsComponentManagerImpl::GetManifestLocations(nsIArray** aLocations)
+nsComponentManagerImpl::GetManifestLocations(nsIArray **aLocations)
 {
   NS_ENSURE_ARG_POINTER(aLocations);
   *aLocations = nullptr;
 
-  if (!sModuleLocations) {
+  if (!sModuleLocations)
     return NS_ERROR_NOT_INITIALIZED;
-  }
 
   nsCOMPtr<nsIMutableArray> locations = nsArray::Create();
   nsresult rv;
   for (uint32_t i = 0; i < sModuleLocations->Length(); ++i) {
     ComponentLocation& l = sModuleLocations->ElementAt(i);
     FileLocation loc = l.location;
     nsCString uriString;
     loc.GetURIString(uriString);
     nsCOMPtr<nsIURI> uri;
     rv = NS_NewURI(getter_AddRefs(uri), uriString);
-    if (NS_SUCCEEDED(rv)) {
+    if (NS_SUCCEEDED(rv))
       locations->AppendElement(uri, false);
-    }
   }
 
   locations.forget(aLocations);
   return NS_OK;
 }
 
 EXPORT_XPCOM_API(nsresult)
 XRE_AddManifestLocation(NSLocationType aType, nsIFile* aLocation)
 {
-  nsComponentManagerImpl::InitializeModuleLocations();
-  nsComponentManagerImpl::ComponentLocation* c =
-    nsComponentManagerImpl::sModuleLocations->AppendElement();
-  c->type = aType;
-  c->location.Init(aLocation);
+    nsComponentManagerImpl::InitializeModuleLocations();
+    nsComponentManagerImpl::ComponentLocation* c = 
+        nsComponentManagerImpl::sModuleLocations->AppendElement();
+    c->type = aType;
+    c->location.Init(aLocation);
 
-  if (nsComponentManagerImpl::gComponentManager &&
-      nsComponentManagerImpl::NORMAL ==
-        nsComponentManagerImpl::gComponentManager->mStatus) {
-    nsComponentManagerImpl::gComponentManager->RegisterManifest(aType,
-                                                                c->location,
-                                                                false);
-  }
+    if (nsComponentManagerImpl::gComponentManager &&
+        nsComponentManagerImpl::NORMAL == nsComponentManagerImpl::gComponentManager->mStatus)
+        nsComponentManagerImpl::gComponentManager->RegisterManifest(aType, c->location, false);
 
-  return NS_OK;
+    return NS_OK;
 }
 
 EXPORT_XPCOM_API(nsresult)
 XRE_AddJarManifestLocation(NSLocationType aType, nsIFile* aLocation)
 {
-  nsComponentManagerImpl::InitializeModuleLocations();
-  nsComponentManagerImpl::ComponentLocation* c =
-    nsComponentManagerImpl::sModuleLocations->AppendElement();
-
-  c->type = aType;
-  c->location.Init(aLocation, "chrome.manifest");
+    nsComponentManagerImpl::InitializeModuleLocations();
+    nsComponentManagerImpl::ComponentLocation* c = 
+        nsComponentManagerImpl::sModuleLocations->AppendElement();
 
-  if (nsComponentManagerImpl::gComponentManager &&
-      nsComponentManagerImpl::NORMAL ==
-        nsComponentManagerImpl::gComponentManager->mStatus) {
-    nsComponentManagerImpl::gComponentManager->RegisterManifest(aType,
-                                                                c->location,
-                                                                false);
-  }
+    c->type = aType;
+    c->location.Init(aLocation, "chrome.manifest");
 
-  return NS_OK;
+    if (nsComponentManagerImpl::gComponentManager &&
+        nsComponentManagerImpl::NORMAL == nsComponentManagerImpl::gComponentManager->mStatus)
+        nsComponentManagerImpl::gComponentManager->RegisterManifest(aType, c->location, false);
+
+    return NS_OK;
 }
 
--- a/xpcom/components/nsComponentManager.h
+++ b/xpcom/components/nsComponentManager.h
@@ -69,295 +69,281 @@ extern const mozilla::Module kXPCOMModul
  * This is a wrapper around mozilla::Mutex which provides runtime
  * checking for a deadlock where the same thread tries to lock a mutex while
  * it is already locked. This checking is present in both debug and release
  * builds.
  */
 class SafeMutex
 {
 public:
-  SafeMutex(const char* aName)
-    : mMutex(aName)
-    , mOwnerThread(nullptr)
-  {
-  }
-
-  ~SafeMutex() {}
+    SafeMutex(const char* name)
+        : mMutex(name)
+        , mOwnerThread(nullptr)
+    { }
+    ~SafeMutex()
+    { }
 
-  void Lock()
-  {
-    AssertNotCurrentThreadOwns();
-    mMutex.Lock();
-    MOZ_ASSERT(mOwnerThread == nullptr);
-    mOwnerThread = PR_GetCurrentThread();
-  }
+    void Lock()
+    {
+        AssertNotCurrentThreadOwns();
+        mMutex.Lock();
+        MOZ_ASSERT(mOwnerThread == nullptr);
+        mOwnerThread = PR_GetCurrentThread();
+    }
 
-  void Unlock()
-  {
-    MOZ_ASSERT(mOwnerThread == PR_GetCurrentThread());
-    mOwnerThread = nullptr;
-    mMutex.Unlock();
-  }
+    void Unlock()
+    {
+        MOZ_ASSERT(mOwnerThread == PR_GetCurrentThread());
+        mOwnerThread = nullptr;
+        mMutex.Unlock();
+    }
 
-  void AssertCurrentThreadOwns() const
-  {
-    // This method is a debug-only check
-    MOZ_ASSERT(mOwnerThread == PR_GetCurrentThread());
-  }
+    void AssertCurrentThreadOwns() const
+    {
+        // This method is a debug-only check
+        MOZ_ASSERT(mOwnerThread == PR_GetCurrentThread());
+    }
 
-  MOZ_NEVER_INLINE void AssertNotCurrentThreadOwns() const
-  {
-    // This method is a release-mode check
-    if (PR_GetCurrentThread() == mOwnerThread) {
-      MOZ_CRASH();
+    MOZ_NEVER_INLINE void AssertNotCurrentThreadOwns() const
+    {
+        // This method is a release-mode check
+        if (PR_GetCurrentThread() == mOwnerThread) {
+            MOZ_CRASH();
+        }
     }
-  }
 
 private:
-  mozilla::Mutex mMutex;
-  volatile PRThread* mOwnerThread;
+    mozilla::Mutex mMutex;
+    volatile PRThread* mOwnerThread;
 };
 
 typedef mozilla::BaseAutoLock<SafeMutex> SafeMutexAutoLock;
 typedef mozilla::BaseAutoUnlock<SafeMutex> SafeMutexAutoUnlock;
 
 class nsComponentManagerImpl MOZ_FINAL
-  : public nsIComponentManager
-  , public nsIServiceManager
-  , public nsSupportsWeakReference
-  , public nsIComponentRegistrar
-  , public nsIInterfaceRequestor
-  , public nsIMemoryReporter
+    : public nsIComponentManager
+    , public nsIServiceManager
+    , public nsSupportsWeakReference
+    , public nsIComponentRegistrar
+    , public nsIInterfaceRequestor
+    , public nsIMemoryReporter
 {
 public:
-  NS_DECL_THREADSAFE_ISUPPORTS
-  NS_DECL_NSIINTERFACEREQUESTOR
-  NS_DECL_NSICOMPONENTMANAGER
-  NS_DECL_NSICOMPONENTREGISTRAR
-  NS_DECL_NSIMEMORYREPORTER
+    NS_DECL_THREADSAFE_ISUPPORTS
+    NS_DECL_NSIINTERFACEREQUESTOR
+    NS_DECL_NSICOMPONENTMANAGER
+    NS_DECL_NSICOMPONENTREGISTRAR
+    NS_DECL_NSIMEMORYREPORTER
 
-  static nsresult Create(nsISupports* aOuter, REFNSIID aIID, void** aResult);
+    static nsresult Create(nsISupports* aOuter, REFNSIID aIID, void** aResult);
 
-  nsresult RegistryLocationForFile(nsIFile* aFile,
-                                   nsCString& aResult);
-  nsresult FileForRegistryLocation(const nsCString& aLocation,
-                                   nsIFile** aSpec);
+    nsresult RegistryLocationForFile(nsIFile* aFile,
+                                     nsCString& aResult);
+    nsresult FileForRegistryLocation(const nsCString &aLocation,
+                                     nsIFile **aSpec);
 
-  NS_DECL_NSISERVICEMANAGER
+    NS_DECL_NSISERVICEMANAGER
 
-  // nsComponentManagerImpl methods:
-  nsComponentManagerImpl();
+    // nsComponentManagerImpl methods:
+    nsComponentManagerImpl();
 
-  static nsComponentManagerImpl* gComponentManager;
-  nsresult Init();
+    static nsComponentManagerImpl* gComponentManager;
+    nsresult Init();
 
-  nsresult Shutdown(void);
+    nsresult Shutdown(void);
 
-  nsresult FreeServices();
+    nsresult FreeServices();
 
-  already_AddRefed<mozilla::ModuleLoader> LoaderForExtension(const nsACString& aExt);
-  nsInterfaceHashtable<nsCStringHashKey, mozilla::ModuleLoader> mLoaderMap;
+    already_AddRefed<mozilla::ModuleLoader> LoaderForExtension(const nsACString& aExt);
+    nsInterfaceHashtable<nsCStringHashKey, mozilla::ModuleLoader> mLoaderMap;
 
-  already_AddRefed<nsIFactory> FindFactory(const nsCID& aClass);
-  already_AddRefed<nsIFactory> FindFactory(const char* aContractID,
-                                           uint32_t aContractIDLen);
+    already_AddRefed<nsIFactory> FindFactory(const nsCID& aClass);
+    already_AddRefed<nsIFactory> FindFactory(const char *contractID,
+                                             uint32_t aContractIDLen);
 
-  already_AddRefed<nsIFactory> LoadFactory(nsFactoryEntry* aEntry);
+    already_AddRefed<nsIFactory> LoadFactory(nsFactoryEntry *aEntry);
 
-  nsFactoryEntry* GetFactoryEntry(const char* aContractID,
-                                  uint32_t aContractIDLen);
-  nsFactoryEntry* GetFactoryEntry(const nsCID& aClass);
+    nsFactoryEntry *GetFactoryEntry(const char *aContractID,
+                                    uint32_t aContractIDLen);
+    nsFactoryEntry *GetFactoryEntry(const nsCID &aClass);
 
-  nsDataHashtable<nsIDHashKey, nsFactoryEntry*> mFactories;
-  nsDataHashtable<nsCStringHashKey, nsFactoryEntry*> mContractIDs;
+    nsDataHashtable<nsIDHashKey, nsFactoryEntry*> mFactories;
+    nsDataHashtable<nsCStringHashKey, nsFactoryEntry*> mContractIDs;
 
-  SafeMutex mLock;
+    SafeMutex mLock;
 
-  static void InitializeStaticModules();
-  static void InitializeModuleLocations();
+    static void InitializeStaticModules();
+    static void InitializeModuleLocations();
 
-  struct ComponentLocation
-  {
-    NSLocationType type;
-    mozilla::FileLocation location;
-  };
+    struct ComponentLocation
+    {
+        NSLocationType type;
+        mozilla::FileLocation location;
+    };
 
-  class ComponentLocationComparator
-  {
-  public:
-    bool Equals(const ComponentLocation& aA,
-                const ComponentLocation& aB) const
+    class ComponentLocationComparator
     {
-      return (aA.type == aB.type && aA.location.Equals(aB.location));
-    }
-  };
+    public:
+      bool Equals(const ComponentLocation& a, const ComponentLocation& b) const
+      {
+        return (a.type == b.type && a.location.Equals(b.location));
+      }
+    };
 
-  static nsTArray<const mozilla::Module*>* sStaticModules;
-  static nsTArray<ComponentLocation>* sModuleLocations;
+    static nsTArray<const mozilla::Module*>* sStaticModules;
+    static nsTArray<ComponentLocation>* sModuleLocations;
 
-  nsNativeModuleLoader mNativeModuleLoader;
-
-  class KnownModule
-  {
-  public:
-    /**
-     * Static or binary module.
-     */
-    KnownModule(const mozilla::Module* aModule, mozilla::FileLocation& aFile)
-      : mModule(aModule)
-      , mFile(aFile)
-      , mLoaded(false)
-      , mFailed(false)
-    {
-    }
+    nsNativeModuleLoader mNativeModuleLoader;
 
-    KnownModule(const mozilla::Module* aModule)
-      : mModule(aModule)
-      , mLoaded(false)
-      , mFailed(false)
-    {
-    }
-
-    KnownModule(mozilla::FileLocation& aFile)
-      : mModule(nullptr)
-      , mFile(aFile)
-      , mLoader(nullptr)
-      , mLoaded(false)
-      , mFailed(false)
-    {
-    }
-
-    ~KnownModule()
+    class KnownModule
     {
-      if (mLoaded && mModule->unloadProc) {
-        mModule->unloadProc();
-      }
-    }
-
-    bool EnsureLoader();
-    bool Load();
+    public:
+        /**
+         * Static or binary module.
+         */
+        KnownModule(const mozilla::Module* aModule, mozilla::FileLocation &aFile)
+            : mModule(aModule)
+            , mFile(aFile)
+            , mLoaded(false)
+            , mFailed(false)
+        { }
 
-    const mozilla::Module* Module() const { return mModule; }
+        KnownModule(const mozilla::Module* aModule)
+            : mModule(aModule)
+            , mLoaded(false)
+            , mFailed(false)
+        { }
 
-    /**
-     * For error logging, get a description of this module, either the
-     * file path, or <static module>.
-     */
-    nsCString Description() const;
+        KnownModule(mozilla::FileLocation &aFile)
+            : mModule(nullptr)
+            , mFile(aFile)
+            , mLoader(nullptr)
+            , mLoaded(false)
+            , mFailed(false)
+        { }
+
+        ~KnownModule()
+        {
+            if (mLoaded && mModule->unloadProc)
+                mModule->unloadProc();
+        }
 
-  private:
-    const mozilla::Module* mModule;
-    mozilla::FileLocation mFile;
-    nsCOMPtr<mozilla::ModuleLoader> mLoader;
-    bool mLoaded;
-    bool mFailed;
-  };
+        bool EnsureLoader();
+        bool Load();
+
+        const mozilla::Module* Module() const
+        {
+            return mModule;
+        }
+
+        /**
+         * For error logging, get a description of this module, either the
+         * file path, or <static module>.
+         */
+        nsCString Description() const;
 
-  // The KnownModule is kept alive by these members, it is
-  // referenced by pointer from the factory entries.
-  nsTArray<nsAutoPtr<KnownModule>> mKnownStaticModules;
-  // The key is the URI string of the module
-  nsClassHashtable<nsCStringHashKey, KnownModule> mKnownModules;
+    private:
+        const mozilla::Module* mModule;
+        mozilla::FileLocation mFile;
+        nsCOMPtr<mozilla::ModuleLoader> mLoader;
+        bool mLoaded;
+        bool mFailed;
+    };
 
-  // Mutex not held
-  void RegisterModule(const mozilla::Module* aModule,
-                      mozilla::FileLocation* aFile);
+    // The KnownModule is kept alive by these members, it is
+    // referenced by pointer from the factory entries.
+    nsTArray< nsAutoPtr<KnownModule> > mKnownStaticModules;
+    // The key is the URI string of the module
+    nsClassHashtable<nsCStringHashKey, KnownModule> mKnownModules;
+
+    // Mutex not held
+    void RegisterModule(const mozilla::Module* aModule,
+                        mozilla::FileLocation* aFile);
 
 
-  // Mutex held
-  void RegisterCIDEntryLocked(const mozilla::Module::CIDEntry* aEntry,
-                              KnownModule* aModule);
-  void RegisterContractIDLocked(const mozilla::Module::ContractIDEntry* aEntry);
+    // Mutex held
+    void RegisterCIDEntryLocked(const mozilla::Module::CIDEntry* aEntry,
+                          KnownModule* aModule);
+    void RegisterContractIDLocked(const mozilla::Module::ContractIDEntry* aEntry);
 
-  // Mutex not held
-  void RegisterManifest(NSLocationType aType, mozilla::FileLocation& aFile,
-                        bool aChromeOnly);
+    // Mutex not held
+    void RegisterManifest(NSLocationType aType, mozilla::FileLocation &aFile,
+                          bool aChromeOnly);
 
-  struct ManifestProcessingContext
-  {
-    ManifestProcessingContext(NSLocationType aType,
-                              mozilla::FileLocation& aFile,
-                              bool aChromeOnly)
-      : mType(aType)
-      , mFile(aFile)
-      , mChromeOnly(aChromeOnly)
+    struct ManifestProcessingContext
     {
-    }
-
-    ~ManifestProcessingContext() {}
+        ManifestProcessingContext(NSLocationType aType, mozilla::FileLocation &aFile, bool aChromeOnly)
+            : mType(aType)
+            , mFile(aFile)
+            , mChromeOnly(aChromeOnly)
+        { }
 
-    NSLocationType mType;
-    mozilla::FileLocation mFile;
-    bool mChromeOnly;
-  };
+        ~ManifestProcessingContext() { }
+
+        NSLocationType mType;
+        mozilla::FileLocation mFile;
+        bool mChromeOnly;
+    };
 
-  void ManifestManifest(ManifestProcessingContext& aCx, int aLineNo,
-                        char* const* aArgv);
-  void ManifestBinaryComponent(ManifestProcessingContext& aCx, int aLineNo,
-                               char* const* aArgv);
-  void ManifestXPT(ManifestProcessingContext& aCx, int aLineNo,
-                   char* const* aArgv);
-  void ManifestComponent(ManifestProcessingContext& aCx, int aLineNo,
-                         char* const* aArgv);
-  void ManifestContract(ManifestProcessingContext& aCx, int aLineNo,
-                        char* const* aArgv);
-  void ManifestCategory(ManifestProcessingContext& aCx, int aLineNo,
-                        char* const* aArgv);
+    void ManifestManifest(ManifestProcessingContext& cx, int lineno, char *const * argv);
+    void ManifestBinaryComponent(ManifestProcessingContext& cx, int lineno, char *const * argv);
+    void ManifestXPT(ManifestProcessingContext& cx, int lineno, char *const * argv);
+    void ManifestComponent(ManifestProcessingContext& cx, int lineno, char *const * argv);
+    void ManifestContract(ManifestProcessingContext& cx, int lineno, char* const * argv);
+    void ManifestCategory(ManifestProcessingContext& cx, int lineno, char* const * argv);
 
-  void RereadChromeManifests(bool aChromeOnly = true);
+    void RereadChromeManifests(bool aChromeOnly = true);
 
-  // Shutdown
-  enum
-  {
-    NOT_INITIALIZED,
-    NORMAL,
-    SHUTDOWN_IN_PROGRESS,
-    SHUTDOWN_COMPLETE
-  } mStatus;
+    // Shutdown
+    enum {
+        NOT_INITIALIZED,
+        NORMAL,
+        SHUTDOWN_IN_PROGRESS,
+        SHUTDOWN_COMPLETE
+    } mStatus;
 
-  PLArenaPool   mArena;
+    PLArenaPool   mArena;
 
-  struct PendingServiceInfo
-  {
-    const nsCID* cid;
-    PRThread* thread;
-  };
+    struct PendingServiceInfo {
+      const nsCID* cid;
+      PRThread* thread;
+    };
 
-  inline PendingServiceInfo* AddPendingService(const nsCID& aServiceCID,
-                                               PRThread* aThread);
-  inline void RemovePendingService(const nsCID& aServiceCID);
-  inline PRThread* GetPendingServiceThread(const nsCID& aServiceCID) const;
+    inline PendingServiceInfo* AddPendingService(const nsCID& aServiceCID,
+                                                 PRThread* aThread);
+    inline void RemovePendingService(const nsCID& aServiceCID);
+    inline PRThread* GetPendingServiceThread(const nsCID& aServiceCID) const;
 
-  nsTArray<PendingServiceInfo> mPendingServices;
+    nsTArray<PendingServiceInfo> mPendingServices;
 
-  size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf);
+    size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf);
 
 private:
-  ~nsComponentManagerImpl();
+    ~nsComponentManagerImpl();
 };
 
 
 #define NS_MAX_FILENAME_LEN     1024
 
 #define NS_ERROR_IS_DIR NS_ERROR_GENERATE_FAILURE(NS_ERROR_MODULE_XPCOM, 24)
 
 struct nsFactoryEntry
 {
-  nsFactoryEntry(const mozilla::Module::CIDEntry* aEntry,
-                 nsComponentManagerImpl::KnownModule* aModule);
+    nsFactoryEntry(const mozilla::Module::CIDEntry* entry,
+                   nsComponentManagerImpl::KnownModule* module);
 
-  // nsIComponentRegistrar.registerFactory support
-  nsFactoryEntry(const nsCID& aClass, nsIFactory* aFactory);
+    // nsIComponentRegistrar.registerFactory support
+    nsFactoryEntry(const nsCID& aClass, nsIFactory* factory);
 
-  ~nsFactoryEntry();
+    ~nsFactoryEntry();
 
-  already_AddRefed<nsIFactory> GetFactory();
+    already_AddRefed<nsIFactory> GetFactory();
 
-  size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf);
+    size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf);
 
-  const mozilla::Module::CIDEntry* mCIDEntry;
-  nsComponentManagerImpl::KnownModule* mModule;
+    const mozilla::Module::CIDEntry* mCIDEntry;
+    nsComponentManagerImpl::KnownModule* mModule;
 
-  nsCOMPtr<nsIFactory>   mFactory;
-  nsCOMPtr<nsISupports>  mServiceObject;
+    nsCOMPtr<nsIFactory>   mFactory;
+    nsCOMPtr<nsISupports>  mServiceObject;
 };
 
 #endif // nsComponentManager_h__
--- a/xpcom/components/nsNativeModuleLoader.cpp
+++ b/xpcom/components/nsNativeModuleLoader.cpp
@@ -48,197 +48,193 @@
 #endif
 
 #ifdef DEBUG
 #define IMPLEMENT_BREAK_AFTER_LOAD
 #endif
 
 using namespace mozilla;
 
-static PRLogModuleInfo*
+static PRLogModuleInfo *
 GetNativeModuleLoaderLog()
 {
-  static PRLogModuleInfo* sLog;
-  if (!sLog) {
-    sLog = PR_NewLogModule("nsNativeModuleLoader");
-  }
-  return sLog;
+    static PRLogModuleInfo *sLog;
+    if (!sLog)
+        sLog = PR_NewLogModule("nsNativeModuleLoader");
+    return sLog;
 }
 
 #define LOG(level, args) PR_LOG(GetNativeModuleLoaderLog(), level, args)
 
 nsresult
 nsNativeModuleLoader::Init()
 {
-  MOZ_ASSERT(NS_IsMainThread(), "Startup not on main thread?");
-  LOG(PR_LOG_DEBUG, ("nsNativeModuleLoader::Init()"));
-  return NS_OK;
+    MOZ_ASSERT(NS_IsMainThread(), "Startup not on main thread?");
+    LOG(PR_LOG_DEBUG, ("nsNativeModuleLoader::Init()"));
+    return NS_OK;
 }
 
 class LoadModuleMainThreadRunnable : public nsRunnable
 {
 public:
-  LoadModuleMainThreadRunnable(nsNativeModuleLoader* aLoader,
-                               FileLocation& aFile)
-    : mManager(nsComponentManagerImpl::gComponentManager)
-    , mLoader(aLoader)
-    , mFile(aFile)
-    , mResult(nullptr)
-  {
-  }
+    LoadModuleMainThreadRunnable(nsNativeModuleLoader* aLoader,
+                                 FileLocation &aFile)
+        : mManager(nsComponentManagerImpl::gComponentManager)
+        , mLoader(aLoader)
+        , mFile(aFile)
+        , mResult(nullptr)
+    { }
 
-  NS_IMETHOD Run()
-  {
-    mResult = mLoader->LoadModule(mFile);
-    return NS_OK;
-  }
+    NS_IMETHOD Run()
+    {
+        mResult = mLoader->LoadModule(mFile);
+        return NS_OK;
+    }
 
-  nsRefPtr<nsComponentManagerImpl> mManager;
-  nsNativeModuleLoader* mLoader;
-  FileLocation mFile;
-  const mozilla::Module* mResult;
+    nsRefPtr<nsComponentManagerImpl> mManager;
+    nsNativeModuleLoader* mLoader;
+    FileLocation mFile;
+    const mozilla::Module* mResult;
 };
 
 const mozilla::Module*
-nsNativeModuleLoader::LoadModule(FileLocation& aFile)
+nsNativeModuleLoader::LoadModule(FileLocation &aFile)
 {
-  if (aFile.IsZip()) {
-    NS_ERROR("Binary components cannot be loaded from JARs");
-    return nullptr;
-  }
-  nsCOMPtr<nsIFile> file = aFile.GetBaseFile();
-  nsresult rv;
+    if (aFile.IsZip()) {
+        NS_ERROR("Binary components cannot be loaded from JARs");
+        return nullptr;
+    }
+    nsCOMPtr<nsIFile> file = aFile.GetBaseFile();
+    nsresult rv;
 
-  if (!NS_IsMainThread()) {
-    // If this call is off the main thread, synchronously proxy it
-    // to the main thread.
-    nsRefPtr<LoadModuleMainThreadRunnable> r =
-      new LoadModuleMainThreadRunnable(this, aFile);
-    NS_DispatchToMainThread(r, NS_DISPATCH_SYNC);
-    return r->mResult;
-  }
-
-  nsCOMPtr<nsIHashable> hashedFile(do_QueryInterface(file));
-  if (!hashedFile) {
-    NS_ERROR("nsIFile is not nsIHashable");
-    return nullptr;
-  }
+    if (!NS_IsMainThread()) {
+        // If this call is off the main thread, synchronously proxy it
+        // to the main thread.
+        nsRefPtr<LoadModuleMainThreadRunnable> r = new LoadModuleMainThreadRunnable(this, aFile);
+        NS_DispatchToMainThread(r, NS_DISPATCH_SYNC);
+        return r->mResult;
+    }
 
-  nsAutoCString filePath;
-  file->GetNativePath(filePath);
-
-  NativeLoadData data;
+    nsCOMPtr<nsIHashable> hashedFile(do_QueryInterface(file));
+    if (!hashedFile) {
+        NS_ERROR("nsIFile is not nsIHashable");
+        return nullptr;
+    }
 
-  if (mLibraries.Get(hashedFile, &data)) {
-    NS_ASSERTION(data.mModule, "Corrupt mLibraries hash");
-    LOG(PR_LOG_DEBUG,
-        ("nsNativeModuleLoader::LoadModule(\"%s\") - found in cache",
-         filePath.get()));
-    return data.mModule;
-  }
+    nsAutoCString filePath;
+    file->GetNativePath(filePath);
+
+    NativeLoadData data;
 
-  // We haven't loaded this module before
-  {
+    if (mLibraries.Get(hashedFile, &data)) {
+        NS_ASSERTION(data.mModule, "Corrupt mLibraries hash");
+        LOG(PR_LOG_DEBUG,
+            ("nsNativeModuleLoader::LoadModule(\"%s\") - found in cache",
+             filePath.get()));
+        return data.mModule;
+    }
+
+    // We haven't loaded this module before
+    {
 #ifdef HAS_DLL_BLOCKLIST
-    AutoSetXPCOMLoadOnMainThread guard;
+      AutoSetXPCOMLoadOnMainThread guard;
 #endif
-    rv = file->Load(&data.mLibrary);
-  }
-
-  if (NS_FAILED(rv)) {
-    char errorMsg[1024] = "<unknown; can't get error from NSPR>";
-
-    if (PR_GetErrorTextLength() < (int)sizeof(errorMsg)) {
-      PR_GetErrorText(errorMsg);
+      rv = file->Load(&data.mLibrary);
     }
 
-    LogMessage("Failed to load native module at path '%s': (%lx) %s",
-               filePath.get(), rv, errorMsg);
-
-    return nullptr;
-  }
+    if (NS_FAILED(rv)) {
+        char errorMsg[1024] = "<unknown; can't get error from NSPR>";
 
-#ifdef IMPLEMENT_BREAK_AFTER_LOAD
-  nsAutoCString leafName;
-  file->GetNativeLeafName(leafName);
+        if (PR_GetErrorTextLength() < (int) sizeof(errorMsg))
+            PR_GetErrorText(errorMsg);
 
-  char* env = getenv("XPCOM_BREAK_ON_LOAD");
-  char* blist;
-  if (env && *env && (blist = strdup(env))) {
-    char* nextTok = blist;
-    while (char* token = NS_strtok(":", &nextTok)) {
-      if (leafName.Find(token, true) != kNotFound) {
-        NS_BREAK();
-      }
+        LogMessage("Failed to load native module at path '%s': (%lx) %s",
+                   filePath.get(), rv, errorMsg);
+
+        return nullptr;
     }
 
-    free(blist);
-  }
+#ifdef IMPLEMENT_BREAK_AFTER_LOAD
+    nsAutoCString leafName;
+    file->GetNativeLeafName(leafName);
+
+    char *env = getenv("XPCOM_BREAK_ON_LOAD");
+    char *blist;
+    if (env && *env && (blist = strdup(env))) {
+        char *nextTok = blist;
+        while (char *token = NS_strtok(":", &nextTok)) {
+            if (leafName.Find(token, true) != kNotFound) {
+                NS_BREAK();
+            }
+        }
+
+        free(blist);
+    }
 #endif
 
-  void* module = PR_FindSymbol(data.mLibrary, "NSModule");
-  if (!module) {
-    LogMessage("Native module at path '%s' doesn't export symbol `NSModule`.",
-               filePath.get());
-    PR_UnloadLibrary(data.mLibrary);
-    return nullptr;
-  }
+    void *module = PR_FindSymbol(data.mLibrary, "NSModule");
+    if (!module) {
+        LogMessage("Native module at path '%s' doesn't export symbol `NSModule`.",
+                   filePath.get());
+        PR_UnloadLibrary(data.mLibrary);
+        return nullptr;
+    }
 
-  data.mModule = *(mozilla::Module const* const*)module;
-  if (mozilla::Module::kVersion != data.mModule->mVersion) {
-    LogMessage("Native module at path '%s' is incompatible with this version of Firefox, has version %i, expected %i.",
-               filePath.get(), data.mModule->mVersion,
-               mozilla::Module::kVersion);
-    PR_UnloadLibrary(data.mLibrary);
-    return nullptr;
-  }
+    data.mModule = *(mozilla::Module const *const *) module;
+    if (mozilla::Module::kVersion != data.mModule->mVersion) {
+        LogMessage("Native module at path '%s' is incompatible with this version of Firefox, has version %i, expected %i.",
+                   filePath.get(), data.mModule->mVersion,
+                   mozilla::Module::kVersion);
+        PR_UnloadLibrary(data.mLibrary);
+        return nullptr;
+    }
 
-  mLibraries.Put(hashedFile, data); // infallible
-  return data.mModule;
+    mLibraries.Put(hashedFile, data); // infallible
+    return data.mModule;
 }
 
 PLDHashOperator
 nsNativeModuleLoader::ReleaserFunc(nsIHashable* aHashedFile,
                                    NativeLoadData& aLoadData, void*)
 {
-  aLoadData.mModule = nullptr;
-  return PL_DHASH_NEXT;
+    aLoadData.mModule = nullptr;
+    return PL_DHASH_NEXT;
 }
 
 PLDHashOperator
 nsNativeModuleLoader::UnloaderFunc(nsIHashable* aHashedFile,
                                    NativeLoadData& aLoadData, void*)
 {
-  if (PR_LOG_TEST(GetNativeModuleLoaderLog(), PR_LOG_DEBUG)) {
-    nsCOMPtr<nsIFile> file(do_QueryInterface(aHashedFile));
+    if (PR_LOG_TEST(GetNativeModuleLoaderLog(), PR_LOG_DEBUG)) {
+        nsCOMPtr<nsIFile> file(do_QueryInterface(aHashedFile));
 
-    nsAutoCString filePath;
-    file->GetNativePath(filePath);
+        nsAutoCString filePath;
+        file->GetNativePath(filePath);
 
-    LOG(PR_LOG_DEBUG,
-        ("nsNativeModuleLoader::UnloaderFunc(\"%s\")", filePath.get()));
-  }
+        LOG(PR_LOG_DEBUG,
+            ("nsNativeModuleLoader::UnloaderFunc(\"%s\")", filePath.get()));
+    }
 
 #ifdef NS_BUILD_REFCNT_LOGGING
-  nsTraceRefcnt::SetActivityIsLegal(false);
+    nsTraceRefcnt::SetActivityIsLegal(false);
 #endif
 
 #if 0
-  // XXXbsmedberg: do this as soon as the static-destructor crash(es)
-  // are fixed
-  PRStatus ret = PR_UnloadLibrary(aLoadData.mLibrary);
-  NS_ASSERTION(ret == PR_SUCCESS, "Failed to unload library");
+    // XXXbsmedberg: do this as soon as the static-destructor crash(es)
+    // are fixed
+    PRStatus ret = PR_UnloadLibrary(aLoadData.mLibrary);
+    NS_ASSERTION(ret == PR_SUCCESS, "Failed to unload library");
 #endif
 
 #ifdef NS_BUILD_REFCNT_LOGGING
-  nsTraceRefcnt::SetActivityIsLegal(true);
+    nsTraceRefcnt::SetActivityIsLegal(true);
 #endif
 
-  return PL_DHASH_REMOVE;
+    return PL_DHASH_REMOVE;
 }
 
 void
 nsNativeModuleLoader::UnloadLibraries()
 {
-  MOZ_ASSERT(NS_IsMainThread(), "Shutdown not on main thread?");
-  mLibraries.Enumerate(ReleaserFunc, nullptr);
-  mLibraries.Enumerate(UnloaderFunc, nullptr);
+    MOZ_ASSERT(NS_IsMainThread(), "Shutdown not on main thread?");
+    mLibraries.Enumerate(ReleaserFunc, nullptr);
+    mLibraries.Enumerate(UnloaderFunc, nullptr);
 }
--- a/xpcom/components/nsNativeModuleLoader.h
+++ b/xpcom/components/nsNativeModuleLoader.h
@@ -11,34 +11,37 @@
 #include "prlink.h"
 
 namespace mozilla {
 class FileLocation;
 }
 
 class nsNativeModuleLoader MOZ_FINAL
 {
-public:
-  const mozilla::Module* LoadModule(mozilla::FileLocation& aFile);
-
-  nsresult Init();
+ public:
+    const mozilla::Module* LoadModule(mozilla::FileLocation &aFile);
 
-  void UnloadLibraries();
+    nsresult Init();
 
-private:
-  struct NativeLoadData
-  {
-    NativeLoadData() : mModule(nullptr), mLibrary(nullptr) {}
+    void UnloadLibraries();
 
-    const mozilla::Module* mModule;
-    PRLibrary* mLibrary;
-  };
+ private:
+    struct NativeLoadData
+    {
+        NativeLoadData()
+            : mModule(nullptr)
+            , mLibrary(nullptr)
+        { }
 
-  static PLDHashOperator
-  ReleaserFunc(nsIHashable* aHashedFile, NativeLoadData& aLoadData, void*);
+        const mozilla::Module* mModule;
+        PRLibrary* mLibrary;
+    };
 
-  static PLDHashOperator
-  UnloaderFunc(nsIHashable* aHashedFile, NativeLoadData& aLoadData, void*);
+    static PLDHashOperator
+    ReleaserFunc(nsIHashable* aHashedFile, NativeLoadData &aLoadData, void*);
 
-  nsDataHashtable<nsHashableHashKey, NativeLoadData> mLibraries;
+    static PLDHashOperator
+    UnloaderFunc(nsIHashable* aHashedFile, NativeLoadData &aLoadData, void*);
+
+    nsDataHashtable<nsHashableHashKey, NativeLoadData> mLibraries;
 };
 
 #endif /* nsNativeModuleLoader_h__ */