Backout changesets 7ff3cd713466, f8ec5977a454 and c7c37390b46b (bug 977026) for b2g bustage on a CLOSED TREE.
authorMike Hommey <mh+mozilla@glandium.org>
Tue, 29 Jul 2014 14:50:41 +0900
changeset 219363 b17cad2d1e5e6bcb5a10096d51d07ea8a79b6921
parent 219362 78dbda7034771454acdba2055956f48fcc8672e4
child 219383 c735ac304dd1c2d2949ba38dd50f3102983729ec
child 219405 4e2a92a90646d36b7837936918f9e60ee2fb9351
child 219407 79d9d8c334cb9c3c37ac0ae8a6742143667c2235
push id583
push userbhearsum@mozilla.com
push dateMon, 24 Nov 2014 19:04:58 +0000
treeherdermozilla-release@c107e74250f4 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
bugs977026
milestone34.0a1
backs out7ff3cd713466b3153a535cda8d459302bc64ee88
f8ec5977a4545cf4fed5aa2547b22c58bace58b2
c7c37390b46bae7d8319e8596057f3c3e0930f26
first release with
nightly linux32
b17cad2d1e5e / 34.0a1 / 20140729030202 / files
nightly linux64
b17cad2d1e5e / 34.0a1 / 20140729030202 / files
nightly mac
b17cad2d1e5e / 34.0a1 / 20140729030202 / files
nightly win32
b17cad2d1e5e / 34.0a1 / 20140729030202 / files
nightly win64
b17cad2d1e5e / 34.0a1 / 20140729030202 / files
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
releases
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Backout changesets 7ff3cd713466, f8ec5977a454 and c7c37390b46b (bug 977026) for b2g bustage on a CLOSED TREE.
b2g/app/B2GLoader.cpp
b2g/app/moz.build
b2g/app/nsBrowserApp.cpp
b2g/confvars.sh
configure.in
ipc/app/Makefile.in
ipc/app/MozillaRuntimeMain.cpp
ipc/chromium/src/base/process_util_linux.cc
ipc/contentproc/moz.build
ipc/contentproc/plugin-container.cpp
ipc/glue/PProcLoader.ipdl
ipc/glue/ProcessUtils.h
ipc/glue/ProcessUtils_linux.cpp
ipc/glue/moz.build
ipc/moz.build
toolkit/xre/moz.build
toolkit/xre/nsAppRunner.cpp
toolkit/xre/nsEmbedFunctions.cpp
tools/profiler/platform.cpp
xpcom/base/nsDebugImpl.cpp
xpcom/build/nsXULAppAPI.h
xpcom/components/ManifestParser.cpp
xpcom/components/ManifestParser.h
xpcom/components/nsComponentManager.cpp
xpcom/components/nsComponentManager.h
xpcom/threads/BackgroundHangMonitor.cpp
xpcom/threads/BackgroundHangMonitor.h
deleted file mode 100644
--- a/b2g/app/B2GLoader.cpp
+++ /dev/null
@@ -1,248 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* vim: set sw=2 ts=2 autoindent cindent expandtab: */
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this file,
- * You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-#include "nsXULAppAPI.h"
-#include "application.ini.h"
-#include "nsXPCOMGlue.h"
-#include "nsStringGlue.h"
-#include "nsCOMPtr.h"
-#include "nsIFile.h"
-#include "BinaryPath.h"
-#include "nsAutoPtr.h"
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <fcntl.h>
-#include <sys/types.h>
-#include <sys/socket.h>
-
-#include <dlfcn.h>
-
-#include "nsXPCOMPrivate.h" // for MAXPATHLEN and XPCOM_DLL
-
-#define ASSERT(x) if (!(x)) { MOZ_CRASH(); }
-
-
-// Functions being loaded by XPCOMGlue
-XRE_ProcLoaderServiceRunType XRE_ProcLoaderServiceRun;
-XRE_ProcLoaderClientInitType XRE_ProcLoaderClientInit;
-XRE_ProcLoaderPreloadType XRE_ProcLoaderPreload;
-extern XRE_CreateAppDataType XRE_CreateAppData;
-extern XRE_GetFileFromPathType XRE_GetFileFromPath;
-
-static const nsDynamicFunctionLoad kXULFuncs[] = {
-  { "XRE_ProcLoaderServiceRun", (NSFuncPtr*) &XRE_ProcLoaderServiceRun },
-  { "XRE_ProcLoaderClientInit", (NSFuncPtr*) &XRE_ProcLoaderClientInit },
-  { "XRE_ProcLoaderPreload", (NSFuncPtr*) &XRE_ProcLoaderPreload },
-  { "XRE_CreateAppData", (NSFuncPtr*) &XRE_CreateAppData },
-  { "XRE_GetFileFromPath", (NSFuncPtr*) &XRE_GetFileFromPath },
-  { nullptr, nullptr }
-};
-
-static int
-GetDirnameSlash(const char *aPath, char *aOutDir, int aMaxLen)
-{
-  char *lastSlash = strrchr(aPath, XPCOM_FILE_PATH_SEPARATOR[0]);
-  if (lastSlash == nullptr) {
-    return 0;
-  }
-  int cpsz = lastSlash - aPath + 1; // include slash
-  if (aMaxLen <= cpsz) {
-    return 0;
-  }
-  strncpy(aOutDir, aPath, cpsz);
-  aOutDir[cpsz] = 0;
-  return cpsz;
-}
-
-static bool
-GetXPCOMPath(const char *aProgram, char *aOutPath, int aMaxLen)
-{
-  nsAutoArrayPtr<char> progBuf(new char[aMaxLen]);
-  nsresult rv = mozilla::BinaryPath::Get(aProgram, progBuf);
-  NS_ENSURE_SUCCESS(rv, false);
-
-  int len = GetDirnameSlash(progBuf, aOutPath, aMaxLen);
-  NS_ENSURE_TRUE(!!len, false);
-
-  NS_ENSURE_TRUE((len + sizeof(XPCOM_DLL)) < aMaxLen, false);
-  char *afterSlash = aOutPath + len;
-  strcpy(afterSlash, XPCOM_DLL);
-  return true;
-}
-
-static bool
-LoadLibxul(const char *aXPCOMPath)
-{
-  nsresult rv;
-
-  XPCOMGlueEnablePreload();
-  rv = XPCOMGlueStartup(aXPCOMPath);
-  NS_ENSURE_SUCCESS(rv, false);
-
-  rv = XPCOMGlueLoadXULFunctions(kXULFuncs);
-  NS_ENSURE_SUCCESS(rv, false);
-
-  return true;
-}
-
-/**
- * Return true if |arg| matches the given argument name.
- */
-static bool
-IsArg(const char* arg, const char* s)
-{
-  if (*arg == '-') {
-    if (*++arg == '-') {
-      ++arg;
-    }
-    return !strcasecmp(arg, s);
-  }
-
-#if defined(XP_WIN)
-  if (*arg == '/') {
-    return !strcasecmp(++arg, s);
-  }
-#endif
-
-  return false;
-}
-
-static already_AddRefed<nsIFile>
-GetAppIni(int argc, const char *argv[])
-{
-  nsCOMPtr<nsIFile> appini;
-  nsresult rv;
-
-  // Allow firefox.exe to launch XULRunner apps via -app <application.ini>
-  // Note that -app must be the *first* argument.
-  const char *appDataFile = getenv("XUL_APP_FILE");
-  if (appDataFile && *appDataFile) {
-    rv = XRE_GetFileFromPath(appDataFile, getter_AddRefs(appini));
-    NS_ENSURE_SUCCESS(rv, nullptr);
-  } else if (argc > 1 && IsArg(argv[1], "app")) {
-    if (argc == 2) {
-      return nullptr;
-    }
-
-    rv = XRE_GetFileFromPath(argv[2], getter_AddRefs(appini));
-    NS_ENSURE_SUCCESS(rv, nullptr);
-
-    char appEnv[MAXPATHLEN];
-    snprintf(appEnv, MAXPATHLEN, "XUL_APP_FILE=%s", argv[2]);
-    if (putenv(appEnv)) {
-      return nullptr;
-    }
-  }
-
-  return appini.forget();
-}
-
-static bool
-LoadStaticData(int argc, const char *argv[])
-{
-  char xpcomPath[MAXPATHLEN];
-  bool ok = GetXPCOMPath(argv[0], xpcomPath, MAXPATHLEN);
-  NS_ENSURE_TRUE(ok, false);
-
-  ok = LoadLibxul(xpcomPath);
-  NS_ENSURE_TRUE(ok, false);
-
-  char progDir[MAXPATHLEN];
-  ok = GetDirnameSlash(xpcomPath, progDir, MAXPATHLEN);
-  NS_ENSURE_TRUE(ok, false);
-
-  nsCOMPtr<nsIFile> appini = GetAppIni(argc, argv);
-  const nsXREAppData *appData;
-  if (appini) {
-    nsresult rv =
-      XRE_CreateAppData(appini, const_cast<nsXREAppData**>(&appData));
-    NS_ENSURE_SUCCESS(rv, false);
-  } else {
-    appData = &sAppData;
-  }
-
-  XRE_ProcLoaderPreload(progDir, appData);
-
-  if (appini) {
-    XRE_FreeAppData(const_cast<nsXREAppData*>(appData));
-  }
-
-  return true;
-}
-
-/**
- * Fork and run parent and child process.
- *
- * The parent is the b2g process and child for Nuwa.
- */
-static int
-RunProcesses(int argc, const char *argv[])
-{
-  /*
-   * The original main() of the b2g process.  It is renamed to
-   * b2g_main() for the b2g loader.
-   */
-  int b2g_main(int argc, const char *argv[]);
-
-  int ipcSockets[2] = {-1, -1};
-  int r = socketpair(AF_LOCAL, SOCK_STREAM, 0, ipcSockets);
-  ASSERT(r == 0);
-  int parentSock = ipcSockets[0];
-  int childSock = ipcSockets[1];
-
-  r = fcntl(parentSock, F_SETFL, O_NONBLOCK);
-  ASSERT(r != -1);
-  r = fcntl(childSock, F_SETFL, O_NONBLOCK);
-  ASSERT(r != -1);
-
-  pid_t pid = fork();
-  ASSERT(pid >= 0);
-  bool isChildProcess = pid == 0;
-
-  close(isChildProcess ? parentSock : childSock);
-
-  if (isChildProcess) {
-    /* The Nuwa process */
-    /* This provides the IPC service of loading Nuwa at the process.
-     * The b2g process would send a IPC message of loading Nuwa
-     * as the replacement of forking and executing plugin-container.
-     */
-    return XRE_ProcLoaderServiceRun(getppid(), childSock, argc, argv);
-  }
-
-  // The b2g process
-  int childPid = pid;
-  XRE_ProcLoaderClientInit(childPid, parentSock);
-  return b2g_main(argc, argv);
-}
-
-/**
- * B2G Loader is responsible for loading the b2g process and the
- * Nuwa process.  It forks into the parent process, for the b2g
- * process, and the child process, for the Nuwa process.
- *
- * The loader loads libxul and performs initialization of static data
- * before forking, so relocation of libxul and static data can be
- * shared between the b2g process, the Nuwa process, and the content
- * processes.
- */
-int
-main(int argc, const char* argv[])
-{
-  const char *program = argv[0];
-  /*
-   * Before fork(), libxul and static data of Gecko are loaded for
-   * sharing.
-   */
-  bool ok = LoadStaticData(argc, argv);
-  if (!ok) {
-    return 255;
-  }
-
-  return RunProcesses(argc, argv);
-}
--- a/b2g/app/moz.build
+++ b/b2g/app/moz.build
@@ -4,21 +4,16 @@
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 if not CONFIG['LIBXUL_SDK']:
     if CONFIG['GAIADIR']:
         PROGRAM = CONFIG['MOZ_APP_NAME'] + "-bin"
     else:
         PROGRAM = CONFIG['MOZ_APP_NAME']
-    if CONFIG['MOZ_B2G_LOADER']:
-        SOURCES += [
-            'B2GLoader.cpp',
-        ]
-
     SOURCES += [
         'nsBrowserApp.cpp',
     ]
     if CONFIG['_MSC_VER']:
         # Always enter a Windows program through wmain, whether or not we're
         # a console application.
         WIN32_EXE_LDFLAGS += ['-ENTRY:wmainCRTStartup']
 
