wine/gecko
0
0
Fork 0
mirror of https://gitlab.winehq.org/wine/wine-gecko.git synced 2024-09-13 09:24:08 -07:00
Code Issues Packages Projects Releases Wiki Activity

Backout changesets 7ff3cd713466, f8ec5977a454 and c7c37390b46b (bug 977026) for b2g bustage on a CLOSED TREE.

Browse Source
This commit is contained in:
Mike Hommey 2014-07-29 14:50:41 +09:00
parent 5986228dc2
commit f39ef3e627
27 changed files with 181 additions and 1560 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

248
b2g/app/B2GLoader.cpp
View File

@ -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);
}

5
b2g/app/moz.build
View File

@ -9,11 +9,6 @@ if not CONFIG['LIBXUL_SDK']:
PROGRAM = CONFIG['MOZ_APP_NAME'] + "-bin" PROGRAM = CONFIG['MOZ_APP_NAME'] + "-bin"
else: else:
PROGRAM = CONFIG['MOZ_APP_NAME'] PROGRAM = CONFIG['MOZ_APP_NAME']
if CONFIG['MOZ_B2G_LOADER']:
SOURCES += [
'B2GLoader.cpp',
]
SOURCES += [ SOURCES += [
'nsBrowserApp.cpp', 'nsBrowserApp.cpp',
] ]

45
b2g/app/nsBrowserApp.cpp
View File

@ -17,7 +17,6 @@
#include <stdio.h> #include <stdio.h>
#include <stdarg.h> #include <stdarg.h>
#include <string.h>
#include "nsCOMPtr.h" #include "nsCOMPtr.h"
#include "nsIFile.h" #include "nsIFile.h"
@ -164,22 +163,9 @@ static int do_main(int argc, char* argv[])
return XRE_main(argc, argv, &sAppData, 0); return XRE_main(argc, argv, &sAppData, 0);
} }
#ifdef MOZ_B2G_LOADER int main(int argc, char* argv[])
/*
* 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[])
{ {
#ifndef MOZ_B2G_LOADER
char exePath[MAXPATHLEN]; char exePath[MAXPATHLEN];
#endif
#ifdef MOZ_WIDGET_GONK #ifdef MOZ_WIDGET_GONK
// This creates a ThreadPool for binder ipc. A ThreadPool is necessary to // This creates a ThreadPool for binder ipc. A ThreadPool is necessary to
@ -189,9 +175,7 @@ int main(int argc, _CONST char* argv[])
android::ProcessState::self()->startThreadPool(); android::ProcessState::self()->startThreadPool();
#endif #endif
nsresult rv; nsresult rv = mozilla::BinaryPath::Get(argv[0], exePath);
#ifndef MOZ_B2G_LOADER
rv = mozilla::BinaryPath::Get(argv[0], exePath);
if (NS_FAILED(rv)) { if (NS_FAILED(rv)) {
Output("Couldn't calculate the application directory.\n"); Output("Couldn't calculate the application directory.\n");
return 255; return 255;
@ -202,7 +186,6 @@ int main(int argc, _CONST char* argv[])
return 255; return 255;
strcpy(++lastSlash, XPCOM_DLL); strcpy(++lastSlash, XPCOM_DLL);
#endif // MOZ_B2G_LOADER
#if defined(XP_UNIX) #if defined(XP_UNIX)
// If the b2g app is launched from adb shell, then the shell will wind // If the b2g app is launched from adb shell, then the shell will wind
@ -226,9 +209,6 @@ int main(int argc, _CONST char* argv[])
DllBlocklist_Initialize(); DllBlocklist_Initialize();
#endif #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 // We do this because of data in bug 771745
XPCOMGlueEnablePreload(); XPCOMGlueEnablePreload();
@ -239,7 +219,6 @@ int main(int argc, _CONST char* argv[])
} }
// Reset exePath so that it is the directory name and not the xpcom dll name // Reset exePath so that it is the directory name and not the xpcom dll name
*lastSlash = 0; *lastSlash = 0;
#endif // MOZ_B2G_LOADER
rv = XPCOMGlueLoadXULFunctions(kXULFuncs); rv = XPCOMGlueLoadXULFunctions(kXULFuncs);
if (NS_FAILED(rv)) { if (NS_FAILED(rv)) {
@ -274,25 +253,7 @@ int main(int argc, _CONST char* argv[])
int result; int result;
{ {
ScopedLogging log; ScopedLogging log;
char **_argv; result = do_main(argc, 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;
} }
return result; return result;

1
b2g/confvars.sh
View File

@ -59,7 +59,6 @@ MOZ_B2G=1
if test "$OS_TARGET" = "Android"; then if test "$OS_TARGET" = "Android"; then
MOZ_NUWA_PROCESS=1 MOZ_NUWA_PROCESS=1
MOZ_B2G_LOADER=1
fi fi
MOZ_FOLD_LIBS=1 MOZ_FOLD_LIBS=1

8
configure.in
View File

@ -8631,14 +8631,6 @@ if test "$MOZ_WIDGET_TOOLKIT" = gonk -a -n "$MOZ_NUWA_PROCESS"; then
AC_DEFINE(MOZ_NUWA_PROCESS) AC_DEFINE(MOZ_NUWA_PROCESS)
fi fi
AC_SUBST(MOZ_NUWA_PROCESS) 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_CFLAGS)
AC_SUBST(NSPR_LIBS) AC_SUBST(NSPR_LIBS)

4
ipc/app/Makefile.in
View File

@ -37,10 +37,6 @@ include $(topsrcdir)/config/config.mk
include $(topsrcdir)/config/rules.mk include $(topsrcdir)/config/rules.mk
ifneq ($(MOZ_WIDGET_TOOLKIT),android)
#LIBS += ../contentproc/$(LIB_PREFIX)plugin-container.$(LIB_SUFFIX)
endif
ifeq ($(OS_ARCH),WINNT) #{ ifeq ($(OS_ARCH),WINNT) #{
# Note the manifest file exists in the tree, so we use the explicit filename # Note the manifest file exists in the tree, so we use the explicit filename
# here. # here.

149
ipc/app/MozillaRuntimeMain.cpp
View File

@ -4,9 +4,148 @@
* License, v. 2.0. If a copy of the MPL was not distributed with this * 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/. */ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "../contentproc/plugin-container.cpp" #include "nsXPCOM.h"
#include "nsXULAppAPI.h"
int
main(int argc, char *argv[]) { // FIXME/cjones testing
return content_process_main(argc, argv); #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[])
{
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;
} }