--- a/b2g/app/nsBrowserApp.cpp
+++ b/b2g/app/nsBrowserApp.cpp
@@ -12,17 +12,16 @@
 #elif defined(XP_UNIX)
 #include <sys/time.h>
 #include <sys/resource.h>
 #include <unistd.h>
 #endif
 
 #include <stdio.h>
 #include <stdarg.h>
-#include <string.h>
 
 #include "nsCOMPtr.h"
 #include "nsIFile.h"
 #include "nsStringGlue.h"
 
 #ifdef XP_WIN
 // we want a wmain entry point
 #include "nsWindowsWMain.cpp"
@@ -159,55 +158,39 @@ static int do_main(int argc, char* argv[
     int result = XRE_main(argc, argv, appData, 0);
     XRE_FreeAppData(appData);
     return result;
   }
 
   return XRE_main(argc, argv, &sAppData, 0);
 }
 
-#ifdef MOZ_B2G_LOADER
-/*
- * The main() in B2GLoader.cpp is the new main function instead of the
- * main() here if it is enabled.  So, rename it to b2g_man().
- */
-#define main b2g_main
-#define _CONST const
-#else
-#define _CONST
-#endif
-
-int main(int argc, _CONST char* argv[])
+int main(int argc, char* argv[])
 {
-#ifndef MOZ_B2G_LOADER
   char exePath[MAXPATHLEN];
-#endif
 
 #ifdef MOZ_WIDGET_GONK
   // This creates a ThreadPool for binder ipc. A ThreadPool is necessary to
   // receive binder calls, though not necessary to send binder calls.
   // ProcessState::Self() also needs to be called once on the main thread to
   // register the main thread with the binder driver.
   android::ProcessState::self()->startThreadPool();
 #endif
 
-  nsresult rv;
-#ifndef MOZ_B2G_LOADER
-  rv = mozilla::BinaryPath::Get(argv[0], exePath);
+  nsresult rv = mozilla::BinaryPath::Get(argv[0], exePath);
   if (NS_FAILED(rv)) {
     Output("Couldn't calculate the application directory.\n");
     return 255;
   }
 
   char *lastSlash = strrchr(exePath, XPCOM_FILE_PATH_SEPARATOR[0]);
   if (!lastSlash || ((lastSlash - exePath) + sizeof(XPCOM_DLL) + 1 > MAXPATHLEN))
     return 255;
 
   strcpy(++lastSlash, XPCOM_DLL);
-#endif // MOZ_B2G_LOADER
 
 #if defined(XP_UNIX)
   // If the b2g app is launched from adb shell, then the shell will wind
   // up being the process group controller. This means that we can't send
   // signals to the process group (useful for profiling).
   // We ignore the return value since setsid() fails if we're already the
   // process group controller (the normal situation).
   (void)setsid();
@@ -221,30 +204,26 @@ int main(int argc, _CONST char* argv[])
   IO_COUNTERS ioCounters;
   gotCounters = GetProcessIoCounters(GetCurrentProcess(), &ioCounters);
 #endif
 
 #ifdef HAS_DLL_BLOCKLIST
   DllBlocklist_Initialize();
 #endif
 
-  // B2G loader has already initialized Gecko so we can't initialize
-  // it again here.
-#ifndef MOZ_B2G_LOADER
   // We do this because of data in bug 771745
   XPCOMGlueEnablePreload();
 
   rv = XPCOMGlueStartup(exePath);
   if (NS_FAILED(rv)) {
     Output("Couldn't load XPCOM.\n");
     return 255;
   }
   // Reset exePath so that it is the directory name and not the xpcom dll name
   *lastSlash = 0;
-#endif // MOZ_B2G_LOADER
 
   rv = XPCOMGlueLoadXULFunctions(kXULFuncs);
   if (NS_FAILED(rv)) {
     Output("Couldn't load XRE functions.\n");
     return 255;
   }
 
   if (gotCounters) {
@@ -269,31 +248,13 @@ int main(int argc, _CONST char* argv[])
                               int(newRUsage.ru_majflt - initialRUsage.ru_majflt));
     }
 #endif
   }
 
   int result;
   {
     ScopedLogging log;
-    char **_argv;
-
-    /*
-     * Duplicate argument vector to conform non-const argv of
-     * do_main() since XRE_main() is very stupid with non-const argv.
-     */
-    _argv = new char *[argc + 1];
-    for (int i = 0; i < argc; i++) {
-      _argv[i] = strdup(argv[i]);
-      MOZ_ASSERT(_argv[i] != nullptr);
-    }
-    _argv[argc] = nullptr;
-
-    result = do_main(argc, _argv);
-
-    for (int i = 0; i < argc; i++) {
-      free(_argv[i]);
-    }
-    delete[] _argv;
+    result = do_main(argc, argv);
   }
 
   return result;
 }
--- a/b2g/confvars.sh
+++ b/b2g/confvars.sh
@@ -54,17 +54,16 @@ MOZ_TIME_MANAGER=1
 
 MOZ_PAY=1
 MOZ_TOOLKIT_SEARCH=
 MOZ_PLACES=
 MOZ_B2G=1
 
 if test "$OS_TARGET" = "Android"; then
 MOZ_NUWA_PROCESS=1
-MOZ_B2G_LOADER=1
 fi
 MOZ_FOLD_LIBS=1
 
 MOZ_JSDOWNLOADS=1
 
 MOZ_BUNDLED_FONTS=1
 
 # Enable exact rooting on b2g.
--- a/configure.in
+++ b/configure.in
@@ -8626,24 +8626,16 @@ AC_SUBST(MOZ_BZ2_LIBS)
 AC_SUBST(MOZ_PNG_CFLAGS)
 AC_SUBST(MOZ_PNG_LIBS)
 
 if test "$MOZ_WIDGET_TOOLKIT" = gonk -a -n "$MOZ_NUWA_PROCESS"; then
     export MOZ_NUWA_PROCESS
     AC_DEFINE(MOZ_NUWA_PROCESS)
 fi
 AC_SUBST(MOZ_NUWA_PROCESS)
-if test "$MOZ_WIDGET_TOOLKIT" = gonk -a -n "$MOZ_B2G_LOADER"; then
-    if test -z "$MOZ_NUWA_PROCESS"; then
-       AC_MSG_ERROR([B2G loader works with Nuwa]);
-    fi
-    export MOZ_B2G_LOADER
-    AC_DEFINE(MOZ_B2G_LOADER)
-fi
-AC_SUBST(MOZ_B2G_LOADER)
 
 AC_SUBST(NSPR_CFLAGS)
 AC_SUBST(NSPR_LIBS)
 AC_SUBST(MOZ_NATIVE_NSPR)
 
 AC_SUBST(NSS_CFLAGS)
 AC_SUBST(NSS_LIBS)
 AC_SUBST(MOZ_NATIVE_NSS)
--- a/ipc/app/Makefile.in
+++ b/ipc/app/Makefile.in
@@ -32,20 +32,16 @@ endif
 # This switches $(INSTALL) to copy mode, like $(SYSINSTALL), so things that
 # shouldn't get 755 perms need $(IFLAGS1) for either way of calling nsinstall.
 NSDISTMODE = copy
 
 include $(topsrcdir)/config/config.mk
 
 include $(topsrcdir)/config/rules.mk
 
-ifneq ($(MOZ_WIDGET_TOOLKIT),android)
-#LIBS += ../contentproc/$(LIB_PREFIX)plugin-container.$(LIB_SUFFIX)
-endif
-
 ifeq ($(OS_ARCH),WINNT) #{
 # Note the manifest file exists in the tree, so we use the explicit filename
 # here.
 EXTRA_DEPS += plugin-container.exe.manifest
 endif #}
 
 ifeq (cocoa,$(MOZ_WIDGET_TOOLKIT)) #{
 
--- a/ipc/app/MozillaRuntimeMain.cpp
+++ b/ipc/app/MozillaRuntimeMain.cpp
@@ -1,12 +1,151 @@
 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
  * vim: sw=4 ts=4 et :
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-#include "../contentproc/plugin-container.cpp"
- 
+#include "nsXPCOM.h"
+#include "nsXULAppAPI.h"
+
+// FIXME/cjones testing
+#if !defined(OS_WIN)
+#include <unistd.h>
+#endif
+
+#ifdef XP_WIN
+#include <windows.h>
+// we want a wmain entry point
+// but we don't want its DLL load protection, because we'll handle it here
+#define XRE_DONT_PROTECT_DLL_LOAD
+#include "nsWindowsWMain.cpp"
+#include "nsSetDllDirectory.h"
+#endif
+
+#if defined(XP_WIN)
+#include "sandbox/chromium/base/basictypes.h"
+#include "sandbox/win/src/sandbox.h"
+#include "sandbox/win/src/sandbox_factory.h"
+#include "mozilla/sandboxTarget.h"
+#endif
+
+#ifdef MOZ_WIDGET_GONK
+# include <sys/time.h>
+# include <sys/resource.h> 
+
+# include <binder/ProcessState.h>
+
+# ifdef LOGE_IF
+#  undef LOGE_IF
+# endif
+
+# include <android/log.h>
+# define LOGE_IF(cond, ...) \
+     ( (CONDITION(cond)) \
+     ? ((void)__android_log_print(ANDROID_LOG_ERROR, \
+       "Gecko:MozillaRntimeMain", __VA_ARGS__)) \
+     : (void)0 )
+
+#endif
+
+#ifdef MOZ_NUWA_PROCESS
+#include <binder/ProcessState.h>
+#include "ipc/Nuwa.h"
+#endif
+
+#ifdef MOZ_WIDGET_GONK
+static void
+InitializeBinder(void *aDummy) {
+    // Change thread priority to 0 only during calling ProcessState::self().
+    // The priority is registered to binder driver and used for default Binder
+    // Thread's priority. 
+    // To change the process's priority to small value need's root permission.
+    int curPrio = getpriority(PRIO_PROCESS, 0);
+    int err = setpriority(PRIO_PROCESS, 0, 0);
+    MOZ_ASSERT(!err);
+    LOGE_IF(err, "setpriority failed. Current process needs root permission.");
+    android::ProcessState::self()->startThreadPool();
+    setpriority(PRIO_PROCESS, 0, curPrio);
+}
+#endif
+
+#if defined(XP_WIN)
+static bool gIsSandboxEnabled = false;
+void StartSandboxCallback()
+{
+    if (gIsSandboxEnabled) {
+        sandbox::TargetServices* target_service =
+            sandbox::SandboxFactory::GetTargetServices();
+        target_service->LowerToken();
+    }
+}
+#endif
+
 int
-main(int argc, char *argv[]) {
-    return content_process_main(argc, argv);
+main(int argc, char* argv[])
+{
+    bool isNuwa = false;
+    for (int i = 1; i < argc; i++) {
+        isNuwa |= strcmp(argv[i], "-nuwa") == 0;
+#if defined(XP_WIN)
+        gIsSandboxEnabled |= strcmp(argv[i], "-sandbox") == 0;
+#endif
+    }
+
+#ifdef MOZ_NUWA_PROCESS
+    if (isNuwa) {
+        PrepareNuwaProcess();
+    }
+#endif
+
+#ifdef MOZ_WIDGET_GONK
+    // This creates a ThreadPool for binder ipc. A ThreadPool is necessary to
+    // receive binder calls, though not necessary to send binder calls.
+    // ProcessState::Self() also needs to be called once on the main thread to
+    // register the main thread with the binder driver.
+
+#ifdef MOZ_NUWA_PROCESS
+    if (!isNuwa) {
+        InitializeBinder(nullptr);
+    } else {
+        NuwaAddFinalConstructor(&InitializeBinder, nullptr);
+    }
+#else
+    InitializeBinder(nullptr);
+#endif
+#endif
+
+    // Check for the absolute minimum number of args we need to move
+    // forward here. We expect the last arg to be the child process type.
+    if (argc < 1)
+      return 3;
+    GeckoProcessType proctype = XRE_StringToChildProcessType(argv[--argc]);
+
+#ifdef XP_WIN
+    // For plugins, this is done in PluginProcessChild::Init, as we need to
+    // avoid it for unsupported plugins.  See PluginProcessChild::Init for
+    // the details.
+    if (proctype != GeckoProcessType_Plugin) {
+        mozilla::SanitizeEnvironmentVariables();
+        SetDllDirectory(L"");
+    }
+
+    if (gIsSandboxEnabled) {
+        sandbox::TargetServices* target_service =
+            sandbox::SandboxFactory::GetTargetServices();
+        if (!target_service) {
+            return 1;
+        }
+
+        sandbox::ResultCode result = target_service->Init();
+        if (result != sandbox::SBOX_ALL_OK) {
+           return 2;
+        }
+        mozilla::SandboxTarget::Instance()->SetStartSandboxCallback(StartSandboxCallback);
+    }
+#endif
+
+    nsresult rv = XRE_InitChildProcess(argc, argv, proctype);
+    NS_ENSURE_SUCCESS(rv, 1);
+
+    return 0;
 }
--- a/ipc/chromium/src/base/process_util_linux.cc
+++ b/ipc/chromium/src/base/process_util_linux.cc
@@ -1,10 +1,8 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* vim: set sw=2 ts=2 autoindent cindent expandtab: */
 // Copyright (c) 2008 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/process_util.h"
 
 #include <ctype.h>
 #include <fcntl.h>
@@ -15,23 +13,16 @@
 #include <sys/wait.h>
 
 #include "base/debug_util.h"
 #include "base/eintr_wrapper.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/string_tokenizer.h"
 #include "base/string_util.h"
-#include "nsLiteralString.h"
-
-#ifdef MOZ_B2G_LOADER
-#include "ProcessUtils.h"
-
-using namespace mozilla::ipc;
-#endif	// MOZ_B2G_LOADER
 
 #ifdef MOZ_WIDGET_GONK
 /*
  * AID_APP is the first application UID used by Android. We're using
  * it as our unprivilegied UID.  This ensure the UID used is not
  * shared with any other processes than our own childs.
  */
 # include <private/android_filesystem_config.h>
@@ -192,81 +183,22 @@ bool LaunchApp(const std::vector<std::st
                const environment_map& env_vars_to_set,
                bool wait, ProcessHandle* process_handle,
                ProcessArchitecture arch) {
   return LaunchApp(argv, fds_to_remap, env_vars_to_set,
                    PRIVILEGES_INHERIT,
                    wait, process_handle);
 }
 
-#ifdef MOZ_B2G_LOADER
-/**
- * Launch an app using B2g Loader.
- */
-static bool
-LaunchAppProcLoader(const std::vector<std::string>& argv,
-                    const file_handle_mapping_vector& fds_to_remap,
-                    const environment_map& env_vars_to_set,
-                    ChildPrivileges privs,
-                    ProcessHandle* process_handle) {
-  size_t i;
-  scoped_array<char*> argv_cstr(new char*[argv.size() + 1]);
-  for (i = 0; i < argv.size(); i++) {
-    argv_cstr[i] = const_cast<char*>(argv[i].c_str());
-  }
-  argv_cstr[argv.size()] = nullptr;
-
-  scoped_array<char*> env_cstr(new char*[env_vars_to_set.size() + 1]);
-  i = 0;
-  for (environment_map::const_iterator it = env_vars_to_set.begin();
-       it != env_vars_to_set.end(); ++it) {
-    env_cstr[i++] = strdup((it->first + "=" + it->second).c_str());
-  }
-  env_cstr[env_vars_to_set.size()] = nullptr;
-
-  bool ok = ProcLoaderLoad((const char **)argv_cstr.get(),
-                           (const char **)env_cstr.get(),
-                           fds_to_remap, privs,
-                           process_handle);
-  MOZ_ASSERT(ok, "ProcLoaderLoad() failed");
-
-  for (size_t i = 0; i < env_vars_to_set.size(); i++) {
-    free(env_cstr[i]);
-  }
-
-  return ok;
-}
-
-static bool
-IsLaunchingNuwa(const std::vector<std::string>& argv) {
-  std::vector<std::string>::const_iterator it;
-  for (it = argv.begin(); it != argv.end(); ++it) {
-    if (*it == std::string("-nuwa")) {
-      return true;
-    }
-  }
-  return false;
-}
-#endif // MOZ_B2G_LOADER
-
 bool LaunchApp(const std::vector<std::string>& argv,
                const file_handle_mapping_vector& fds_to_remap,
                const environment_map& env_vars_to_set,
                ChildPrivileges privs,
                bool wait, ProcessHandle* process_handle,
                ProcessArchitecture arch) {
-#ifdef MOZ_B2G_LOADER
-  static bool beforeFirstNuwaLaunch = true;
-  if (!wait && beforeFirstNuwaLaunch && IsLaunchingNuwa(argv)) {
-    beforeFirstNuwaLaunch = false;
-    return LaunchAppProcLoader(argv, fds_to_remap, env_vars_to_set,
-                               privs, process_handle);
-  }
-#endif // MOZ_B2G_LOADER
-
   scoped_array<char*> argv_cstr(new char*[argv.size() + 1]);
   // Illegal to allocate memory after fork and before execvp
   InjectiveMultimap fd_shuffle1, fd_shuffle2;
   fd_shuffle1.reserve(fds_to_remap.size());
   fd_shuffle2.reserve(fds_to_remap.size());
 
 #ifdef HAVE_PR_DUPLICATE_ENVIRONMENT
   Environment env;
deleted file mode 100644
--- a/ipc/contentproc/moz.build
+++ /dev/null
@@ -1,29 +0,0 @@
-# -*- Mode: python; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 40 -*-
-# vim: set filetype=python:
-# This Source Code Form is subject to the terms of the Mozilla Public
-# License, v. 2.0. If a copy of the MPL was not distributed with this
-# file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-LIBRARY_NAME = 'plugin-container'
-if CONFIG['MOZ_B2G_LOADER']:
-    FINAL_LIBRARY = 'xul'
-
-SOURCES += [
-    'plugin-container.cpp',
-]
-
-include('/ipc/chromium/chromium-config.mozbuild')
-
-if CONFIG['OS_ARCH'] == 'WINNT':
-    LOCAL_INCLUDES += [
-        '/toolkit/xre',
-        '/xpcom/base',
-    ]
-
-if CONFIG['OS_ARCH'] == 'WINNT':
-    # For sandbox includes and the include dependencies those have
-    LOCAL_INCLUDES += [
-        '/security',
-        '/security/sandbox',
-        '/security/sandbox/chromium',
-    ]
deleted file mode 100644
--- a/ipc/contentproc/plugin-container.cpp
+++ /dev/null
@@ -1,151 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- * vim: sw=4 ts=4 et :
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-#include "nsXPCOM.h"
-#include "nsXULAppAPI.h"
-
-// FIXME/cjones testing
-#if !defined(OS_WIN)
-#include <unistd.h>
-#endif
-
-#ifdef XP_WIN
-#include <windows.h>
-// we want a wmain entry point
-// but we don't want its DLL load protection, because we'll handle it here
-#define XRE_DONT_PROTECT_DLL_LOAD
-#include "nsWindowsWMain.cpp"
-#include "nsSetDllDirectory.h"
-#endif
-
-#if defined(XP_WIN)
-#include "sandbox/chromium/base/basictypes.h"
-#include "sandbox/win/src/sandbox.h"
-#include "sandbox/win/src/sandbox_factory.h"
-#include "mozilla/sandboxTarget.h"
-#endif
-
-#ifdef MOZ_WIDGET_GONK
-# include <sys/time.h>
-# include <sys/resource.h> 
-
-# include <binder/ProcessState.h>
-
-# ifdef LOGE_IF
-#  undef LOGE_IF
-# endif
-
-# include <android/log.h>
-# define LOGE_IF(cond, ...) \
-     ( (CONDITION(cond)) \
-     ? ((void)__android_log_print(ANDROID_LOG_ERROR, \
-       "Gecko:MozillaRntimeMain", __VA_ARGS__)) \
-     : (void)0 )
-
-#endif
-
-#ifdef MOZ_NUWA_PROCESS
-#include <binder/ProcessState.h>
-#include "ipc/Nuwa.h"
-#endif
-
-#ifdef MOZ_WIDGET_GONK
-static void
-InitializeBinder(void *aDummy) {
-    // Change thread priority to 0 only during calling ProcessState::self().
-    // The priority is registered to binder driver and used for default Binder
-    // Thread's priority. 
-    // To change the process's priority to small value need's root permission.
-    int curPrio = getpriority(PRIO_PROCESS, 0);
-    int err = setpriority(PRIO_PROCESS, 0, 0);
-    MOZ_ASSERT(!err);
-    LOGE_IF(err, "setpriority failed. Current process needs root permission.");
-    android::ProcessState::self()->startThreadPool();
-    setpriority(PRIO_PROCESS, 0, curPrio);
-}
-#endif
-
-#if defined(XP_WIN)
-static bool gIsSandboxEnabled = false;
-void StartSandboxCallback()
-{
-    if (gIsSandboxEnabled) {
-        sandbox::TargetServices* target_service =
-            sandbox::SandboxFactory::GetTargetServices();
-        target_service->LowerToken();
-    }
-}
-#endif
-
-int
-content_process_main(int argc, char* argv[])
-{
-    bool isNuwa = false;
-    for (int i = 1; i < argc; i++) {
-        isNuwa |= strcmp(argv[i], "-nuwa") == 0;
-#if defined(XP_WIN)
-        gIsSandboxEnabled |= strcmp(argv[i], "-sandbox") == 0;
-#endif
-    }
-
-#ifdef MOZ_NUWA_PROCESS
-    if (isNuwa) {
-        PrepareNuwaProcess();
-    }
-#endif
-
-#ifdef MOZ_WIDGET_GONK
-    // This creates a ThreadPool for binder ipc. A ThreadPool is necessary to
-    // receive binder calls, though not necessary to send binder calls.
-    // ProcessState::Self() also needs to be called once on the main thread to
-    // register the main thread with the binder driver.
-
-#ifdef MOZ_NUWA_PROCESS
-    if (!isNuwa) {
-        InitializeBinder(nullptr);
-    } else {
-        NuwaAddFinalConstructor(&InitializeBinder, nullptr);
-    }
-#else
-    InitializeBinder(nullptr);
-#endif
-#endif
-
-    // Check for the absolute minimum number of args we need to move
-    // forward here. We expect the last arg to be the child process type.
-    if (argc < 1)
-      return 3;
-    GeckoProcessType proctype = XRE_StringToChildProcessType(argv[--argc]);
-
-#ifdef XP_WIN
-    // For plugins, this is done in PluginProcessChild::Init, as we need to
-    // avoid it for unsupported plugins.  See PluginProcessChild::Init for
-    // the details.
-    if (proctype != GeckoProcessType_Plugin) {
-        mozilla::SanitizeEnvironmentVariables();
-        SetDllDirectory(L"");
-    }
-
-    if (gIsSandboxEnabled) {
-        sandbox::TargetServices* target_service =
-            sandbox::SandboxFactory::GetTargetServices();
-        if (!target_service) {
-            return 1;
-        }
-
-        sandbox::ResultCode result = target_service->Init();
-        if (result != sandbox::SBOX_ALL_OK) {
-           return 2;
-        }
-        mozilla::SandboxTarget::Instance()->SetStartSandboxCallback(StartSandboxCallback);
-    }
-#endif
-
-    nsresult rv = XRE_InitChildProcess(argc, argv, proctype);
-    NS_ENSURE_SUCCESS(rv, 1);
-
-    return 0;
-}
deleted file mode 100644
--- a/ipc/glue/PProcLoader.ipdl
+++ /dev/null
@@ -1,35 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* vim: set sw=2 ts=2 autoindent cindent expandtab: */
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this file,
- * You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-namespace mozilla {
-namespace ipc {
-
-struct FDRemap {
-  FileDescriptor fd;
-  int mapto;
-};
-
-protocol PProcLoader
-{
-child:
-  /**
-   * Request B2G loader service to load content process.
-   *
-   * It actually calls the main() function of plugin-container.
-   */
-  async Load(nsCString[] argv, nsCString[] env,
-             FDRemap[] fdsRemap, uint32_t privs,
-             int32_t cookie);
-
-parent:
-  /**
-   * The acknowledgement of Load().
-   */
-  async LoadComplete(int32_t pid, int32_t cookie);
-};
-
-}
-}
--- a/ipc/glue/ProcessUtils.h
+++ b/ipc/glue/ProcessUtils.h
@@ -1,36 +1,19 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* vim: set sw=2 ts=2 autoindent cindent expandtab: */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef mozilla_ipc_ProcessUtils_h
 #define mozilla_ipc_ProcessUtils_h
 
-#ifdef MOZ_B2G_LOADER
-#include "base/process_util.h"
-#endif
-
 namespace mozilla {
 namespace ipc {
 
 // You probably should call ContentChild::SetProcessName instead of calling
 // this directly.
 void SetThisProcessName(const char *aName);
 
-#ifdef MOZ_B2G_LOADER
-// see ProcessUtils_linux.cpp for explaination.
-void ProcLoaderClientGeckoInit();
-
-bool ProcLoaderLoad(const char *aArgv[],
-                    const char *aEnvp[],
-                    const base::file_handle_mapping_vector &aFdsRemap,
-                    const base::ChildPrivileges aPrivs,
-                    base::ProcessHandle *aProcessHandle);
-#endif /* MOZ_B2G_LOADER */
-
 } // namespace ipc
 } // namespace mozilla
 
 #endif // ifndef mozilla_ipc_ProcessUtils_h
 
--- a/ipc/glue/ProcessUtils_linux.cpp
+++ b/ipc/glue/ProcessUtils_linux.cpp
@@ -1,570 +1,20 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* vim: set sw=2 ts=2 autoindent cindent expandtab: */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "ProcessUtils.h"
 
 #include "nsString.h"
 
 #include <sys/prctl.h>
 
-#ifdef MOZ_B2G_LOADER
-
-#include <sys/types.h>
-#include <unistd.h>
-
-#include "nsAutoPtr.h"
-
-#include "mozilla/Assertions.h"
-#include "mozilla/ipc/PProcLoaderParent.h"
-#include "mozilla/ipc/PProcLoaderChild.h"
-#include "mozilla/ipc/Transport.h"
-#include "mozilla/ipc/FileDescriptorUtils.h"
-#include "mozilla/ipc/IOThreadChild.h"
-#include "mozilla/dom/ContentProcess.h"
-#include "base/file_descriptor_shuffle.h"
-#include "mozilla/BackgroundHangMonitor.h"
-#include "mozilla/DebugOnly.h"
-#include "base/process_util.h"
-
-#include "prenv.h"
-
-#include "nsXULAppAPI.h" // export XRE_* functions
-
-#include "nsAppRunner.h"
-
-int content_process_main(int argc, char *argv[]);
-
-extern bool gDisableAndroidLog;
-
-#endif /* MOZ_B2G_LOADER */
-
 namespace mozilla {
 namespace ipc {
 
 void SetThisProcessName(const char *aName)
 {
   prctl(PR_SET_NAME, (unsigned long)aName, 0uL, 0uL, 0uL);
 }
 
-#ifdef MOZ_B2G_LOADER
-/**
- * How does B2G Loader Work?
- *
- *  <<parent process>>      <<child process>>
- *   ProcLoaderParent -----> ProcLoaderChild
- *         ^                       |
- *         | load()                | content_process_main()
- *         |                       V
- *     ProcLoaderClient      Nuwa/plugin-container
- *         ^
- *         | ProcLoaderLoad()
- *        ...
- *     ContentParent
- *
- *
- * B2G loader includes an IPC protocol PProcLoader for communication
- * between client (parent) and server (child).  The b2g process is the
- * client.  It requests the server to load/start the Nuwa process with
- * the given arguments, env variables, and file descriptors.
- *
- * ProcLoaderClientInit() is called by B2G loader to initialize the
- * client side, the b2g process.  Then the b2g_main() is called to
- * start b2g process.
- *
- * ProcLoaderClientGeckoInit() is called by XRE_main() to create the
- * parent actor, |ProcLoaderParent|, of PProcLoader for servicing the
- * request to run Nuwa process later once Gecko has been initialized.
- *
- * ProcLoaderServiceRun() is called by the server process.  It starts
- * an IOThread and event loop to serve the |ProcLoaderChild|
- * implmentation of PProcLoader protocol as the child actor.  Once it
- * recieves a load() request, it stops the IOThread and event loop,
- * then starts running the main function of the content process with
- * the given arguments.
- *
- * NOTE: The server process serves at most one load() request.
- */
-
-using namespace base;
-using namespace mozilla::dom;
-
-static bool sProcLoaderClientOnDeinit = false;
-static DebugOnly<bool> sProcLoaderClientInitialized = false;
-static DebugOnly<bool> sProcLoaderClientGeckoInitialized = false;
-static pid_t sProcLoaderPid = 0;
-static int sProcLoaderChannelFd = -1;
-static PProcLoaderParent *sProcLoaderParent = nullptr;
-static MessageLoop *sProcLoaderLoop = nullptr;
-
-static void ProcLoaderClientDeinit();
-
-
-class ProcLoaderParent : public PProcLoaderParent
-{
-private:
-  nsAutoPtr<FileDescriptor> mChannelFd; // To keep a reference.
-
-public:
-  ProcLoaderParent(FileDescriptor *aFd) : mChannelFd(aFd) {}
-
-  virtual void ActorDestroy(ActorDestroyReason aWhy) MOZ_OVERRIDE;
-
-  virtual bool RecvLoadComplete(const int32_t &aPid,
-                                const int32_t &aCookie) MOZ_OVERRIDE;
-
-  virtual void OnChannelError() MOZ_OVERRIDE;
-};
-
-void
-ProcLoaderParent::ActorDestroy(ActorDestroyReason aWhy)
-{
-}
-
-static void
-_ProcLoaderParentDestroy(PProcLoaderParent *aLoader)
-{
-  aLoader->Close();
-  delete aLoader;
-  sProcLoaderClientOnDeinit = false;
-}
-
-bool
-ProcLoaderParent::RecvLoadComplete(const int32_t &aPid,
-                                   const int32_t &aCookie)
-{
-  ProcLoaderClientDeinit();
-  return true;
-}
-
-void
-ProcLoaderParent::OnChannelError()
-{
-  if (sProcLoaderClientOnDeinit) {
-    // Get error for closing while the channel is already error.
-    return;
-  }
-  NS_WARNING("ProcLoaderParent is in channel error");
-  ProcLoaderClientDeinit();
-}
-
-/**
- * Initialize the client of B2G loader for loader itself.
- *
- * The initialization of B2G loader are divided into two stages. First
- * stage is to collect child info passed from the main program of the
- * loader.  Second stage is to initialize Gecko according to info from the
- * first stage and make the client of loader service ready.
- *
- * \param aPeerPid is the pid of the child.
- * \param aChannelFd is the file descriptor of the socket used for IPC.
- */
-static void
-ProcLoaderClientInit(pid_t aPeerPid, int aChannelFd)
-{
-  MOZ_ASSERT(!sProcLoaderClientInitialized, "call ProcLoaderClientInit() more than once");
-  MOZ_ASSERT(aPeerPid != 0 && aChannelFd != -1, "invalid argument");
-  sProcLoaderPid = aPeerPid;
-  sProcLoaderChannelFd = aChannelFd;
-  sProcLoaderClientInitialized = true;
-}
-
-/**
- * Initialize the client of B2G loader for Gecko.
- */
-void
-ProcLoaderClientGeckoInit()
-{
-  MOZ_ASSERT(sProcLoaderClientInitialized, "call ProcLoaderClientInit() at first");
-  MOZ_ASSERT(!sProcLoaderClientGeckoInitialized,
-             "call ProcLoaderClientGeckoInit() more than once");
-
-  sProcLoaderClientGeckoInitialized = true;
-
-  FileDescriptor *fd = new FileDescriptor(sProcLoaderChannelFd);
-  close(sProcLoaderChannelFd);
-  sProcLoaderChannelFd = -1;
-  Transport *transport = OpenDescriptor(*fd, Transport::MODE_CLIENT);
-  sProcLoaderParent = new ProcLoaderParent(fd);
-  sProcLoaderParent->Open(transport,
-                          sProcLoaderPid,
-                          XRE_GetIOMessageLoop(),
-                          ParentSide);
-  sProcLoaderLoop = MessageLoop::current();
-}
-
-/**
- * Shutdown and destroy the client of B2G loader service.
- */
-static void
-ProcLoaderClientDeinit()
-{
-  MOZ_ASSERT(sProcLoaderClientGeckoInitialized && sProcLoaderClientInitialized);
-  sProcLoaderClientGeckoInitialized = false;
-  sProcLoaderClientInitialized = false;
-
-  sProcLoaderClientOnDeinit = true;
-
-  MOZ_ASSERT(sProcLoaderParent != nullptr);
-  PProcLoaderParent *procLoaderParent = sProcLoaderParent;
-  sProcLoaderParent = nullptr;
-  sProcLoaderLoop = nullptr;
-
-  MessageLoop::current()->
-    PostTask(FROM_HERE,
-             NewRunnableFunction(&_ProcLoaderParentDestroy,
-                                 procLoaderParent));
-}
-
-struct AsyncSendLoadData
-{
-  nsTArray<nsCString> mArgv;
-  nsTArray<nsCString> mEnv;
-  nsTArray<FDRemap> mFdsremap;
-  ChildPrivileges mPrivs;
-  int mCookie;
-};
-
-static void
-AsyncSendLoad(AsyncSendLoadData *aLoad)
-{
-  PProcLoaderParent *loader = sProcLoaderParent;
-  DebugOnly<bool> ok =
-    loader->SendLoad(aLoad->mArgv, aLoad->mEnv, aLoad->mFdsremap,
-                     aLoad->mPrivs, aLoad->mCookie);
-  MOZ_ASSERT(ok);
-  delete aLoad;
-}
-
-/**
- * Request the loader service, the server, to load Nuwa.
- */
-bool
-ProcLoaderLoad(const char *aArgv[],
-               const char *aEnvp[],
-               const file_handle_mapping_vector &aFdsRemap,
-               const ChildPrivileges aPrivs,
-               ProcessHandle *aProcessHandle)
-{
-  static int cookie=0;
-  int i;
-
-  if (sProcLoaderParent == nullptr || sProcLoaderPid == 0) {
-    return false;
-  }
-
-  AsyncSendLoadData *load = new AsyncSendLoadData();
-  nsTArray<nsCString> &argv = load->mArgv;
-  for (i = 0; aArgv[i] != nullptr; i++) {
-    argv.AppendElement(nsCString(aArgv[i]));
-  }
-  nsTArray<nsCString> &env = load->mEnv;
-  for (i = 0; aEnvp[i] != nullptr; i++) {
-    env.AppendElement(nsCString(aEnvp[i]));
-  }
-  nsTArray<FDRemap> &fdsremap = load->mFdsremap;
-  for (file_handle_mapping_vector::const_iterator fdmap =
-         aFdsRemap.begin();
-       fdmap != aFdsRemap.end();
-       fdmap++) {
-    fdsremap.AppendElement(FDRemap(fdmap->first, fdmap->second));
-  }
-  load->mPrivs = aPrivs;
-  load->mCookie = cookie++;
-
-  *aProcessHandle = sProcLoaderPid;
-  sProcLoaderPid = 0;
-
-  sProcLoaderLoop->PostTask(FROM_HERE,
-                            NewRunnableFunction(AsyncSendLoad, load));
-  return true;
-}
-
-
-class ProcLoaderRunnerBase;
-
-static bool sProcLoaderServing = false;
-static ProcLoaderRunnerBase *sProcLoaderDispatchedTask = nullptr;
-
-class ProcLoaderRunnerBase
-{
-public:
-  virtual int DoWork() = 0;
-};
-
-
-class ProcLoaderNoopRunner : public ProcLoaderRunnerBase {
-public:
-  virtual int DoWork();
-};
-
-int
-ProcLoaderNoopRunner::DoWork() {
-  return 0;
-}
-
-
-/**
- * The runner to load Nuwa at the current process.
- */
-class ProcLoaderLoadRunner : public ProcLoaderRunnerBase {
-private:
-  const nsTArray<nsCString> mArgv;
-  const nsTArray<nsCString> mEnv;
-  const nsTArray<FDRemap> mFdsRemap;
-  const ChildPrivileges mPrivs;
-
-  void ShuffleFds();
-
-public:
-  ProcLoaderLoadRunner(const InfallibleTArray<nsCString>& aArgv,
-                       const InfallibleTArray<nsCString>& aEnv,
-                       const InfallibleTArray<FDRemap>& aFdsRemap,
-                       const ChildPrivileges aPrivs)
-    : mArgv(aArgv)
-    , mEnv(aEnv)
-    , mFdsRemap(aFdsRemap)
-    , mPrivs(aPrivs) {}
-
-  int DoWork();
-};
-
-void
-ProcLoaderLoadRunner::ShuffleFds()
-{
-  unsigned int i;
-
-  InjectiveMultimap fd_shuffle1, fd_shuffle2;
-  fd_shuffle1.reserve(mFdsRemap.Length());
-  fd_shuffle2.reserve(mFdsRemap.Length());
-  for (i = 0; i < mFdsRemap.Length(); i++) {
-    const FDRemap *map = &mFdsRemap[i];
-    int fd = map->fd().PlatformHandle();
-    int tofd = map->mapto();
-
-    fd_shuffle1.push_back(InjectionArc(fd, tofd, false));
-    fd_shuffle2.push_back(InjectionArc(fd, tofd, false));
-  }
-
-  DebugOnly<bool> ok = ShuffleFileDescriptors(&fd_shuffle1);
-  MOZ_ASSERT(ok, "ShuffleFileDescriptors failed");
-
-  CloseSuperfluousFds(fd_shuffle2);
-}
-
-int
-ProcLoaderLoadRunner::DoWork()
-{
-  unsigned int i;
-
-  ShuffleFds();
-
-  unsigned int argc = mArgv.Length();
-  char **argv = new char *[argc + 1];
-  for (i = 0; i < argc; i++) {
-    argv[i] = ::strdup(mArgv[i].get());
-  }
-  argv[argc] = nullptr;
-
-  unsigned int envc = mEnv.Length();
-  for (i = 0; i < envc; i++) {
-    PR_SetEnv(mEnv[i].get());
-  }
-
-  SetCurrentProcessPrivileges(mPrivs);
-
-  MOZ_ASSERT(content_process_main != nullptr,
-             "content_process_main not found");
-  // Start Nuwa (main function)
-  int ret = content_process_main(argc, argv);
-
-  for (i = 0; i < argc; i++) {
-    free(argv[i]);
-  }
-  delete[] argv;
-
-  return ret;
-}
-
-
-class ProcLoaderChild : public PProcLoaderChild
-{
-  pid_t mPeerPid;
-
-public:
-  ProcLoaderChild(pid_t aPeerPid) : mPeerPid(aPeerPid) {}
-
-  virtual void ActorDestroy(ActorDestroyReason aWhy) MOZ_OVERRIDE;
-
-  virtual bool RecvLoad(const InfallibleTArray<nsCString>& aArgv,
-                        const InfallibleTArray<nsCString>& aEnv,
-                        const InfallibleTArray<FDRemap>& aFdsremap,
-                        const uint32_t& aPrivs,
-                        const int32_t& aCookie);
-
-  virtual void OnChannelError();
-};
-
-void
-ProcLoaderChild::ActorDestroy(ActorDestroyReason aWhy)
-{
-}
-
-static void
-_ProcLoaderChildDestroy(ProcLoaderChild *aChild)
-{
-  aChild->Close();
-  delete aChild;
-  MessageLoop::current()->Quit();
-}
-
-bool
-ProcLoaderChild::RecvLoad(const InfallibleTArray<nsCString>& aArgv,
-                          const InfallibleTArray<nsCString>& aEnv,
-                          const InfallibleTArray<FDRemap>& aFdsRemap,
-                          const uint32_t& aPrivs,
-                          const int32_t& aCookie) {
-  if (!sProcLoaderServing) {
-    return true;
-  }
-  sProcLoaderServing = false;
-
-  MOZ_ASSERT(sProcLoaderDispatchedTask == nullptr);
-  ChildPrivileges privs = static_cast<ChildPrivileges>(aPrivs);
-  sProcLoaderDispatchedTask =
-    new ProcLoaderLoadRunner(aArgv, aEnv, aFdsRemap, privs);
-
-  SendLoadComplete(mPeerPid, aCookie);
-
-  MessageLoop::current()->PostTask(FROM_HERE,
-                                   NewRunnableFunction(_ProcLoaderChildDestroy,
-                                                       this));
-  return true;
-}
-
-void
-ProcLoaderChild::OnChannelError()
-{
-  if (!sProcLoaderServing) {
-    return;
-  }
-  sProcLoaderServing = false;
-
-  PProcLoaderChild::OnChannelError();
-
-  MOZ_ASSERT(sProcLoaderDispatchedTask == nullptr);
-  sProcLoaderDispatchedTask = new ProcLoaderNoopRunner();
-
-  MessageLoop::current()->PostTask(FROM_HERE,
-                                   NewRunnableFunction(_ProcLoaderChildDestroy,
-                                                       this));
-}
-
-/**
- * A helper class which calls NS_LogInit/NS_LogTerm in its scope.
- */
-class ScopedLogging
-{
-public:
-  ScopedLogging() { NS_LogInit(); }
-  ~ScopedLogging() { NS_LogTerm(); }
-};
-
-/**
- * Run service of ProcLoader.
- *
- * \param aPeerPid is the pid of the parent.
- * \param aFd is the file descriptor of the socket for IPC.
- *
- * See the comment near the head of this file.
- */
-static int
-ProcLoaderServiceRun(pid_t aPeerPid, int aFd,
-                     int aArgc, const char *aArgv[])
-{
-  ScopedLogging logging;
-
-  char **_argv;
-  _argv = new char *[aArgc + 1];
-  for (int i = 0; i < aArgc; i++) {
-    _argv[i] = ::strdup(aArgv[i]);
-    MOZ_ASSERT(_argv[i] != nullptr);
-  }
-  _argv[aArgc] = nullptr;
-
-  gArgv = _argv;
-  gArgc = aArgc;
-
-  {
-    gDisableAndroidLog = true;
-
-    nsresult rv = XRE_InitCommandLine(aArgc, _argv);
-    if (NS_FAILED(rv)) {
-      gDisableAndroidLog = false;
-      MOZ_CRASH();
-    }
-
-    FileDescriptor fd(aFd);
-    close(aFd);
-
-    MOZ_ASSERT(!sProcLoaderServing);
-    MessageLoop loop;
-
-    nsAutoPtr<ContentProcess> process;
-    process = new ContentProcess(aPeerPid);
-    ChildThread *iothread = process->child_thread();
-
-    Transport *transport = OpenDescriptor(fd, Transport::MODE_CLIENT);
-    ProcLoaderChild *loaderChild = new ProcLoaderChild(aPeerPid);
-    // Pass a message loop to initialize (connect) the channel
-    // (connection).
-    loaderChild->Open(transport, aPeerPid, iothread->message_loop());
-
-    BackgroundHangMonitor::Prohibit();
-
-    sProcLoaderServing = true;
-    loop.Run();
-
-    BackgroundHangMonitor::Allow();
-
-    XRE_DeinitCommandLine();
-
-    gDisableAndroidLog = false;
-  }
-
-  MOZ_ASSERT(sProcLoaderDispatchedTask != nullptr);
-  ProcLoaderRunnerBase *task = sProcLoaderDispatchedTask;
-  sProcLoaderDispatchedTask = nullptr;
-  int ret = task->DoWork();
-  delete task;
-
-  for (int i = 0; i < aArgc; i++) {
-    free(_argv[i]);
-  }
-  delete[] _argv;
-
-  return ret;
-}
-
-#endif /* MOZ_B2G_LOADER */
-
 } // namespace ipc
 } // namespace mozilla
-
-#ifdef MOZ_B2G_LOADER
-void
-XRE_ProcLoaderClientInit(pid_t aPeerPid, int aChannelFd)
-{
-  mozilla::ipc::ProcLoaderClientInit(aPeerPid, aChannelFd);
-}
-
-int
-XRE_ProcLoaderServiceRun(pid_t aPeerPid, int aFd,
-                         int aArgc, const char *aArgv[])
-{
-  return mozilla::ipc::ProcLoaderServiceRun(aPeerPid, aFd,
-                                            aArgc, aArgv);
-}
-#endif /* MOZ_B2G_LOADER */
--- a/ipc/glue/moz.build
+++ b/ipc/glue/moz.build
@@ -125,24 +125,22 @@ LOCAL_INCLUDES += [
     '/xpcom/build',
 ]
 
 IPDL_SOURCES = [
     'InputStreamParams.ipdlh',
     'PBackground.ipdl',
     'PBackgroundSharedTypes.ipdlh',
     'PBackgroundTest.ipdl',
-    'PProcLoader.ipdl',
     'ProtocolTypes.ipdlh',
     'URIParams.ipdlh',
 ]
 
 
 LOCAL_INCLUDES += [
-    '/toolkit/xre',
     '/xpcom/threads',
 ]
 
 include('/ipc/chromium/chromium-config.mozbuild')
 
 FINAL_LIBRARY = 'xul'
 
 for var in ('MOZ_CHILD_PROCESS_NAME', 'MOZ_CHILD_PROCESS_BUNDLE',
--- a/ipc/moz.build
+++ b/ipc/moz.build
@@ -21,12 +21,9 @@ if CONFIG['MOZ_NFC']:
     DIRS += ['nfc']
 
 if CONFIG['MOZ_B2G_RIL'] or CONFIG['MOZ_B2G_BT'] or CONFIG['MOZ_NFC'] or CONFIG['MOZ_WIDGET_TOOLKIT'] == 'gonk':
     DIRS += ['unixfd', 'unixsocket']
 
 if CONFIG['MOZ_WIDGET_TOOLKIT'] == 'gonk':
     DIRS += ['keystore', 'netd']
 
-if CONFIG['MOZ_WIDGET_TOOLKIT'] != 'android':
-    DIRS += ['contentproc']
-
 DIRS += ['app']
--- a/toolkit/xre/moz.build
+++ b/toolkit/xre/moz.build
@@ -155,10 +155,8 @@ LOCAL_INCLUDES += [
     '/xpcom/build',
 ]
 
 if CONFIG['MOZ_ENABLE_XREMOTE']:
     LOCAL_INCLUDES += [
         '/widget/xremoteclient',
     ]
 
-if CONFIG['MOZ_B2G_LOADER']:
-    DEFINES['OMNIJAR_NAME'] = CONFIG['OMNIJAR_NAME']
--- a/toolkit/xre/nsAppRunner.cpp
+++ b/toolkit/xre/nsAppRunner.cpp
@@ -180,20 +180,16 @@
 #include "nsIPrefService.h"
 #endif
 
 #include "base/command_line.h"
 #ifdef MOZ_ENABLE_TESTS
 #include "GTestRunner.h"
 #endif
 
-#ifdef MOZ_B2G_LOADER
-#include "ProcessUtils.h"
-#endif
-
 #ifdef MOZ_WIDGET_ANDROID
 #include "AndroidBridge.h"
 #endif
 
 extern uint32_t gRestartMode;
 extern void InstallSignalHandlers(const char *ProgramName);
 
 #define FILE_COMPATIBILITY_INFO NS_LITERAL_CSTRING("compatibility.ini")
@@ -3771,20 +3767,16 @@ XREMain::XRE_mainStartup(bool* aExitFlag
  * the calling of appStartup->Run().
  */
 nsresult
 XREMain::XRE_mainRun()
 {
   nsresult rv = NS_OK;
   NS_ASSERTION(mScopedXPCom, "Scoped xpcom not initialized.");
 
-#ifdef MOZ_B2G_LOADER
-  mozilla::ipc::ProcLoaderClientGeckoInit();
-#endif
-
 #ifdef NS_FUNCTION_TIMER
   // initialize some common services, so we don't pay the cost for these at odd times later on;
   // SetWindowCreator -> ChromeRegistry -> IOService -> SocketTransportService -> (nspr wspm init), Prefs
   {
     nsCOMPtr<nsISupports> comp;
 
     comp = do_GetService("@mozilla.org/preferences-service;1");
 
--- a/toolkit/xre/nsEmbedFunctions.cpp
+++ b/toolkit/xre/nsEmbedFunctions.cpp
@@ -76,21 +76,16 @@
 
 #ifdef MOZ_IPDL_TESTS
 #include "mozilla/_ipdltest/IPDLUnitTests.h"
 #include "mozilla/_ipdltest/IPDLUnitTestProcessChild.h"
 
 using mozilla::_ipdltest::IPDLUnitTestProcessChild;
 #endif  // ifdef MOZ_IPDL_TESTS
 
-#ifdef MOZ_B2G_LOADER
-#include "nsLocalFile.h"
-#include "nsXREAppData.h"
-#endif
-
 using namespace mozilla;
 
 using mozilla::ipc::BrowserProcessSubThread;
 using mozilla::ipc::GeckoChildProcessHost;
 using mozilla::ipc::IOThreadChild;
 using mozilla::ipc::ProcessChild;
 using mozilla::ipc::ScopedXREEmbed;
 
@@ -815,43 +810,8 @@ SetWindowsEnvironment(WindowsEnvironment
 
 WindowsEnvironmentType
 XRE_GetWindowsEnvironment()
 {
   return sWindowsEnvironmentType;
 }
 #endif // XP_WIN
 
-#ifdef MOZ_B2G_LOADER
-extern const nsXREAppData* gAppData;
-
-/**
- * Preload static data of Gecko for B2G loader.
- *
- * This function is supposed to be called before XPCOM is initialized.
- * For now, this function preloads
- *  - XPT interface Information
- */
-void
-XRE_ProcLoaderPreload(const char* aProgramDir, const nsXREAppData* aAppData)
-{
-    void PreloadXPT(nsIFile *);
-
-    nsresult rv;
-    nsCOMPtr<nsIFile> omnijarFile;
-    rv = NS_NewNativeLocalFile(nsCString(aProgramDir),
-			       true,
-			       getter_AddRefs(omnijarFile));
-    MOZ_ASSERT(NS_SUCCEEDED(rv));
-    rv = omnijarFile->AppendNative(NS_LITERAL_CSTRING(NS_STRINGIFY(OMNIJAR_NAME)));
-    MOZ_ASSERT(NS_SUCCEEDED(rv));
-
-    /*
-     * gAppData is required by nsXULAppInfo.  The manifest parser
-     * evaluate flags with the information from nsXULAppInfo.
-     */
-    gAppData = aAppData;
-
-    PreloadXPT(omnijarFile);
-
-    gAppData = nullptr;
-}
-#endif /* MOZ_B2G_LOADER */
--- a/tools/profiler/platform.cpp
+++ b/tools/profiler/platform.cpp
@@ -873,20 +873,16 @@ void mozilla_sampler_unlock()
 {
   nsCOMPtr<nsIObserverService> os = mozilla::services::GetObserverService();
   if (os)
     os->NotifyObservers(nullptr, "profiler-unlocked", nullptr);
 }
 
 bool mozilla_sampler_register_thread(const char* aName, void* stackTop)
 {
-  if (sInitCount == 0) {
-    return false;
-  }
-
 #if defined(MOZ_WIDGET_GONK) && !defined(MOZ_PROFILING)
   // The only way to profile secondary threads on b2g
   // is to build with profiling OR have the profiler
   // running on startup.
   if (!profiler_is_active()) {
     return false;
   }
 #endif
@@ -894,47 +890,35 @@ bool mozilla_sampler_register_thread(con
   PseudoStack* stack = new PseudoStack();
   tlsPseudoStack.set(stack);
   bool isMainThread = is_main_thread_name(aName);
   return Sampler::RegisterCurrentThread(aName, stack, isMainThread, stackTop);
 }
 
 void mozilla_sampler_unregister_thread()
 {
-  if (sInitCount == 0) {
-    return;
-  }
-
   Sampler::UnregisterCurrentThread();
 
   PseudoStack *stack = tlsPseudoStack.get();
   if (!stack) {
     return;
   }
   delete stack;
   tlsPseudoStack.set(nullptr);
 }
 
 void mozilla_sampler_sleep_start() {
-    if (sInitCount == 0) {
-	return;
-    }
-
     PseudoStack *stack = tlsPseudoStack.get();
     if (stack == nullptr) {
       return;
     }
     stack->setSleeping(1);
 }
 
 void mozilla_sampler_sleep_end() {
-    if (sInitCount == 0) {
-	return;
-    }
-
     PseudoStack *stack = tlsPseudoStack.get();
     if (stack == nullptr) {
       return;
     }
     stack->setSleeping(0);
 }
 
 double mozilla_sampler_time(const mozilla::TimeStamp& aTime)
--- a/xpcom/base/nsDebugImpl.cpp
+++ b/xpcom/base/nsDebugImpl.cpp
@@ -96,23 +96,16 @@ Break(const char* aMsg);
 #if defined(_WIN32)
 #include <windows.h>
 #include <signal.h>
 #include <malloc.h> // for _alloca
 #elif defined(XP_UNIX)
 #include <stdlib.h>
 #endif
 
-#ifdef MOZ_B2G_LOADER
-/* Avoid calling Android logger/logd temporarily while running
- * B2GLoader to start the child process.
- */
-bool gDisableAndroidLog = false;
-#endif
-
 using namespace mozilla;
 
 static const char* sMultiprocessDescription = nullptr;
 
 static Atomic<int32_t> gAssertionCount;
 
 NS_IMPL_QUERY_INTERFACE(nsDebugImpl, nsIDebug, nsIDebug2)
 
@@ -394,19 +387,16 @@ NS_DebugBreak(uint32_t aSeverity, const 
   // errors on platforms without a debugdlg ring a bell on stderr
 #if !defined(XP_WIN)
   if (ll != PR_LOG_WARNING) {
     fprintf(stderr, "\07");
   }
 #endif
 
 #ifdef ANDROID
-#ifdef MOZ_B2G_LOADER
-  if (!gDisableAndroidLog)
-#endif
   __android_log_print(ANDROID_LOG_INFO, "Gecko", "%s", buf.buffer);
 #endif
 
   // Write the message to stderr unless it's a warning and MOZ_IGNORE_WARNINGS
   // is set.
   if (!(PR_GetEnv("MOZ_IGNORE_WARNINGS") && aSeverity == NS_DEBUG_WARNING)) {
     fprintf(stderr, "%s\n", buf.buffer);
     fflush(stderr);
--- a/xpcom/build/nsXULAppAPI.h
+++ b/xpcom/build/nsXULAppAPI.h
@@ -462,22 +462,12 @@ enum WindowsEnvironmentType {
 /**
  * Retrieve the Windows desktop environment libXUL is running
  * under. Valid after a call to XRE_main.
  */
 XRE_API(WindowsEnvironmentType,
         XRE_GetWindowsEnvironment, ())
 #endif // XP_WIN
 
-#ifdef MOZ_B2G_LOADER
-XRE_API(int,
-        XRE_ProcLoaderServiceRun, (pid_t, int, int argc, const char *argv[]));
-XRE_API(void,
-        XRE_ProcLoaderClientInit, (pid_t, int));
-XRE_API(void,
-        XRE_ProcLoaderPreload, (const char* aProgramDir,
-                                const nsXREAppData* aAppData));
-#endif // MOZ_B2G_LOADER
-
 XRE_API(int,
         XRE_XPCShellMain, (int argc, char** argv, char** envp))
 
 #endif // _nsXULAppAPI_h__
--- a/xpcom/components/ManifestParser.cpp
+++ b/xpcom/components/ManifestParser.cpp
@@ -31,28 +31,16 @@
 #include "nsTextFormatter.h"
 #include "nsVersionComparator.h"
 #include "nsXPCOMCIDInternal.h"
 
 #include "nsIConsoleService.h"
 #include "nsIScriptError.h"
 #include "nsIXULAppInfo.h"
 #include "nsIXULRuntime.h"
-#ifdef MOZ_B2G_LOADER
-#include "mozilla/XPTInterfaceInfoManager.h"
-#endif
-
-#ifdef MOZ_B2G_LOADER
-#define XPTONLY_MANIFEST &nsComponentManagerImpl::XPTOnlyManifestManifest
-#define XPTONLY_XPT &nsComponentManagerImpl::XPTOnlyManifestXPT
-#else
-#define XPTONLY_MANIFEST nullptr
-#define XPTONLY_XPT nullptr
-#endif
-
 
 using namespace mozilla;
 
 struct ManifestDirective
 {
   const char* directive;
   int argc;
 
@@ -71,53 +59,46 @@ struct ManifestDirective
   // 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);
-#ifdef MOZ_B2G_LOADER
-  // The function to handle the directive for XPT Only parsing.
-  void (*xptonlyfunc)(nsComponentManagerImpl::XPTOnlyManifestProcessingContext& cx,
-                      int lineno, char *const * argv);
-#else
-  void *xptonlyfunc;
-#endif
 
   bool isContract;
 };
 static const ManifestDirective kParsingTable[] = {
   { "manifest",         1, false, true, true, false,
-    &nsComponentManagerImpl::ManifestManifest, nullptr, XPTONLY_MANIFEST },
+    &nsComponentManagerImpl::ManifestManifest, nullptr },
   { "binary-component", 1, true, false, false, false,
-    &nsComponentManagerImpl::ManifestBinaryComponent, nullptr, nullptr },
+    &nsComponentManagerImpl::ManifestBinaryComponent, nullptr },
   { "interfaces",       1, true, false, false, false,
-    &nsComponentManagerImpl::ManifestXPT, nullptr, XPTONLY_XPT },
+    &nsComponentManagerImpl::ManifestXPT, nullptr },
   { "component",        2, true, false, false, false,
-    &nsComponentManagerImpl::ManifestComponent, nullptr, nullptr },
+    &nsComponentManagerImpl::ManifestComponent, nullptr },
   { "contract",         2, true, false, false, false,
-    &nsComponentManagerImpl::ManifestContract, nullptr, nullptr, true},
+    &nsComponentManagerImpl::ManifestContract, nullptr, true},
   { "category",         3, true, false, false, false,
-    &nsComponentManagerImpl::ManifestCategory, nullptr, nullptr },
+    &nsComponentManagerImpl::ManifestCategory, nullptr },
   { "content",          2, true, true, true,  true,
-    nullptr, &nsChromeRegistry::ManifestContent, nullptr },
+    nullptr, &nsChromeRegistry::ManifestContent },
   { "locale",           3, true, true, true,  false,
-    nullptr, &nsChromeRegistry::ManifestLocale, nullptr },
+    nullptr, &nsChromeRegistry::ManifestLocale },
   { "skin",             3, false, true, true,  false,
-    nullptr, &nsChromeRegistry::ManifestSkin, nullptr },
+    nullptr, &nsChromeRegistry::ManifestSkin },
   { "overlay",          2, true, true, false,  false,
-    nullptr, &nsChromeRegistry::ManifestOverlay, nullptr },
+    nullptr, &nsChromeRegistry::ManifestOverlay },
   { "style",            2, false, true, false,  false,
-    nullptr, &nsChromeRegistry::ManifestStyle, nullptr },
+    nullptr, &nsChromeRegistry::ManifestStyle },
   { "override",         2, true, true, true,  false,
-    nullptr, &nsChromeRegistry::ManifestOverride, nullptr },
+    nullptr, &nsChromeRegistry::ManifestOverride },
   { "resource",         2, true, true, false,  false,
-    nullptr, &nsChromeRegistry::ManifestResource, nullptr }
+    nullptr, &nsChromeRegistry::ManifestResource }
 };
 
 static const char kWhitespace[] = "\t ";
 
 static bool IsNewline(char c)
 {
   return c == '\n' || c == '\r';
 }