68
ipc/chromium/src/base/process_util_linux.cc
View File

@ -1,5 +1,3 @@
/* -*- 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. // Copyright (c) 2008 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be // Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file. // found in the LICENSE file.
@ -20,13 +18,6 @@
#include "base/logging.h" #include "base/logging.h"
#include "base/string_tokenizer.h" #include "base/string_tokenizer.h"
#include "base/string_util.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 #ifdef MOZ_WIDGET_GONK
/* /*
@ -197,71 +188,12 @@ bool LaunchApp(const std::vector<std::string>& argv,
wait, process_handle); 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, bool LaunchApp(const std::vector<std::string>& argv,
const file_handle_mapping_vector& fds_to_remap, const file_handle_mapping_vector& fds_to_remap,
const environment_map& env_vars_to_set, const environment_map& env_vars_to_set,
ChildPrivileges privs, ChildPrivileges privs,
bool wait, ProcessHandle* process_handle, bool wait, ProcessHandle* process_handle,
ProcessArchitecture arch) { 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]); scoped_array<char*> argv_cstr(new char*[argv.size() + 1]);
// Illegal to allocate memory after fork and before execvp // Illegal to allocate memory after fork and before execvp
InjectiveMultimap fd_shuffle1, fd_shuffle2; InjectiveMultimap fd_shuffle1, fd_shuffle2;

29
ipc/contentproc/moz.build
View File

@ -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',
]

151
ipc/contentproc/plugin-container.cpp
View File

@ -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;
}

35
ipc/glue/PProcLoader.ipdl
View File

@ -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);
};
}
}

17
ipc/glue/ProcessUtils.h
View File

@ -1,5 +1,3 @@
/* -*- 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 /* 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 * 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/. */ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
@ -7,10 +5,6 @@
#ifndef mozilla_ipc_ProcessUtils_h #ifndef mozilla_ipc_ProcessUtils_h
#define mozilla_ipc_ProcessUtils_h #define mozilla_ipc_ProcessUtils_h
#ifdef MOZ_B2G_LOADER
#include "base/process_util.h"
#endif
namespace mozilla { namespace mozilla {
namespace ipc { namespace ipc {
@ -18,17 +12,6 @@ namespace ipc {
// this directly. // this directly.
void SetThisProcessName(const char *aName); 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 ipc
} // namespace mozilla } // namespace mozilla

550
ipc/glue/ProcessUtils_linux.cpp
View File

@ -1,5 +1,3 @@
/* -*- 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 /* 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 * 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/. */ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
@ -10,37 +8,6 @@
#include <sys/prctl.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 mozilla {
namespace ipc { namespace ipc {
@ -49,522 +16,5 @@ void SetThisProcessName(const char *aName)
prctl(PR_SET_NAME, (unsigned long)aName, 0uL, 0uL, 0uL); 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 ipc
} // namespace mozilla } // 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 */

2
ipc/glue/moz.build
View File

@ -130,14 +130,12 @@ IPDL_SOURCES = [
'PBackground.ipdl', 'PBackground.ipdl',
'PBackgroundSharedTypes.ipdlh', 'PBackgroundSharedTypes.ipdlh',
'PBackgroundTest.ipdl', 'PBackgroundTest.ipdl',
'PProcLoader.ipdl',
'ProtocolTypes.ipdlh', 'ProtocolTypes.ipdlh',
'URIParams.ipdlh', 'URIParams.ipdlh',
] ]
LOCAL_INCLUDES += [ LOCAL_INCLUDES += [
'/toolkit/xre',
'/xpcom/threads', '/xpcom/threads',
] ]

3
ipc/moz.build
View File

@ -26,7 +26,4 @@ if CONFIG['MOZ_B2G_RIL'] or CONFIG['MOZ_B2G_BT'] or CONFIG['MOZ_NFC'] or CONFIG[
if CONFIG['MOZ_WIDGET_TOOLKIT'] == 'gonk': if CONFIG['MOZ_WIDGET_TOOLKIT'] == 'gonk':
DIRS += ['keystore', 'netd'] DIRS += ['keystore', 'netd']
if CONFIG['MOZ_WIDGET_TOOLKIT'] != 'android':
DIRS += ['contentproc']
DIRS += ['app'] DIRS += ['app']

2
toolkit/xre/moz.build
View File

@ -160,5 +160,3 @@ if CONFIG['MOZ_ENABLE_XREMOTE']:
'/widget/xremoteclient', '/widget/xremoteclient',
] ]
if CONFIG['MOZ_B2G_LOADER']:
DEFINES['OMNIJAR_NAME'] = CONFIG['OMNIJAR_NAME']

8
toolkit/xre/nsAppRunner.cpp
View File

@ -185,10 +185,6 @@
#include "GTestRunner.h" #include "GTestRunner.h"
#endif #endif
#ifdef MOZ_B2G_LOADER
#include "ProcessUtils.h"
#endif
#ifdef MOZ_WIDGET_ANDROID #ifdef MOZ_WIDGET_ANDROID
#include "AndroidBridge.h" #include "AndroidBridge.h"
#endif #endif
@ -3776,10 +3772,6 @@ XREMain::XRE_mainRun()
nsresult rv = NS_OK; nsresult rv = NS_OK;
NS_ASSERTION(mScopedXPCom, "Scoped xpcom not initialized."); NS_ASSERTION(mScopedXPCom, "Scoped xpcom not initialized.");
#ifdef MOZ_B2G_LOADER
mozilla::ipc::ProcLoaderClientGeckoInit();
#endif
#ifdef NS_FUNCTION_TIMER #ifdef NS_FUNCTION_TIMER
// initialize some common services, so we don't pay the cost for these at odd times later on; // 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 // SetWindowCreator -> ChromeRegistry -> IOService -> SocketTransportService -> (nspr wspm init), Prefs

40
toolkit/xre/nsEmbedFunctions.cpp
View File

@ -81,11 +81,6 @@
using mozilla::_ipdltest::IPDLUnitTestProcessChild; using mozilla::_ipdltest::IPDLUnitTestProcessChild;
#endif // ifdef MOZ_IPDL_TESTS #endif // ifdef MOZ_IPDL_TESTS
#ifdef MOZ_B2G_LOADER
#include "nsLocalFile.h"
#include "nsXREAppData.h"
#endif
using namespace mozilla; using namespace mozilla;
using mozilla::ipc::BrowserProcessSubThread; using mozilla::ipc::BrowserProcessSubThread;
@ -820,38 +815,3 @@ XRE_GetWindowsEnvironment()
} }
#endif // XP_WIN #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 */

16
tools/profiler/platform.cpp
View File

@ -878,10 +878,6 @@ void mozilla_sampler_unlock()
bool mozilla_sampler_register_thread(const char* aName, void* stackTop) bool mozilla_sampler_register_thread(const char* aName, void* stackTop)
{ {
if (sInitCount == 0) {
return false;
}
#if defined(MOZ_WIDGET_GONK) && !defined(MOZ_PROFILING) #if defined(MOZ_WIDGET_GONK) && !defined(MOZ_PROFILING)
// The only way to profile secondary threads on b2g // The only way to profile secondary threads on b2g
// is to build with profiling OR have the profiler // is to build with profiling OR have the profiler
@ -899,10 +895,6 @@ bool mozilla_sampler_register_thread(const char* aName, void* stackTop)
void mozilla_sampler_unregister_thread() void mozilla_sampler_unregister_thread()
{ {
if (sInitCount == 0) {
return;
}
Sampler::UnregisterCurrentThread(); Sampler::UnregisterCurrentThread();
PseudoStack *stack = tlsPseudoStack.get(); PseudoStack *stack = tlsPseudoStack.get();
@ -914,10 +906,6 @@ void mozilla_sampler_unregister_thread()
} }
void mozilla_sampler_sleep_start() { void mozilla_sampler_sleep_start() {
if (sInitCount == 0) {
return;
}
PseudoStack *stack = tlsPseudoStack.get(); PseudoStack *stack = tlsPseudoStack.get();
if (stack == nullptr) { if (stack == nullptr) {
return; return;
@ -926,10 +914,6 @@ void mozilla_sampler_sleep_start() {
} }
void mozilla_sampler_sleep_end() { void mozilla_sampler_sleep_end() {
if (sInitCount == 0) {
return;
}
PseudoStack *stack = tlsPseudoStack.get(); PseudoStack *stack = tlsPseudoStack.get();
if (stack == nullptr) { if (stack == nullptr) {
return; return;

10
xpcom/base/nsDebugImpl.cpp
View File

@ -101,13 +101,6 @@ Break(const char* aMsg);
#include <stdlib.h> #include <stdlib.h>
#endif #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; using namespace mozilla;
static const char* sMultiprocessDescription = nullptr; static const char* sMultiprocessDescription = nullptr;
@ -399,9 +392,6 @@ NS_DebugBreak(uint32_t aSeverity, const char* aStr, const char* aExpr,
#endif #endif
#ifdef ANDROID #ifdef ANDROID
#ifdef MOZ_B2G_LOADER
if (!gDisableAndroidLog)
#endif
__android_log_print(ANDROID_LOG_INFO, "Gecko", "%s", buf.buffer); __android_log_print(ANDROID_LOG_INFO, "Gecko", "%s", buf.buffer);
#endif #endif

10
xpcom/build/nsXULAppAPI.h
View File

@ -467,16 +467,6 @@ XRE_API(WindowsEnvironmentType,
XRE_GetWindowsEnvironment, ()) XRE_GetWindowsEnvironment, ())
#endif // XP_WIN #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_API(int,
XRE_XPCShellMain, (int argc, char** argv, char** envp)) XRE_XPCShellMain, (int argc, char** argv, char** envp))

102
xpcom/components/ManifestParser.cpp
View File

@ -36,18 +36,6 @@
#include "nsIScriptError.h" #include "nsIScriptError.h"
#include "nsIXULAppInfo.h" #include "nsIXULAppInfo.h"
#include "nsIXULRuntime.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; using namespace mozilla;
@ -76,43 +64,36 @@ struct ManifestDirective
(nsChromeRegistry::ManifestProcessingContext& cx, (nsChromeRegistry::ManifestProcessingContext& cx,
int lineno, char *const *argv, int lineno, char *const *argv,
bool platform, bool contentaccessible); 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; bool isContract;
}; };
static const ManifestDirective kParsingTable[] = { static const ManifestDirective kParsingTable[] = {
{ "manifest", 1, false, true, true, false, { "manifest", 1, false, true, true, false,
&nsComponentManagerImpl::ManifestManifest, nullptr, XPTONLY_MANIFEST }, &nsComponentManagerImpl::ManifestManifest, nullptr },
{ "binary-component", 1, true, false, false, false, { "binary-component", 1, true, false, false, false,
&nsComponentManagerImpl::ManifestBinaryComponent, nullptr, nullptr }, &nsComponentManagerImpl::ManifestBinaryComponent, nullptr },
{ "interfaces", 1, true, false, false, false, { "interfaces", 1, true, false, false, false,
&nsComponentManagerImpl::ManifestXPT, nullptr, XPTONLY_XPT }, &nsComponentManagerImpl::ManifestXPT, nullptr },
{ "component", 2, true, false, false, false, { "component", 2, true, false, false, false,
&nsComponentManagerImpl::ManifestComponent, nullptr, nullptr }, &nsComponentManagerImpl::ManifestComponent, nullptr },
{ "contract", 2, true, false, false, false, { "contract", 2, true, false, false, false,
&nsComponentManagerImpl::ManifestContract, nullptr, nullptr, true}, &nsComponentManagerImpl::ManifestContract, nullptr, true},
{ "category", 3, true, false, false, false, { "category", 3, true, false, false, false,
&nsComponentManagerImpl::ManifestCategory, nullptr, nullptr }, &nsComponentManagerImpl::ManifestCategory, nullptr },
{ "content", 2, true, true, true, true, { "content", 2, true, true, true, true,
nullptr, &nsChromeRegistry::ManifestContent, nullptr }, nullptr, &nsChromeRegistry::ManifestContent },
{ "locale", 3, true, true, true, false, { "locale", 3, true, true, true, false,
nullptr, &nsChromeRegistry::ManifestLocale, nullptr }, nullptr, &nsChromeRegistry::ManifestLocale },
{ "skin", 3, false, true, true, false, { "skin", 3, false, true, true, false,
nullptr, &nsChromeRegistry::ManifestSkin, nullptr }, nullptr, &nsChromeRegistry::ManifestSkin },
{ "overlay", 2, true, true, false, false, { "overlay", 2, true, true, false, false,
nullptr, &nsChromeRegistry::ManifestOverlay, nullptr }, nullptr, &nsChromeRegistry::ManifestOverlay },
{ "style", 2, false, true, false, false, { "style", 2, false, true, false, false,
nullptr, &nsChromeRegistry::ManifestStyle, nullptr }, nullptr, &nsChromeRegistry::ManifestStyle },
{ "override", 2, true, true, true, false, { "override", 2, true, true, true, false,
nullptr, &nsChromeRegistry::ManifestOverride, nullptr }, nullptr, &nsChromeRegistry::ManifestOverride },
{ "resource", 2, true, true, false, false, { "resource", 2, true, true, false, false,
nullptr, &nsChromeRegistry::ManifestResource, nullptr } nullptr, &nsChromeRegistry::ManifestResource }
}; };
static const char kWhitespace[] = "\t "; static const char kWhitespace[] = "\t ";
@ -145,16 +126,8 @@ struct AutoPR_smprintf_free
} // anonymous namespace } // 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, ...) void LogMessage(const char* aMsg, ...)
{ {
if (!nsComponentManagerImpl::gComponentManager) {
return;
}
nsCOMPtr<nsIConsoleService> console = nsCOMPtr<nsIConsoleService> console =
do_GetService(NS_CONSOLESERVICE_CONTRACTID); do_GetService(NS_CONSOLESERVICE_CONTRACTID);
if (!console) if (!console)
@ -170,10 +143,6 @@ void LogMessage(const char* aMsg, ...)
console->LogMessage(error); 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, void LogMessageWithContext(FileLocation &aFile,
uint32_t aLineNumber, const char* aMsg, ...) uint32_t aLineNumber, const char* aMsg, ...)
{ {
@ -184,10 +153,6 @@ void LogMessageWithContext(FileLocation &aFile,
if (!formatted) if (!formatted)
return; return;
if (!nsComponentManagerImpl::gComponentManager) {
return;
}
nsCString file; nsCString file;
aFile.GetURIString(file); aFile.GetURIString(file);
@ -423,23 +388,11 @@ struct CachedDirective
} // anonymous namespace } // 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 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); nsComponentManagerImpl::ManifestProcessingContext mgrcx(type, file, aChromeOnly);
nsChromeRegistry::ManifestProcessingContext chromecx(type, file); nsChromeRegistry::ManifestProcessingContext chromecx(type, file);
#ifdef MOZ_B2G_LOADER
nsComponentManagerImpl::XPTOnlyManifestProcessingContext xptonlycx(file);
#endif
nsresult rv; nsresult rv;
NS_NAMED_LITERAL_STRING(kPlatform, "platform"); NS_NAMED_LITERAL_STRING(kPlatform, "platform");
@ -463,12 +416,7 @@ ParseManifest(NSLocationType type, FileLocation &file, char* buf, bool aChromeOn
nsAutoString osTarget; nsAutoString osTarget;
nsAutoString abi; nsAutoString abi;
nsCOMPtr<nsIXULAppInfo> xapp; nsCOMPtr<nsIXULAppInfo> xapp (do_GetService(XULAPPINFO_SERVICE_CONTRACTID));
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);
}
if (xapp) { if (xapp) {
nsAutoCString s; nsAutoCString s;
rv = xapp->GetID(s); rv = xapp->GetID(s);
@ -568,10 +516,9 @@ ParseManifest(NSLocationType type, FileLocation &file, char* buf, bool aChromeOn
for (const ManifestDirective* d = kParsingTable; for (const ManifestDirective* d = kParsingTable;
d < ArrayEnd(kParsingTable); d < ArrayEnd(kParsingTable);
++d) { ++d) {
if (!strcmp(d->directive, token) && if (!strcmp(d->directive, token)) {
(!aXPTOnly || d->xptonlyfunc)) { directive = d;
directive = d; break;
break;
} }
} }
@ -630,9 +577,8 @@ ParseManifest(NSLocationType type, FileLocation &file, char* buf, bool aChromeOn
CheckStringFlag(kABI, wtoken, abi, stABI) || CheckStringFlag(kABI, wtoken, abi, stABI) ||
CheckVersionFlag(kOsVersion, wtoken, osVersion, stOsVersion) || CheckVersionFlag(kOsVersion, wtoken, osVersion, stOsVersion) ||
CheckVersionFlag(kAppVersion, wtoken, appVersion, stAppVersion) || CheckVersionFlag(kAppVersion, wtoken, appVersion, stAppVersion) ||
CheckVersionFlag(kGeckoVersion, wtoken, geckoVersion, stGeckoVersion)) { CheckVersionFlag(kGeckoVersion, wtoken, geckoVersion, stGeckoVersion))
continue; continue;
}
#if defined(MOZ_WIDGET_ANDROID) #if defined(MOZ_WIDGET_ANDROID)
bool tablet = false; bool tablet = false;
@ -673,11 +619,6 @@ ParseManifest(NSLocationType type, FileLocation &file, char* buf, bool aChromeOn
stABI == eBad) stABI == eBad)
continue; continue;
#ifdef MOZ_B2G_LOADER
if (aXPTOnly) {
directive->xptonlyfunc(xptonlycx, line, argv);
} else
#endif /* MOZ_B2G_LOADER */
if (directive->regfunc) { if (directive->regfunc) {
if (GeckoProcessType_Default != XRE_GetProcessType()) if (GeckoProcessType_Default != XRE_GetProcessType())
continue; continue;
@ -695,7 +636,7 @@ ParseManifest(NSLocationType type, FileLocation &file, char* buf, bool aChromeOn
(nsChromeRegistry::gChromeRegistry->*(directive->regfunc)) (nsChromeRegistry::gChromeRegistry->*(directive->regfunc))
(chromecx, line, argv, platform, contentAccessible); (chromecx, line, argv, platform, contentAccessible);
} }
else if (directive->mgrfunc && (directive->ischrome || !aChromeOnly)) { else if (directive->ischrome || !aChromeOnly) {
if (directive->isContract) { if (directive->isContract) {
CachedDirective* cd = contracts.AppendElement(); CachedDirective* cd = contracts.AppendElement();
cd->lineno = line; cd->lineno = line;
@ -705,9 +646,6 @@ ParseManifest(NSLocationType type, FileLocation &file, char* buf, bool aChromeOn
else else
(nsComponentManagerImpl::gComponentManager->*(directive->mgrfunc)) (nsComponentManagerImpl::gComponentManager->*(directive->mgrfunc))
(mgrcx, line, argv); (mgrcx, line, argv);
} else {
LogMessageWithContext(file, line,
"No valid manifest directive.");
} }
} }

2
xpcom/components/ManifestParser.h
View File

@ -13,7 +13,7 @@
class nsIFile; class nsIFile;
void ParseManifest(NSLocationType type, mozilla::FileLocation &file, void ParseManifest(NSLocationType type, mozilla::FileLocation &file,
char* buf, bool aChromeOnly, bool aXPTOnly=false); char* buf, bool aChromeOnly);
void LogMessage(const char* aMsg, ...); void LogMessage(const char* aMsg, ...);

129
xpcom/components/nsComponentManager.cpp
View File

@ -69,7 +69,6 @@
#include "nsStringEnumerator.h" #include "nsStringEnumerator.h"
#include "mozilla/FileUtils.h" #include "mozilla/FileUtils.h"
#include "nsNetUtil.h" #include "nsNetUtil.h"
#include "nsDataHashtable.h"
#include <new> // for placement new #include <new> // for placement new
@ -105,36 +104,6 @@ NS_DEFINE_CID(kCategoryManagerCID, NS_CATEGORYMANAGER_CID);
#define UID_STRING_LENGTH 39 #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 nsresult
nsGetServiceFromCategory::operator()(const nsIID& aIID, void** aInstancePtr) const nsGetServiceFromCategory::operator()(const nsIID& aIID, void** aInstancePtr) const
{ {
@ -555,14 +524,11 @@ CutExtension(nsCString& path)
path.Cut(0, dotPos + 1); path.Cut(0, dotPos + 1);
} }
static void void
DoRegisterManifest(NSLocationType aType, nsComponentManagerImpl::RegisterManifest(NSLocationType aType,
FileLocation &aFile, FileLocation &aFile,
bool aChromeOnly, bool aChromeOnly)
bool aXPTOnly)
{ {
MOZ_ASSERT(!aXPTOnly ||
nsComponentManagerImpl::gComponentManager == nullptr);
uint32_t len; uint32_t len;
FileLocation::Data data; FileLocation::Data data;
nsAutoArrayPtr<char> buf; nsAutoArrayPtr<char> buf;
@ -576,7 +542,7 @@ DoRegisterManifest(NSLocationType aType,
} }
if (NS_SUCCEEDED(rv)) { if (NS_SUCCEEDED(rv)) {
buf[len] = '\0'; buf[len] = '\0';
ParseManifest(aType, aFile, buf, aChromeOnly, aXPTOnly); ParseManifest(aType, aFile, buf, aChromeOnly);
} else if (NS_BOOTSTRAPPED_LOCATION != aType) { } else if (NS_BOOTSTRAPPED_LOCATION != aType) {
nsCString uri; nsCString uri;
aFile.GetURIString(uri); aFile.GetURIString(uri);
@ -584,14 +550,6 @@ DoRegisterManifest(NSLocationType aType,
} }
} }
void
nsComponentManagerImpl::RegisterManifest(NSLocationType aType,
FileLocation &aFile,
bool aChromeOnly)
{
DoRegisterManifest(aType, aFile, aChromeOnly, false);
}
void void
nsComponentManagerImpl::ManifestManifest(ManifestProcessingContext& cx, int lineno, char *const * argv) nsComponentManagerImpl::ManifestManifest(ManifestProcessingContext& cx, int lineno, char *const * argv)
{ {
@ -629,19 +587,14 @@ nsComponentManagerImpl::ManifestBinaryComponent(ManifestProcessingContext& cx, i
RegisterModule(m, &f); RegisterModule(m, &f);
} }
static void void
DoRegisterXPT(FileLocation &aFile) nsComponentManagerImpl::ManifestXPT(ManifestProcessingContext& cx, int lineno, char *const * argv)
{ {
#ifdef MOZ_B2G_LOADER FileLocation f(cx.mFile, argv[0]);
if (IsRegisteredXPTIInfo(aFile)) {
return;
}
#endif
uint32_t len; uint32_t len;
FileLocation::Data data; FileLocation::Data data;
nsAutoArrayPtr<char> buf; nsAutoArrayPtr<char> buf;
nsresult rv = aFile.GetData(data); nsresult rv = f.GetData(data);
if (NS_SUCCEEDED(rv)) { if (NS_SUCCEEDED(rv)) {
rv = data.GetSize(&len); rv = data.GetSize(&len);
} }
@ -651,23 +604,13 @@ DoRegisterXPT(FileLocation &aFile)
} }
if (NS_SUCCEEDED(rv)) { if (NS_SUCCEEDED(rv)) {
XPTInterfaceInfoManager::GetSingleton()->RegisterBuffer(buf, len); XPTInterfaceInfoManager::GetSingleton()->RegisterBuffer(buf, len);
#ifdef MOZ_B2G_LOADER
MarkRegisteredXPTIInfo(aFile);
#endif
} else { } else {
nsCString uri; nsCString uri;
aFile.GetURIString(uri); f.GetURIString(uri);
LogMessage("Could not read '%s'.", uri.get()); 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 void
nsComponentManagerImpl::ManifestComponent(ManifestProcessingContext& cx, int lineno, char *const * argv) nsComponentManagerImpl::ManifestComponent(ManifestProcessingContext& cx, int lineno, char *const * argv)
{ {
@ -851,10 +794,6 @@ nsresult nsComponentManagerImpl::Shutdown(void)
delete sStaticModules; delete sStaticModules;
delete sModuleLocations; delete sModuleLocations;
#ifdef MOZ_B2G_LOADER
delete sXPTIInfosBook;
sXPTIInfosBook = nullptr;
#endif
// Unload libraries // Unload libraries
mNativeModuleLoader.UnloadLibraries(); mNativeModuleLoader.UnloadLibraries();
@ -2003,54 +1942,6 @@ nsComponentManagerImpl::GetManifestLocations(nsIArray **aLocations)
return NS_OK; 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) EXPORT_XPCOM_API(nsresult)
XRE_AddManifestLocation(NSLocationType aType, nsIFile* aLocation) XRE_AddManifestLocation(NSLocationType aType, nsIFile* aLocation)
{ {

28
xpcom/components/nsComponentManager.h
View File

@ -38,10 +38,6 @@
#include "mozilla/Omnijar.h" #include "mozilla/Omnijar.h"
#include "mozilla/Attributes.h" #include "mozilla/Attributes.h"
#ifdef MOZ_B2G_LOADER
#include "mozilla/FileLocation.h"
#endif
struct nsFactoryEntry; struct nsFactoryEntry;
class nsIServiceManager; class nsIServiceManager;
struct PRThread; struct PRThread;
@ -320,30 +316,6 @@ public:
size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf); 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: private:
~nsComponentManagerImpl(); ~nsComponentManagerImpl();
}; };

56
xpcom/threads/BackgroundHangMonitor.cpp
View File

@ -65,7 +65,6 @@ private:
public: public:
NS_INLINE_DECL_THREADSAFE_REFCOUNTING(BackgroundHangManager) NS_INLINE_DECL_THREADSAFE_REFCOUNTING(BackgroundHangManager)
static StaticRefPtr<BackgroundHangManager> sInstance; static StaticRefPtr<BackgroundHangManager> sInstance;
static bool sProhibited;
// Lock for access to members of this class // Lock for access to members of this class
Monitor mLock; Monitor mLock;
@ -163,7 +162,6 @@ public:
StaticRefPtr<BackgroundHangManager> BackgroundHangManager::sInstance; StaticRefPtr<BackgroundHangManager> BackgroundHangManager::sInstance;
bool BackgroundHangManager::sProhibited = false;
ThreadLocal<BackgroundHangThread*> BackgroundHangThread::sTlsKey; ThreadLocal<BackgroundHangThread*> BackgroundHangThread::sTlsKey;
@ -411,16 +409,8 @@ BackgroundHangThread*
BackgroundHangThread::FindThread() BackgroundHangThread::FindThread()
{ {
#ifdef MOZ_ENABLE_BACKGROUND_HANG_MONITOR #ifdef MOZ_ENABLE_BACKGROUND_HANG_MONITOR
if (BackgroundHangManager::sInstance == nullptr) {
MOZ_ASSERT(BackgroundHangManager::sProhibited,
"BackgroundHandleManager is not initialized");
return nullptr;
}
if (sTlsKey.initialized()) { if (sTlsKey.initialized()) {
// Use TLS if available // Use TLS if available
MOZ_ASSERT(!BackgroundHangManager::sProhibited,
"BackgroundHandleManager is not initialized");
return sTlsKey.get(); return sTlsKey.get();
} }
// If TLS is unavailable, we can search through the thread list // If TLS is unavailable, we can search through the thread list
@ -446,7 +436,6 @@ void
BackgroundHangMonitor::Startup() BackgroundHangMonitor::Startup()
{ {
#ifdef MOZ_ENABLE_BACKGROUND_HANG_MONITOR #ifdef MOZ_ENABLE_BACKGROUND_HANG_MONITOR
MOZ_ASSERT(!BackgroundHangManager::sProhibited, "Prohibited");
MOZ_ASSERT(!BackgroundHangManager::sInstance, "Already initialized"); MOZ_ASSERT(!BackgroundHangManager::sInstance, "Already initialized");
ThreadStackHelper::Startup(); ThreadStackHelper::Startup();
BackgroundHangThread::Startup(); BackgroundHangThread::Startup();
@ -458,7 +447,6 @@ void
BackgroundHangMonitor::Shutdown() BackgroundHangMonitor::Shutdown()
{ {
#ifdef MOZ_ENABLE_BACKGROUND_HANG_MONITOR #ifdef MOZ_ENABLE_BACKGROUND_HANG_MONITOR
MOZ_ASSERT(!BackgroundHangManager::sProhibited, "Prohibited");
MOZ_ASSERT(BackgroundHangManager::sInstance, "Not initialized"); MOZ_ASSERT(BackgroundHangManager::sInstance, "Not initialized");
/* Scope our lock inside Shutdown() because the sInstance object can /* Scope our lock inside Shutdown() because the sInstance object can
be destroyed as soon as we set sInstance to nullptr below, and be destroyed as soon as we set sInstance to nullptr below, and
@ -475,8 +463,7 @@ BackgroundHangMonitor::BackgroundHangMonitor(const char* aName,
: mThread(BackgroundHangThread::FindThread()) : mThread(BackgroundHangThread::FindThread())
{ {
#ifdef MOZ_ENABLE_BACKGROUND_HANG_MONITOR #ifdef MOZ_ENABLE_BACKGROUND_HANG_MONITOR
if (!BackgroundHangManager::sProhibited && !mThread) { if (!mThread) {
// If sProhibit is true, mThread would be null, and no monitoring.
mThread = new BackgroundHangThread(aName, aTimeoutMs, aMaxTimeoutMs); mThread = new BackgroundHangThread(aName, aTimeoutMs, aMaxTimeoutMs);
} }
#endif #endif
@ -486,8 +473,7 @@ BackgroundHangMonitor::BackgroundHangMonitor()
: mThread(BackgroundHangThread::FindThread()) : mThread(BackgroundHangThread::FindThread())
{ {
#ifdef MOZ_ENABLE_BACKGROUND_HANG_MONITOR #ifdef MOZ_ENABLE_BACKGROUND_HANG_MONITOR
MOZ_ASSERT(!BackgroundHangManager::sProhibited || mThread, MOZ_ASSERT(mThread, "Thread not initialized for hang monitoring");
"This thread is not initialized for hang monitoring");
#endif #endif
} }
@ -499,11 +485,6 @@ void
BackgroundHangMonitor::NotifyActivity() BackgroundHangMonitor::NotifyActivity()
{ {
#ifdef MOZ_ENABLE_BACKGROUND_HANG_MONITOR #ifdef MOZ_ENABLE_BACKGROUND_HANG_MONITOR
if (mThread == nullptr) {
MOZ_ASSERT(BackgroundHangManager::sProhibited,
"This thread is not initialized for hang monitoring");
return;
}
mThread->NotifyActivity(); mThread->NotifyActivity();
#endif #endif
} }
@ -512,49 +493,18 @@ void
BackgroundHangMonitor::NotifyWait() BackgroundHangMonitor::NotifyWait()
{ {
#ifdef MOZ_ENABLE_BACKGROUND_HANG_MONITOR #ifdef MOZ_ENABLE_BACKGROUND_HANG_MONITOR
if (mThread == nullptr) {
MOZ_ASSERT(BackgroundHangManager::sProhibited,
"This thread is not initialized for hang monitoring");
return;
}
mThread->NotifyWait(); mThread->NotifyWait();
#endif #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, /* Because we are iterating through the BackgroundHangThread linked list,
we need to take a lock. Using MonitorAutoLock as a base class makes we need to take a lock. Using MonitorAutoLock as a base class makes
sure all of that is taken care of for us. */ sure all of that is taken care of for us. */
BackgroundHangMonitor::ThreadHangStatsIterator::ThreadHangStatsIterator() BackgroundHangMonitor::ThreadHangStatsIterator::ThreadHangStatsIterator()
: MonitorAutoLock(BackgroundHangManager::sInstance->mLock) : MonitorAutoLock(BackgroundHangManager::sInstance->mLock)
, mThread(BackgroundHangManager::sInstance ? , mThread(BackgroundHangManager::sInstance->mHangThreads.getFirst())
BackgroundHangManager::sInstance->mHangThreads.getFirst() :
nullptr)
{ {
#ifdef MOZ_ENABLE_BACKGROUND_HANG_MONITOR
MOZ_ASSERT(BackgroundHangManager::sInstance || BackgroundHangManager::sProhibited,
"Inconsistent state");
#endif
} }
Telemetry::ThreadHangStats* Telemetry::ThreadHangStats*

23
xpcom/threads/BackgroundHangMonitor.h
View File

@ -107,8 +107,6 @@ class BackgroundHangThread;
* } * }
* } * }
* *
* Prohibit() and Allow() make the background hang monitor work safely
* before Startup().
*/ */
class BackgroundHangMonitor class BackgroundHangMonitor
{ {
@ -206,27 +204,6 @@ public:
* NotifyActivity when subsequently exiting the wait state. * NotifyActivity when subsequently exiting the wait state.
*/ */
void NotifyWait(); 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 } // namespace mozilla