@@ -140,59 +121,43 @@ struct AutoPR_smprintf_free
     return mBuf;
   }
 
   char* mBuf;
 };
 
 } // anonymous namespace
 
-/**
- * If we are pre-loading XPTs, this method may do nothing because the
- * console service is not initialized.
- */
 void LogMessage(const char* aMsg, ...)
 {
-  if (!nsComponentManagerImpl::gComponentManager) {
-    return;
-  }
-
   nsCOMPtr<nsIConsoleService> console =
     do_GetService(NS_CONSOLESERVICE_CONTRACTID);
   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);
 }
 
-/**
- * If we are pre-loading XPTs, this method may do nothing because the
- * console service is not initialized.
- */
 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)
     return;
 
-  if (!nsComponentManagerImpl::gComponentManager) {
-    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.
@@ -418,33 +383,21 @@ struct CachedDirective
 {
   int lineno;
   char* argv[4];
 };
 
 } // anonymous namespace
 
 
-/**
- * For XPT-Only mode, the parser handles only directives of "manifest"
- * and "interfaces", and always call the function given by |xptonlyfunc|
- * variable of struct |ManifestDirective|.
- *
- * This function is safe to be called before the component manager is
- * ready if aXPTOnly is true for it don't invoke any component during
- * parsing.
- */
 void
-ParseManifest(NSLocationType type, FileLocation &file, char* buf, bool aChromeOnly, bool aXPTOnly)
+ParseManifest(NSLocationType type, FileLocation &file, char* buf, bool aChromeOnly)
 {
   nsComponentManagerImpl::ManifestProcessingContext mgrcx(type, file, aChromeOnly);
   nsChromeRegistry::ManifestProcessingContext chromecx(type, file);
-#ifdef MOZ_B2G_LOADER
-  nsComponentManagerImpl::XPTOnlyManifestProcessingContext xptonlycx(file);
-#endif
   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");
@@ -458,22 +411,17 @@ ParseManifest(NSLocationType type, FileL
   NS_NAMED_LITERAL_STRING(kXPCNativeWrappers, "xpcnativewrappers");
 
   nsAutoString appID;
   nsAutoString appVersion;
   nsAutoString geckoVersion;
   nsAutoString osTarget;
   nsAutoString abi;
 
-  nsCOMPtr<nsIXULAppInfo> xapp;
-  if (!aXPTOnly) {
-    // Avoid to create any component for XPT only mode.
-    // No xapp means no ID, version, ..., modifiers checking.
-    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))
       CopyUTF8toUTF16(s, appID);
 
     rv = xapp->GetVersion(s);
     if (NS_SUCCEEDED(rv))
@@ -563,20 +511,19 @@ ParseManifest(NSLocationType type, FileL
     char *whitespace = token;
     token = nsCRT::strtok(whitespace, kWhitespace, &whitespace);
     if (!token) continue;
 
     const ManifestDirective* directive = nullptr;
     for (const ManifestDirective* d = kParsingTable;
 	 d < ArrayEnd(kParsingTable);
 	 ++d) {
-      if (!strcmp(d->directive, token) &&
-          (!aXPTOnly || d->xptonlyfunc)) {
-        directive = d;
-        break;
+      if (!strcmp(d->directive, token)) {
+	directive = d;
+	break;
       }
     }
 
     if (!directive) {
       LogMessageWithContext(file, line,
                             "Ignoring unrecognized chrome manifest directive '%s'.",
                             token);
       continue;
@@ -625,19 +572,18 @@ ParseManifest(NSLocationType type, FileL
       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
@@ -668,21 +614,16 @@ ParseManifest(NSLocationType type, FileL
         stOs == eBad ||
         stOsVersion == eBad ||
 #ifdef MOZ_WIDGET_ANDROID
         stTablet == eBad ||
 #endif
         stABI == eBad)
       continue;
 
-#ifdef MOZ_B2G_LOADER
-    if (aXPTOnly) {
-      directive->xptonlyfunc(xptonlycx, line, argv);
-    } else
-#endif /* MOZ_B2G_LOADER */
     if (directive->regfunc) {
       if (GeckoProcessType_Default != XRE_GetProcessType())
         continue;
 
       if (!nsChromeRegistry::gChromeRegistry) {
         nsCOMPtr<nsIChromeRegistry> cr =
           mozilla::services::GetChromeRegistryService();
         if (!nsChromeRegistry::gChromeRegistry) {
@@ -690,29 +631,26 @@ ParseManifest(NSLocationType type, FileL
                                 "Chrome registry isn't available yet.");
           continue;
         }
       }
 
       (nsChromeRegistry::gChromeRegistry->*(directive->regfunc))
 	(chromecx, line, argv, platform, contentAccessible);
     }
-    else if (directive->mgrfunc && (directive->ischrome || !aChromeOnly)) {
+    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 {
-      LogMessageWithContext(file, line,
-                            "No valid manifest directive.");
     }
   }
 
   for (uint32_t i = 0; i < contracts.Length(); ++i) {
     CachedDirective& d = contracts[i];
     nsComponentManagerImpl::gComponentManager->ManifestContract
       (mgrcx, d.lineno, d.argv);
   }
--- a/xpcom/components/ManifestParser.h
+++ b/xpcom/components/ManifestParser.h
@@ -8,16 +8,16 @@
 
 #include "nsComponentManager.h"
 #include "nsChromeRegistry.h"
 #include "mozilla/FileLocation.h"
 
 class nsIFile;
 
 void ParseManifest(NSLocationType type, mozilla::FileLocation &file,
-                   char* buf, bool aChromeOnly, bool aXPTOnly=false);
+                   char* buf, bool aChromeOnly);
 
 void LogMessage(const char* aMsg, ...);
 
 void LogMessageWithContext(mozilla::FileLocation &aFile,
                            uint32_t aLineNumber, const char* aMsg, ...);
 
 #endif // ManifestParser_h
--- a/xpcom/components/nsComponentManager.cpp
+++ b/xpcom/components/nsComponentManager.cpp
@@ -64,17 +64,16 @@
 #include "mozilla/GenericFactory.h"
 #include "nsSupportsPrimitives.h"
 #include "nsArray.h"
 #include "nsIMutableArray.h"
 #include "nsArrayEnumerator.h"
 #include "nsStringEnumerator.h"
 #include "mozilla/FileUtils.h"
 #include "nsNetUtil.h"
-#include "nsDataHashtable.h"
 
 #include <new>     // for placement new
 
 #include "mozilla/Omnijar.h"
 
 #include "prlog.h"
 
 using namespace mozilla;
@@ -100,46 +99,16 @@ 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
 
-#ifdef MOZ_B2G_LOADER
-typedef nsDataHashtable<nsCStringHashKey, bool> XPTIInfosBookType;
-static XPTIInfosBookType *sXPTIInfosBook = nullptr;
-
-static XPTIInfosBookType *
-GetXPTIInfosBook()
-{
-    if (sXPTIInfosBook == nullptr) {
-        sXPTIInfosBook = new XPTIInfosBookType;
-    }
-    return sXPTIInfosBook;
-}
-
-static bool
-IsRegisteredXPTIInfo(FileLocation &aFile)
-{
-    nsAutoCString uri;
-    aFile.GetURIString(uri);
-    return GetXPTIInfosBook()->Get(uri);
-}
-
-static void
-MarkRegisteredXPTIInfo(FileLocation &aFile)
-{
-    nsAutoCString uri;
-    aFile.GetURIString(uri);
-    GetXPTIInfosBook()->Put(uri, true);
-}
-#endif /* MOZ_B2G_LOADER */
-
 nsresult
 nsGetServiceFromCategory::operator()(const nsIID& aIID, void** aInstancePtr) const
 {
     nsresult rv;
     nsXPIDLCString value;
     nsCOMPtr<nsICategoryManager> catman;
     nsComponentManagerImpl *compMgr = nsComponentManagerImpl::gComponentManager;
     if (!compMgr) {
@@ -550,54 +519,43 @@ CutExtension(nsCString& path)
 {
     int32_t dotPos = path.RFindChar('.');
     if (kNotFound == dotPos)
         path.Truncate();
     else
         path.Cut(0, dotPos + 1);
 }
 
-static void
-DoRegisterManifest(NSLocationType aType,
-                   FileLocation &aFile,
-                   bool aChromeOnly,
-                   bool aXPTOnly)
+void
+nsComponentManagerImpl::RegisterManifest(NSLocationType aType,
+                                         FileLocation &aFile,
+                                         bool aChromeOnly)
 {
-    MOZ_ASSERT(!aXPTOnly ||
-               nsComponentManagerImpl::gComponentManager == nullptr);
     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, aXPTOnly);
+        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::RegisterManifest(NSLocationType aType,
-                                         FileLocation &aFile,
-                                         bool aChromeOnly)
-{
-    DoRegisterManifest(aType, aFile, aChromeOnly, false);
-}
-
-void
 nsComponentManagerImpl::ManifestManifest(ManifestProcessingContext& cx, int lineno, char *const * argv)
 {
     char* file = argv[0];
     FileLocation f(cx.mFile, file);
     RegisterManifest(cx.mType, f, cx.mChromeOnly);
 }
 
 void
@@ -624,56 +582,41 @@ nsComponentManagerImpl::ManifestBinaryCo
     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);
 }
 
-static void
-DoRegisterXPT(FileLocation &aFile)
+void
+nsComponentManagerImpl::ManifestXPT(ManifestProcessingContext& cx, int lineno, char *const * argv)
 {
-#ifdef MOZ_B2G_LOADER
-    if (IsRegisteredXPTIInfo(aFile)) {
-        return;
-    }
-#endif
-
+    FileLocation f(cx.mFile, argv[0]);
     uint32_t len;
     FileLocation::Data data;
     nsAutoArrayPtr<char> buf;
-    nsresult rv = aFile.GetData(data);
+    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);
-#ifdef MOZ_B2G_LOADER
-        MarkRegisteredXPTIInfo(aFile);
-#endif
     } else {
         nsCString uri;
-        aFile.GetURIString(uri);
+        f.GetURIString(uri);
         LogMessage("Could not read '%s'.", uri.get());
     }
 }
 
 void
-nsComponentManagerImpl::ManifestXPT(ManifestProcessingContext& cx, int lineno, char *const * argv)
-{
-    FileLocation f(cx.mFile, argv[0]);
-    DoRegisterXPT(f);
-}
-
-void
 nsComponentManagerImpl::ManifestComponent(ManifestProcessingContext& cx, int lineno, char *const * argv)
 {
     mLock.AssertNotCurrentThreadOwns();
 
     char* id = argv[0];
     char* file = argv[1];
 
     nsID cid;
@@ -846,20 +789,16 @@ nsresult nsComponentManagerImpl::Shutdow
     mContractIDs.Clear();
     mFactories.Clear(); // XXX release the objects, don't just clear
     mLoaderMap.Clear();
     mKnownModules.Clear();
     mKnownStaticModules.Clear();
 
     delete sStaticModules;
     delete sModuleLocations;
-#ifdef MOZ_B2G_LOADER
-    delete sXPTIInfosBook;
-    sXPTIInfosBook = nullptr;
-#endif
 
     // Unload libraries
     mNativeModuleLoader.UnloadLibraries();
 
     // delete arena for strings and small objects
     PL_FinishArenaPool(&mArena);
 
     mStatus = SHUTDOWN_COMPLETE;
@@ -1998,64 +1937,16 @@ nsComponentManagerImpl::GetManifestLocat
     if (NS_SUCCEEDED(rv))
       locations->AppendElement(uri, false);
   }
 
   locations.forget(aLocations);
   return NS_OK;
 }
 
-#ifdef MOZ_B2G_LOADER
-
-/* static */
-void
-nsComponentManagerImpl::XPTOnlyManifestManifest(XPTOnlyManifestProcessingContext &aCx,
-                                                int aLineno,
-                                                char * const * aArgv)
-{
-    char* file = aArgv[0];
-    FileLocation f(aCx.mFile, file);
-
-    DoRegisterManifest(NS_COMPONENT_LOCATION, f, false, true);
-}
-
-/* static */
-void
-nsComponentManagerImpl::XPTOnlyManifestXPT(XPTOnlyManifestProcessingContext &aCx,
-                                           int aLineno,
-                                           char * const * aArgv)
-{
-    FileLocation f(aCx.mFile, aArgv[0]);
-    DoRegisterXPT(f);
-}
-
-/**
- * To load XPT Interface Information before the component manager is ready.
- *
- * With this function, B2G loader could XPT interface info. as earier
- * as possible to gain benefit of shared memory model of the kernel.
- */
-/* static */ void
-nsComponentManagerImpl::PreloadXPT(nsIFile *aFile)
-{
-    MOZ_ASSERT(nsComponentManagerImpl::gComponentManager == nullptr);
-    FileLocation location(aFile, "chrome.manifest");
-
-    DoRegisterManifest(NS_COMPONENT_LOCATION, location,
-                       false, true /* aXPTOnly */);
-}
-
-void
-PreloadXPT(nsIFile *aOmnijarFile)
-{
-    nsComponentManagerImpl::PreloadXPT(aOmnijarFile);
-}
-
-#endif /* MOZ_B2G_LOADER */
-
 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);
--- a/xpcom/components/nsComponentManager.h
+++ b/xpcom/components/nsComponentManager.h
@@ -33,20 +33,16 @@
 #include "nsDataHashtable.h"
 #include "nsInterfaceHashtable.h"
 #include "nsClassHashtable.h"
 #include "nsTArray.h"
 
 #include "mozilla/Omnijar.h"
 #include "mozilla/Attributes.h"
 
-#ifdef MOZ_B2G_LOADER
-#include "mozilla/FileLocation.h"
-#endif
-
 struct nsFactoryEntry;
 class nsIServiceManager;
 struct PRThread;
 
 #define NS_COMPONENTMANAGER_CID                      \
 { /* 91775d60-d5dc-11d2-92fb-00e09805570f */         \
     0x91775d60,                                      \
     0xd5dc,                                          \
@@ -315,40 +311,16 @@ public:
                                                  PRThread* aThread);
     inline void RemovePendingService(const nsCID& aServiceCID);
     inline PRThread* GetPendingServiceThread(const nsCID& aServiceCID) const;
 
     nsTArray<PendingServiceInfo> mPendingServices;
 
     size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf);
 
-#ifdef MOZ_B2G_LOADER
-    // Preload XPT interface info for B2G loader.
-    // This function is called before XPCOM has been initialized.
-    static void PreloadXPT(nsIFile *aFile);
-#endif
-
-#ifdef MOZ_B2G_LOADER
-    // Parsing functions of directives of manifest for XPT only parsing.
-    struct XPTOnlyManifestProcessingContext
-    {
-        XPTOnlyManifestProcessingContext(mozilla::FileLocation &aFile)
-            : mFile(aFile)
-        { }
-
-        ~XPTOnlyManifestProcessingContext() { }
-
-        mozilla::FileLocation mFile;
-    };
-    static void XPTOnlyManifestManifest(XPTOnlyManifestProcessingContext& aCx,
-                                        int aLineno, char * const *aArgv);
-    static void XPTOnlyManifestXPT(XPTOnlyManifestProcessingContext& aCx,
-                                   int aLineno, char * const *aArgv);
-#endif
-
 private:
     ~nsComponentManagerImpl();
 };
 
 
 #define NS_MAX_FILENAME_LEN     1024
 
 #define NS_ERROR_IS_DIR NS_ERROR_GENERATE_FAILURE(NS_ERROR_MODULE_XPCOM, 24)
--- a/xpcom/threads/BackgroundHangMonitor.cpp
+++ b/xpcom/threads/BackgroundHangMonitor.cpp
@@ -60,17 +60,16 @@ private:
 
   BackgroundHangManager(const BackgroundHangManager&);
   BackgroundHangManager& operator=(const BackgroundHangManager&);
   void RunMonitorThread();
 
 public:
   NS_INLINE_DECL_THREADSAFE_REFCOUNTING(BackgroundHangManager)
   static StaticRefPtr<BackgroundHangManager> sInstance;
-  static bool sProhibited;
 
   // Lock for access to members of this class
   Monitor mLock;
   // Current time as seen by hang monitors
   PRIntervalTime mIntervalNow;
   // List of BackgroundHangThread instances associated with each thread
   LinkedList<BackgroundHangThread> mHangThreads;
 
@@ -158,17 +157,16 @@ public:
   {
     NotifyActivity();
     mWaiting = true;
   }
 };
 
 
 StaticRefPtr<BackgroundHangManager> BackgroundHangManager::sInstance;
-bool BackgroundHangManager::sProhibited = false;
 
 ThreadLocal<BackgroundHangThread*> BackgroundHangThread::sTlsKey;
 
 
 BackgroundHangManager::BackgroundHangManager()
   : mShutdown(false)
   , mLock("BackgroundHangManager")
   , mIntervalNow(0)
@@ -406,26 +404,18 @@ BackgroundHangThread::NotifyActivity()
     mInterval = intervalNow;
   }
 }
 
 BackgroundHangThread*
 BackgroundHangThread::FindThread()
 {
 #ifdef MOZ_ENABLE_BACKGROUND_HANG_MONITOR
-  if (BackgroundHangManager::sInstance == nullptr) {
-    MOZ_ASSERT(BackgroundHangManager::sProhibited,
-               "BackgroundHandleManager is not initialized");
-    return nullptr;
-  }
-
   if (sTlsKey.initialized()) {
     // Use TLS if available
-    MOZ_ASSERT(!BackgroundHangManager::sProhibited,
-               "BackgroundHandleManager is not initialized");
     return sTlsKey.get();
   }
   // If TLS is unavailable, we can search through the thread list
   RefPtr<BackgroundHangManager> manager(BackgroundHangManager::sInstance);
   MOZ_ASSERT(manager, "Creating BackgroundHangMonitor after shutdown");
 
   PRThread* threadID = PR_GetCurrentThread();
   // Lock thread list for traversal
@@ -441,125 +431,85 @@ BackgroundHangThread::FindThread()
   return nullptr;
 }
 
 
 void
 BackgroundHangMonitor::Startup()
 {
 #ifdef MOZ_ENABLE_BACKGROUND_HANG_MONITOR
-  MOZ_ASSERT(!BackgroundHangManager::sProhibited, "Prohibited");
   MOZ_ASSERT(!BackgroundHangManager::sInstance, "Already initialized");
   ThreadStackHelper::Startup();
   BackgroundHangThread::Startup();
   BackgroundHangManager::sInstance = new BackgroundHangManager();
 #endif
 }
 
 void
 BackgroundHangMonitor::Shutdown()
 {
 #ifdef MOZ_ENABLE_BACKGROUND_HANG_MONITOR
-  MOZ_ASSERT(!BackgroundHangManager::sProhibited, "Prohibited");
   MOZ_ASSERT(BackgroundHangManager::sInstance, "Not initialized");
   /* Scope our lock inside Shutdown() because the sInstance object can
      be destroyed as soon as we set sInstance to nullptr below, and
      we don't want to hold the lock when it's being destroyed. */
   BackgroundHangManager::sInstance->Shutdown();
   BackgroundHangManager::sInstance = nullptr;
   ThreadStackHelper::Shutdown();
 #endif
 }
 
 BackgroundHangMonitor::BackgroundHangMonitor(const char* aName,
                                              uint32_t aTimeoutMs,
                                              uint32_t aMaxTimeoutMs)
   : mThread(BackgroundHangThread::FindThread())
 {
 #ifdef MOZ_ENABLE_BACKGROUND_HANG_MONITOR
-  if (!BackgroundHangManager::sProhibited && !mThread) {
-    // If sProhibit is true, mThread would be null, and no monitoring.
+  if (!mThread) {
     mThread = new BackgroundHangThread(aName, aTimeoutMs, aMaxTimeoutMs);
   }
 #endif
 }
 
 BackgroundHangMonitor::BackgroundHangMonitor()
   : mThread(BackgroundHangThread::FindThread())
 {
 #ifdef MOZ_ENABLE_BACKGROUND_HANG_MONITOR
-  MOZ_ASSERT(!BackgroundHangManager::sProhibited || mThread,
-             "This thread is not initialized for hang monitoring");
+  MOZ_ASSERT(mThread, "Thread not initialized for hang monitoring");
 #endif
 }
 
 BackgroundHangMonitor::~BackgroundHangMonitor()
 {
 }
 
 void
 BackgroundHangMonitor::NotifyActivity()
 {
 #ifdef MOZ_ENABLE_BACKGROUND_HANG_MONITOR
-  if (mThread == nullptr) {
-    MOZ_ASSERT(BackgroundHangManager::sProhibited,
-               "This thread is not initialized for hang monitoring");
-    return;
-  }
   mThread->NotifyActivity();
 #endif
 }
 
 void
 BackgroundHangMonitor::NotifyWait()
 {
 #ifdef MOZ_ENABLE_BACKGROUND_HANG_MONITOR
-  if (mThread == nullptr) {
-    MOZ_ASSERT(BackgroundHangManager::sProhibited,
-               "This thread is not initialized for hang monitoring");
-    return;
-  }
   mThread->NotifyWait();
 #endif
 }
 
-void
-BackgroundHangMonitor::Prohibit()
-{
-#ifdef MOZ_ENABLE_BACKGROUND_HANG_MONITOR
-  MOZ_ASSERT(BackgroundHangManager::sInstance == nullptr,
-             "The background hang monitor is already initialized");
-  BackgroundHangManager::sProhibited = true;
-#endif
-}
-
-void
-BackgroundHangMonitor::Allow()
-{
-#ifdef MOZ_ENABLE_BACKGROUND_HANG_MONITOR
-  MOZ_ASSERT(BackgroundHangManager::sInstance == nullptr,
-             "The background hang monitor is already initialized");
-  BackgroundHangManager::sProhibited = false;
-#endif
-}
-
 
 /* Because we are iterating through the BackgroundHangThread linked list,
    we need to take a lock. Using MonitorAutoLock as a base class makes
    sure all of that is taken care of for us. */
 BackgroundHangMonitor::ThreadHangStatsIterator::ThreadHangStatsIterator()
   : MonitorAutoLock(BackgroundHangManager::sInstance->mLock)
-  , mThread(BackgroundHangManager::sInstance ?
-            BackgroundHangManager::sInstance->mHangThreads.getFirst() :
-            nullptr)
+  , mThread(BackgroundHangManager::sInstance->mHangThreads.getFirst())
 {
-#ifdef MOZ_ENABLE_BACKGROUND_HANG_MONITOR
-  MOZ_ASSERT(BackgroundHangManager::sInstance || BackgroundHangManager::sProhibited,
-             "Inconsistent state");
-#endif
 }
 
 Telemetry::ThreadHangStats*
 BackgroundHangMonitor::ThreadHangStatsIterator::GetNext()
 {
   if (!mThread) {
     return nullptr;
   }
--- a/xpcom/threads/BackgroundHangMonitor.h
+++ b/xpcom/threads/BackgroundHangMonitor.h
@@ -102,18 +102,16 @@ class BackgroundHangThread;
  *        hangMonitor.NotifyWait();
  *        wait_for_next_event();
  *      }
  *    } else {
  *      process_nonsync_event();
  *    }
  *  }
  *
- * Prohibit() and Allow() make the background hang monitor work safely
- * before Startup().
  */
 class BackgroundHangMonitor
 {
 private:
   RefPtr<BackgroundHangThread> mThread;
 
 public:
   static const uint32_t kNoTimeout = 0;
@@ -201,34 +199,13 @@ public:
   void NotifyActivity();
 
   /**
    * Notify the hang monitor of current thread wait.
    * Call this method before entering a wait state; call
    * NotifyActivity when subsequently exiting the wait state.
    */
   void NotifyWait();
-
-  /**
-   * Prohibit the hang monitor from activating.
-   *
-   * Startup() should not be called between Prohibit() and Allow().
-   * This function makes the background hang monitor stop monitoring
-   * threads.
-   *
-   * Prohibit() and Allow() can be called before XPCOM is ready.  If
-   * we don't stop monitoring threads it could case errors.
-   */
-  static void Prohibit();
-
-  /**
-   * Allow the hang monitor to run.
-   *
-   * Allow() and Prohibit() should be called in pair.
-   *
-   * \see Prohibit()
-   */
-  static void Allow();
 };
 
 } // namespace mozilla
 
 #endif // mozilla_BackgroundHangMonitor_h