4494 lines
128 KiB
C++
4494 lines
128 KiB
C++
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
#include "mozilla/dom/ContentParent.h"
|
|
#include "mozilla/dom/ContentChild.h"
|
|
#include "mozilla/ipc/GeckoChildProcessHost.h"
|
|
|
|
#include "mozilla/ArrayUtils.h"
|
|
#include "mozilla/Attributes.h"
|
|
#include "mozilla/FilePreferences.h"
|
|
#include "mozilla/ChaosMode.h"
|
|
#include "mozilla/IOInterposer.h"
|
|
#include "mozilla/Likely.h"
|
|
#include "mozilla/MemoryChecking.h"
|
|
#include "mozilla/Poison.h"
|
|
#include "mozilla/Preferences.h"
|
|
#include "mozilla/ScopeExit.h"
|
|
#include "mozilla/Services.h"
|
|
#include "mozilla/ServoBindings.h"
|
|
#include "mozilla/Telemetry.h"
|
|
|
|
#include "nsAppRunner.h"
|
|
#include "mozilla/AppData.h"
|
|
#if defined(MOZ_UPDATER) && !defined(MOZ_WIDGET_ANDROID)
|
|
#include "nsUpdateDriver.h"
|
|
#endif
|
|
#include "ProfileReset.h"
|
|
|
|
#ifdef MOZ_INSTRUMENT_EVENT_LOOP
|
|
#include "EventTracer.h"
|
|
#endif
|
|
|
|
#ifdef XP_MACOSX
|
|
#include "nsVersionComparator.h"
|
|
#include "MacLaunchHelper.h"
|
|
#include "MacApplicationDelegate.h"
|
|
#include "MacAutoreleasePool.h"
|
|
// these are needed for sysctl
|
|
#include <sys/types.h>
|
|
#include <sys/sysctl.h>
|
|
#endif
|
|
|
|
#include "prmem.h"
|
|
#include "prnetdb.h"
|
|
#include "prprf.h"
|
|
#include "prproces.h"
|
|
#include "prenv.h"
|
|
#include "prtime.h"
|
|
|
|
#include "nsIAppShellService.h"
|
|
#include "nsIAppStartup.h"
|
|
#include "nsIAppStartupNotifier.h"
|
|
#include "nsIMutableArray.h"
|
|
#include "nsICategoryManager.h"
|
|
#include "nsIChromeRegistry.h"
|
|
#include "nsICommandLineRunner.h"
|
|
#include "nsIComponentManager.h"
|
|
#include "nsIComponentRegistrar.h"
|
|
#include "nsIConsoleService.h"
|
|
#include "nsIContentHandler.h"
|
|
#include "nsIDialogParamBlock.h"
|
|
#include "nsIDOMWindow.h"
|
|
#include "mozilla/ModuleUtils.h"
|
|
#include "nsIIOService2.h"
|
|
#include "nsIObserverService.h"
|
|
#include "nsINativeAppSupport.h"
|
|
#include "nsIPlatformInfo.h"
|
|
#include "nsIProcess.h"
|
|
#include "nsIProfileUnlocker.h"
|
|
#include "nsIPromptService.h"
|
|
#include "nsIServiceManager.h"
|
|
#include "nsIStringBundle.h"
|
|
#include "nsISupportsPrimitives.h"
|
|
#include "nsIToolkitChromeRegistry.h"
|
|
#include "nsIToolkitProfile.h"
|
|
#include "nsIToolkitProfileService.h"
|
|
#include "nsIURI.h"
|
|
#include "nsIURL.h"
|
|
#include "nsIWindowCreator.h"
|
|
#include "nsIWindowMediator.h"
|
|
#include "nsIWindowWatcher.h"
|
|
#include "nsIXULAppInfo.h"
|
|
#include "nsIXULRuntime.h"
|
|
#include "nsPIDOMWindow.h"
|
|
#include "nsIBaseWindow.h"
|
|
#include "nsIWidget.h"
|
|
#include "nsIDocShell.h"
|
|
#include "nsAppShellCID.h"
|
|
#include "mozilla/scache/StartupCache.h"
|
|
#include "gfxPrefs.h"
|
|
|
|
#include "mozilla/Unused.h"
|
|
|
|
#ifdef XP_WIN
|
|
#include "nsIWinAppHelper.h"
|
|
#include <windows.h>
|
|
#include <intrin.h>
|
|
#include <math.h>
|
|
#include "cairo/cairo-features.h"
|
|
#include "mozilla/WindowsVersion.h"
|
|
#include "mozilla/mscom/MainThreadRuntime.h"
|
|
#include "mozilla/widget/AudioSession.h"
|
|
|
|
#ifndef PROCESS_DEP_ENABLE
|
|
#define PROCESS_DEP_ENABLE 0x1
|
|
#endif
|
|
#endif
|
|
|
|
#ifdef ACCESSIBILITY
|
|
#include "nsAccessibilityService.h"
|
|
#if defined(XP_WIN)
|
|
#include "mozilla/a11y/Compatibility.h"
|
|
#endif
|
|
#endif
|
|
|
|
#include "nsCRT.h"
|
|
#include "nsCOMPtr.h"
|
|
#include "nsDirectoryServiceDefs.h"
|
|
#include "nsDirectoryServiceUtils.h"
|
|
#include "nsEmbedCID.h"
|
|
#include "nsNetUtil.h"
|
|
#include "nsReadableUtils.h"
|
|
#include "nsXPCOM.h"
|
|
#include "nsXPCOMCIDInternal.h"
|
|
#include "nsXPIDLString.h"
|
|
#include "nsPrintfCString.h"
|
|
#include "nsVersionComparator.h"
|
|
|
|
#include "nsAppDirectoryServiceDefs.h"
|
|
#include "nsXULAppAPI.h"
|
|
#include "nsXREDirProvider.h"
|
|
#include "nsToolkitCompsCID.h"
|
|
|
|
#include "nsINIParser.h"
|
|
#include "mozilla/Omnijar.h"
|
|
#include "mozilla/StartupTimeline.h"
|
|
#include "mozilla/LateWriteChecks.h"
|
|
|
|
#include <stdlib.h>
|
|
#include <locale.h>
|
|
|
|
#ifdef XP_UNIX
|
|
#include <sys/stat.h>
|
|
#include <unistd.h>
|
|
#include <pwd.h>
|
|
#endif
|
|
|
|
#ifdef XP_WIN
|
|
#include <process.h>
|
|
#include <shlobj.h>
|
|
#include "nsThreadUtils.h"
|
|
#include <comdef.h>
|
|
#include <wbemidl.h>
|
|
#include "WinUtils.h"
|
|
#endif
|
|
|
|
#ifdef XP_MACOSX
|
|
#include "nsILocalFileMac.h"
|
|
#include "nsCommandLineServiceMac.h"
|
|
#endif
|
|
|
|
// for X remote support
|
|
#ifdef MOZ_ENABLE_XREMOTE
|
|
#include "XRemoteClient.h"
|
|
#include "nsIRemoteService.h"
|
|
#include "nsProfileLock.h"
|
|
#include "SpecialSystemDirectory.h"
|
|
#include <sched.h>
|
|
// Time to wait for the remoting service to start
|
|
#define MOZ_XREMOTE_START_TIMEOUT_SEC 5
|
|
#endif
|
|
|
|
#if defined(DEBUG) && defined(XP_WIN32)
|
|
#include <malloc.h>
|
|
#endif
|
|
|
|
#if defined (XP_MACOSX)
|
|
#include <Carbon/Carbon.h>
|
|
#endif
|
|
|
|
#ifdef DEBUG
|
|
#include "mozilla/Logging.h"
|
|
#endif
|
|
|
|
#include "base/command_line.h"
|
|
#include "GTestRunner.h"
|
|
|
|
#ifdef MOZ_WIDGET_ANDROID
|
|
#include "GeneratedJNIWrappers.h"
|
|
#endif
|
|
|
|
extern uint32_t gRestartMode;
|
|
extern void InstallSignalHandlers(const char *ProgramName);
|
|
|
|
#define FILE_COMPATIBILITY_INFO NS_LITERAL_CSTRING("compatibility.ini")
|
|
#define FILE_INVALIDATE_CACHES NS_LITERAL_CSTRING(".purgecaches")
|
|
|
|
int gArgc;
|
|
char **gArgv;
|
|
|
|
static const char gToolkitVersion[] = NS_STRINGIFY(GRE_MILESTONE);
|
|
static const char gToolkitBuildID[] = NS_STRINGIFY(MOZ_BUILDID);
|
|
|
|
static nsIProfileLock* gProfileLock;
|
|
|
|
int gRestartArgc;
|
|
char **gRestartArgv;
|
|
|
|
bool gIsGtest = false;
|
|
|
|
nsString gAbsoluteArgv0Path;
|
|
|
|
#if defined(MOZ_WIDGET_GTK)
|
|
#include <glib.h>
|
|
#if defined(DEBUG) || defined(NS_BUILD_REFCNT_LOGGING)
|
|
#define CLEANUP_MEMORY 1
|
|
#define PANGO_ENABLE_BACKEND
|
|
#include <pango/pangofc-fontmap.h>
|
|
#endif
|
|
#include <gtk/gtk.h>
|
|
#ifdef MOZ_X11
|
|
#include <gdk/gdkx.h>
|
|
#endif /* MOZ_X11 */
|
|
#include "nsGTKToolkit.h"
|
|
#include <fontconfig/fontconfig.h>
|
|
#endif
|
|
#include "BinaryPath.h"
|
|
#ifndef MOZ_BUILDID
|
|
// See comment in Makefile.in why we want to avoid including buildid.h.
|
|
// Still include it when MOZ_BUILDID is not set, which can happen with some
|
|
// build backends.
|
|
#include "buildid.h"
|
|
#endif
|
|
|
|
#ifdef MOZ_LINKER
|
|
extern "C" MFBT_API bool IsSignalHandlingBroken();
|
|
#endif
|
|
|
|
#ifdef LIBFUZZER
|
|
#include "LibFuzzerRunner.h"
|
|
|
|
namespace mozilla {
|
|
LibFuzzerRunner* libFuzzerRunner = 0;
|
|
} // namespace mozilla
|
|
|
|
extern "C" MOZ_EXPORT void XRE_LibFuzzerSetMain(int argc, char** argv, LibFuzzerMain main) {
|
|
mozilla::libFuzzerRunner->setParams(argc, argv, main);
|
|
}
|
|
#endif
|
|
|
|
namespace mozilla {
|
|
int (*RunGTest)() = 0;
|
|
} // namespace mozilla
|
|
|
|
using namespace mozilla;
|
|
using mozilla::Unused;
|
|
using mozilla::scache::StartupCache;
|
|
using mozilla::dom::ContentParent;
|
|
using mozilla::dom::ContentChild;
|
|
|
|
// Save literal putenv string to environment variable.
|
|
static void
|
|
SaveToEnv(const char *putenv)
|
|
{
|
|
char *expr = strdup(putenv);
|
|
if (expr)
|
|
PR_SetEnv(expr);
|
|
// We intentionally leak |expr| here since it is required by PR_SetEnv.
|
|
MOZ_LSAN_INTENTIONALLY_LEAK_OBJECT(expr);
|
|
}
|
|
|
|
// Tests that an environment variable exists and has a value
|
|
static bool
|
|
EnvHasValue(const char *name)
|
|
{
|
|
const char *val = PR_GetEnv(name);
|
|
return (val && *val);
|
|
}
|
|
|
|
// Save the given word to the specified environment variable.
|
|
static void
|
|
SaveWordToEnv(const char *name, const nsACString & word)
|
|
{
|
|
char *expr = PR_smprintf("%s=%s", name, PromiseFlatCString(word).get());
|
|
if (expr)
|
|
PR_SetEnv(expr);
|
|
// We intentionally leak |expr| here since it is required by PR_SetEnv.
|
|
}
|
|
|
|
// Save the path of the given file to the specified environment variable.
|
|
static void
|
|
SaveFileToEnv(const char *name, nsIFile *file)
|
|
{
|
|
#ifdef XP_WIN
|
|
nsAutoString path;
|
|
file->GetPath(path);
|
|
SetEnvironmentVariableW(NS_ConvertASCIItoUTF16(name).get(), path.get());
|
|
#else
|
|
nsAutoCString path;
|
|
file->GetNativePath(path);
|
|
SaveWordToEnv(name, path);
|
|
#endif
|
|
}
|
|
|
|
// Load the path of a file saved with SaveFileToEnv
|
|
static already_AddRefed<nsIFile>
|
|
GetFileFromEnv(const char *name)
|
|
{
|
|
nsresult rv;
|
|
nsCOMPtr<nsIFile> file;
|
|
|
|
#ifdef XP_WIN
|
|
WCHAR path[_MAX_PATH];
|
|
if (!GetEnvironmentVariableW(NS_ConvertASCIItoUTF16(name).get(),
|
|
path, _MAX_PATH))
|
|
return nullptr;
|
|
|
|
rv = NS_NewLocalFile(nsDependentString(path), true, getter_AddRefs(file));
|
|
if (NS_FAILED(rv))
|
|
return nullptr;
|
|
|
|
return file.forget();
|
|
#else
|
|
const char *arg = PR_GetEnv(name);
|
|
if (!arg || !*arg)
|
|
return nullptr;
|
|
|
|
rv = NS_NewNativeLocalFile(nsDependentCString(arg), true,
|
|
getter_AddRefs(file));
|
|
if (NS_FAILED(rv))
|
|
return nullptr;
|
|
|
|
return file.forget();
|
|
#endif
|
|
}
|
|
|
|
// Save the path of the given word to the specified environment variable
|
|
// provided the environment variable does not have a value.
|
|
static void
|
|
SaveWordToEnvIfUnset(const char *name, const nsACString & word)
|
|
{
|
|
if (!EnvHasValue(name))
|
|
SaveWordToEnv(name, word);
|
|
}
|
|
|
|
// Save the path of the given file to the specified environment variable
|
|
// provided the environment variable does not have a value.
|
|
static void
|
|
SaveFileToEnvIfUnset(const char *name, nsIFile *file)
|
|
{
|
|
if (!EnvHasValue(name))
|
|
SaveFileToEnv(name, file);
|
|
}
|
|
|
|
static bool
|
|
strimatch(const char* lowerstr, const char* mixedstr)
|
|
{
|
|
while(*lowerstr) {
|
|
if (!*mixedstr) return false; // mixedstr is shorter
|
|
if (tolower(*mixedstr) != *lowerstr) return false; // no match
|
|
|
|
++lowerstr;
|
|
++mixedstr;
|
|
}
|
|
|
|
if (*mixedstr) return false; // lowerstr is shorter
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool gIsExpectedExit = false;
|
|
|
|
void MozExpectedExit() {
|
|
gIsExpectedExit = true;
|
|
}
|
|
|
|
/**
|
|
* Runs atexit() to catch unexpected exit from 3rd party libraries like the
|
|
* Intel graphics driver calling exit in an error condition. When they
|
|
* call exit() to report an error we won't shutdown correctly and wont catch
|
|
* the issue with our crash reporter.
|
|
*/
|
|
static void UnexpectedExit() {
|
|
if (!gIsExpectedExit) {
|
|
gIsExpectedExit = true; // Don't risk re-entrency issues when crashing.
|
|
MOZ_CRASH("Exit called by third party code.");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Output a string to the user. This method is really only meant to be used to
|
|
* output last-ditch error messages designed for developers NOT END USERS.
|
|
*
|
|
* @param isError
|
|
* Pass true to indicate severe errors.
|
|
* @param fmt
|
|
* printf-style format string followed by arguments.
|
|
*/
|
|
static void Output(bool isError, const char *fmt, ... )
|
|
{
|
|
va_list ap;
|
|
va_start(ap, fmt);
|
|
|
|
#if defined(XP_WIN) && !MOZ_WINCONSOLE
|
|
char *msg = PR_vsmprintf(fmt, ap);
|
|
if (msg)
|
|
{
|
|
UINT flags = MB_OK;
|
|
if (isError)
|
|
flags |= MB_ICONERROR;
|
|
else
|
|
flags |= MB_ICONINFORMATION;
|
|
|
|
wchar_t wide_msg[1024];
|
|
MultiByteToWideChar(CP_ACP,
|
|
0,
|
|
msg,
|
|
-1,
|
|
wide_msg,
|
|
sizeof(wide_msg) / sizeof(wchar_t));
|
|
|
|
MessageBoxW(nullptr, wide_msg, L"XULRunner", flags);
|
|
PR_smprintf_free(msg);
|
|
}
|
|
#else
|
|
vfprintf(stderr, fmt, ap);
|
|
#endif
|
|
|
|
va_end(ap);
|
|
}
|
|
|
|
enum RemoteResult {
|
|
REMOTE_NOT_FOUND = 0,
|
|
REMOTE_FOUND = 1,
|
|
REMOTE_ARG_BAD = 2
|
|
};
|
|
|
|
enum ArgResult {
|
|
ARG_NONE = 0,
|
|
ARG_FOUND = 1,
|
|
ARG_BAD = 2 // you wanted a param, but there isn't one
|
|
};
|
|
|
|
static void RemoveArg(char **argv)
|
|
{
|
|
do {
|
|
*argv = *(argv + 1);
|
|
++argv;
|
|
} while (*argv);
|
|
|
|
--gArgc;
|
|
}
|
|
|
|
/**
|
|
* Check for a commandline flag. If the flag takes a parameter, the
|
|
* parameter is returned in aParam. Flags may be in the form -arg or
|
|
* --arg (or /arg on win32).
|
|
*
|
|
* @param aArg the parameter to check. Must be lowercase.
|
|
* @param aCheckOSInt if true returns ARG_BAD if the osint argument is present
|
|
* when aArg is also present.
|
|
* @param aParam if non-null, the -arg <data> will be stored in this pointer.
|
|
* This is *not* allocated, but rather a pointer to the argv data.
|
|
* @param aRemArg if true, the argument is removed from the gArgv array.
|
|
*/
|
|
static ArgResult
|
|
CheckArg(const char* aArg, bool aCheckOSInt = false, const char **aParam = nullptr, bool aRemArg = true)
|
|
{
|
|
MOZ_ASSERT(gArgv, "gArgv must be initialized before CheckArg()");
|
|
|
|
char **curarg = gArgv + 1; // skip argv[0]
|
|
ArgResult ar = ARG_NONE;
|
|
|
|
while (*curarg) {
|
|
char *arg = curarg[0];
|
|
|
|
if (arg[0] == '-'
|
|
#if defined(XP_WIN)
|
|
|| *arg == '/'
|
|
#endif
|
|
) {
|
|
++arg;
|
|
if (*arg == '-')
|
|
++arg;
|
|
|
|
if (strimatch(aArg, arg)) {
|
|
if (aRemArg)
|
|
RemoveArg(curarg);
|
|
else
|
|
++curarg;
|
|
if (!aParam) {
|
|
ar = ARG_FOUND;
|
|
break;
|
|
}
|
|
|
|
if (*curarg) {
|
|
if (**curarg == '-'
|
|
#if defined(XP_WIN)
|
|
|| **curarg == '/'
|
|
#endif
|
|
)
|
|
return ARG_BAD;
|
|
|
|
*aParam = *curarg;
|
|
if (aRemArg)
|
|
RemoveArg(curarg);
|
|
ar = ARG_FOUND;
|
|
break;
|
|
}
|
|
return ARG_BAD;
|
|
}
|
|
}
|
|
|
|
++curarg;
|
|
}
|
|
|
|
if (aCheckOSInt && ar == ARG_FOUND) {
|
|
ArgResult arOSInt = CheckArg("osint");
|
|
if (arOSInt == ARG_FOUND) {
|
|
ar = ARG_BAD;
|
|
PR_fprintf(PR_STDERR, "Error: argument --osint is invalid\n");
|
|
}
|
|
}
|
|
|
|
return ar;
|
|
}
|
|
|
|
#if defined(XP_WIN)
|
|
/**
|
|
* Check for a commandline flag from the windows shell and remove it from the
|
|
* argv used when restarting. Flags MUST be in the form -arg.
|
|
*
|
|
* @param aArg the parameter to check. Must be lowercase.
|
|
*/
|
|
static ArgResult
|
|
CheckArgShell(const char* aArg)
|
|
{
|
|
char **curarg = gRestartArgv + 1; // skip argv[0]
|
|
|
|
while (*curarg) {
|
|
char *arg = curarg[0];
|
|
|
|
if (arg[0] == '-') {
|
|
++arg;
|
|
|
|
if (strimatch(aArg, arg)) {
|
|
do {
|
|
*curarg = *(curarg + 1);
|
|
++curarg;
|
|
} while (*curarg);
|
|
|
|
--gRestartArgc;
|
|
|
|
return ARG_FOUND;
|
|
}
|
|
}
|
|
|
|
++curarg;
|
|
}
|
|
|
|
return ARG_NONE;
|
|
}
|
|
|
|
/**
|
|
* Enabled Native App Support to process DDE messages when the app needs to
|
|
* restart and the app has been launched by the Windows shell to open an url.
|
|
* When aWait is false this will process the DDE events manually. This prevents
|
|
* Windows from displaying an error message due to the DDE message not being
|
|
* acknowledged.
|
|
*/
|
|
static void
|
|
ProcessDDE(nsINativeAppSupport* aNative, bool aWait)
|
|
{
|
|
// When the app is launched by the windows shell the windows shell
|
|
// expects the app to be available for DDE messages and if it isn't
|
|
// windows displays an error dialog. To prevent the error the DDE server
|
|
// is enabled and pending events are processed when the app needs to
|
|
// restart after it was launched by the shell with the requestpending
|
|
// argument. The requestpending pending argument is removed to
|
|
// differentiate it from being launched when an app restart is not
|
|
// required.
|
|
ArgResult ar;
|
|
ar = CheckArgShell("requestpending");
|
|
if (ar == ARG_FOUND) {
|
|
aNative->Enable(); // enable win32 DDE responses
|
|
if (aWait) {
|
|
nsIThread *thread = NS_GetCurrentThread();
|
|
// This is just a guesstimate based on testing different values.
|
|
// If count is 8 or less windows will display an error dialog.
|
|
int32_t count = 20;
|
|
while(--count >= 0) {
|
|
NS_ProcessNextEvent(thread);
|
|
PR_Sleep(PR_MillisecondsToInterval(1));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
/**
|
|
* Determines if there is support for showing the profile manager
|
|
*
|
|
* @return true in all environments
|
|
*/
|
|
static bool
|
|
CanShowProfileManager()
|
|
{
|
|
return true;
|
|
}
|
|
|
|
bool gSafeMode = false;
|
|
|
|
/**
|
|
* The nsXULAppInfo object implements nsIFactory so that it can be its own
|
|
* singleton.
|
|
*/
|
|
class nsXULAppInfo : public nsIXULAppInfo,
|
|
public nsIObserver,
|
|
#ifdef XP_WIN
|
|
public nsIWinAppHelper,
|
|
#endif
|
|
public nsIXULRuntime
|
|
|
|
{
|
|
public:
|
|
constexpr nsXULAppInfo() {}
|
|
NS_DECL_ISUPPORTS_INHERITED
|
|
NS_DECL_NSIPLATFORMINFO
|
|
NS_DECL_NSIXULAPPINFO
|
|
NS_DECL_NSIXULRUNTIME
|
|
NS_DECL_NSIOBSERVER
|
|
#ifdef XP_WIN
|
|
NS_DECL_NSIWINAPPHELPER
|
|
#endif
|
|
};
|
|
|
|
NS_INTERFACE_MAP_BEGIN(nsXULAppInfo)
|
|
NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIXULRuntime)
|
|
NS_INTERFACE_MAP_ENTRY(nsIXULRuntime)
|
|
NS_INTERFACE_MAP_ENTRY(nsIObserver)
|
|
#ifdef XP_WIN
|
|
NS_INTERFACE_MAP_ENTRY(nsIWinAppHelper)
|
|
#endif
|
|
NS_INTERFACE_MAP_ENTRY(nsIPlatformInfo)
|
|
NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsIXULAppInfo, gAppData ||
|
|
XRE_IsContentProcess())
|
|
NS_INTERFACE_MAP_END
|
|
|
|
NS_IMETHODIMP_(MozExternalRefCountType)
|
|
nsXULAppInfo::AddRef()
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
NS_IMETHODIMP_(MozExternalRefCountType)
|
|
nsXULAppInfo::Release()
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsXULAppInfo::GetVendor(nsACString& aResult)
|
|
{
|
|
if (XRE_IsContentProcess()) {
|
|
ContentChild* cc = ContentChild::GetSingleton();
|
|
aResult = cc->GetAppInfo().vendor;
|
|
return NS_OK;
|
|
}
|
|
aResult.Assign(gAppData->vendor);
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsXULAppInfo::GetName(nsACString& aResult)
|
|
{
|
|
if (XRE_IsContentProcess()) {
|
|
ContentChild* cc = ContentChild::GetSingleton();
|
|
aResult = cc->GetAppInfo().name;
|
|
return NS_OK;
|
|
}
|
|
aResult.Assign(gAppData->name);
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsXULAppInfo::GetID(nsACString& aResult)
|
|
{
|
|
if (XRE_IsContentProcess()) {
|
|
ContentChild* cc = ContentChild::GetSingleton();
|
|
aResult = cc->GetAppInfo().ID;
|
|
return NS_OK;
|
|
}
|
|
aResult.Assign(gAppData->ID);
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsXULAppInfo::GetVersion(nsACString& aResult)
|
|
{
|
|
if (XRE_IsContentProcess()) {
|
|
ContentChild* cc = ContentChild::GetSingleton();
|
|
aResult = cc->GetAppInfo().version;
|
|
return NS_OK;
|
|
}
|
|
aResult.Assign(gAppData->version);
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsXULAppInfo::GetPlatformVersion(nsACString& aResult)
|
|
{
|
|
aResult.Assign(gToolkitVersion);
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsXULAppInfo::GetAppBuildID(nsACString& aResult)
|
|
{
|
|
if (XRE_IsContentProcess()) {
|
|
ContentChild* cc = ContentChild::GetSingleton();
|
|
aResult = cc->GetAppInfo().buildID;
|
|
return NS_OK;
|
|
}
|
|
aResult.Assign(gAppData->buildID);
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsXULAppInfo::GetPlatformBuildID(nsACString& aResult)
|
|
{
|
|
aResult.Assign(gToolkitBuildID);
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsXULAppInfo::GetUAName(nsACString& aResult)
|
|
{
|
|
if (XRE_IsContentProcess()) {
|
|
ContentChild* cc = ContentChild::GetSingleton();
|
|
aResult = cc->GetAppInfo().UAName;
|
|
return NS_OK;
|
|
}
|
|
aResult.Assign(gAppData->UAName);
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsXULAppInfo::GetLogConsoleErrors(bool *aResult)
|
|
{
|
|
*aResult = gLogConsoleErrors;
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsXULAppInfo::SetLogConsoleErrors(bool aValue)
|
|
{
|
|
gLogConsoleErrors = aValue;
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsXULAppInfo::GetInSafeMode(bool *aResult)
|
|
{
|
|
*aResult = gSafeMode;
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsXULAppInfo::GetOS(nsACString& aResult)
|
|
{
|
|
aResult.AssignLiteral(OS_TARGET);
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsXULAppInfo::GetXPCOMABI(nsACString& aResult)
|
|
{
|
|
#ifdef TARGET_XPCOM_ABI
|
|
aResult.AssignLiteral(TARGET_XPCOM_ABI);
|
|
return NS_OK;
|
|
#else
|
|
return NS_ERROR_NOT_AVAILABLE;
|
|
#endif
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsXULAppInfo::GetWidgetToolkit(nsACString& aResult)
|
|
{
|
|
aResult.AssignLiteral(MOZ_WIDGET_TOOLKIT);
|
|
return NS_OK;
|
|
}
|
|
|
|
// Ensure that the GeckoProcessType enum, defined in xpcom/build/nsXULAppAPI.h,
|
|
// is synchronized with the const unsigned longs defined in
|
|
// xpcom/system/nsIXULRuntime.idl.
|
|
#define SYNC_ENUMS(a,b) \
|
|
static_assert(nsIXULRuntime::PROCESS_TYPE_ ## a == \
|
|
static_cast<int>(GeckoProcessType_ ## b), \
|
|
"GeckoProcessType in nsXULAppAPI.h not synchronized with nsIXULRuntime.idl");
|
|
|
|
SYNC_ENUMS(DEFAULT, Default)
|
|
SYNC_ENUMS(PLUGIN, Plugin)
|
|
SYNC_ENUMS(CONTENT, Content)
|
|
SYNC_ENUMS(IPDLUNITTEST, IPDLUnitTest)
|
|
SYNC_ENUMS(GMPLUGIN, GMPlugin)
|
|
SYNC_ENUMS(GPU, GPU)
|
|
|
|
// .. and ensure that that is all of them:
|
|
static_assert(GeckoProcessType_GPU + 1 == GeckoProcessType_End,
|
|
"Did not find the final GeckoProcessType");
|
|
|
|
NS_IMETHODIMP
|
|
nsXULAppInfo::GetProcessType(uint32_t* aResult)
|
|
{
|
|
NS_ENSURE_ARG_POINTER(aResult);
|
|
*aResult = XRE_GetProcessType();
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsXULAppInfo::GetProcessID(uint32_t* aResult)
|
|
{
|
|
#ifdef XP_WIN
|
|
*aResult = GetCurrentProcessId();
|
|
#else
|
|
*aResult = getpid();
|
|
#endif
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsXULAppInfo::GetUniqueProcessID(uint64_t* aResult)
|
|
{
|
|
if (XRE_IsContentProcess()) {
|
|
ContentChild* cc = ContentChild::GetSingleton();
|
|
*aResult = cc->GetID();
|
|
} else {
|
|
*aResult = 0;
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
static bool gBrowserTabsRemoteAutostart = false;
|
|
static uint64_t gBrowserTabsRemoteStatus = 0;
|
|
static bool gBrowserTabsRemoteAutostartInitialized = false;
|
|
|
|
static bool gMultiprocessBlockPolicyInitialized = false;
|
|
static uint32_t gMultiprocessBlockPolicy = 0;
|
|
|
|
NS_IMETHODIMP
|
|
nsXULAppInfo::Observe(nsISupports *aSubject, const char *aTopic, const char16_t *aData) {
|
|
if (!nsCRT::strcmp(aTopic, "getE10SBlocked")) {
|
|
nsCOMPtr<nsISupportsPRUint64> ret = do_QueryInterface(aSubject);
|
|
if (!ret)
|
|
return NS_ERROR_FAILURE;
|
|
|
|
ret->SetData(gBrowserTabsRemoteStatus);
|
|
|
|
return NS_OK;
|
|
}
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsXULAppInfo::GetBrowserTabsRemoteAutostart(bool* aResult)
|
|
{
|
|
*aResult = BrowserTabsRemoteAutostart();
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsXULAppInfo::GetMultiprocessBlockPolicy(uint32_t* aResult)
|
|
{
|
|
*aResult = MultiprocessBlockPolicy();
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsXULAppInfo::GetAccessibilityEnabled(bool* aResult)
|
|
{
|
|
#ifdef ACCESSIBILITY
|
|
*aResult = GetAccService() != nullptr;
|
|
#else
|
|
*aResult = false;
|
|
#endif
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsXULAppInfo::GetIs64Bit(bool* aResult)
|
|
{
|
|
#ifdef HAVE_64BIT_BUILD
|
|
*aResult = true;
|
|
#else
|
|
*aResult = false;
|
|
#endif
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsXULAppInfo::EnsureContentProcess()
|
|
{
|
|
if (!XRE_IsParentProcess())
|
|
return NS_ERROR_NOT_AVAILABLE;
|
|
|
|
RefPtr<ContentParent> unused = ContentParent::GetNewOrUsedBrowserProcess();
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsXULAppInfo::InvalidateCachesOnRestart()
|
|
{
|
|
nsCOMPtr<nsIFile> file;
|
|
nsresult rv = NS_GetSpecialDirectory(NS_APP_PROFILE_DIR_STARTUP,
|
|
getter_AddRefs(file));
|
|
if (NS_FAILED(rv))
|
|
return rv;
|
|
if (!file)
|
|
return NS_ERROR_NOT_AVAILABLE;
|
|
|
|
file->AppendNative(FILE_COMPATIBILITY_INFO);
|
|
|
|
nsINIParser parser;
|
|
rv = parser.Init(file);
|
|
if (NS_FAILED(rv)) {
|
|
// This fails if compatibility.ini is not there, so we'll
|
|
// flush the caches on the next restart anyways.
|
|
return NS_OK;
|
|
}
|
|
|
|
nsAutoCString buf;
|
|
rv = parser.GetString("Compatibility", "InvalidateCaches", buf);
|
|
|
|
if (NS_FAILED(rv)) {
|
|
PRFileDesc *fd;
|
|
rv = file->OpenNSPRFileDesc(PR_RDWR | PR_APPEND, 0600, &fd);
|
|
if (NS_FAILED(rv)) {
|
|
NS_ERROR("could not create output stream");
|
|
return NS_ERROR_NOT_AVAILABLE;
|
|
}
|
|
static const char kInvalidationHeader[] = NS_LINEBREAK "InvalidateCaches=1" NS_LINEBREAK;
|
|
PR_Write(fd, kInvalidationHeader, sizeof(kInvalidationHeader) - 1);
|
|
PR_Close(fd);
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsXULAppInfo::GetReplacedLockTime(PRTime *aReplacedLockTime)
|
|
{
|
|
if (!gProfileLock)
|
|
return NS_ERROR_NOT_AVAILABLE;
|
|
gProfileLock->GetReplacedLockTime(aReplacedLockTime);
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsXULAppInfo::GetLastRunCrashID(nsAString &aLastRunCrashID)
|
|
{
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsXULAppInfo::GetIsReleaseOrBeta(bool* aResult)
|
|
{
|
|
#ifdef RELEASE_OR_BETA
|
|
*aResult = true;
|
|
#else
|
|
*aResult = false;
|
|
#endif
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsXULAppInfo::GetIsOfficialBranding(bool* aResult)
|
|
{
|
|
#ifdef MOZ_OFFICIAL_BRANDING
|
|
*aResult = true;
|
|
#else
|
|
*aResult = false;
|
|
#endif
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsXULAppInfo::GetDefaultUpdateChannel(nsACString& aResult)
|
|
{
|
|
aResult.AssignLiteral(NS_STRINGIFY(MOZ_UPDATE_CHANNEL));
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsXULAppInfo::GetDistributionID(nsACString& aResult)
|
|
{
|
|
aResult.AssignLiteral(MOZ_DISTRIBUTION_ID);
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsXULAppInfo::GetIsOfficial(bool* aResult)
|
|
{
|
|
#ifdef MC_OFFICIAL
|
|
*aResult = true;
|
|
#else
|
|
*aResult = false;
|
|
#endif
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsXULAppInfo::GetWindowsDLLBlocklistStatus(bool* aResult)
|
|
{
|
|
#if defined(XP_WIN)
|
|
*aResult = gAppData->flags & NS_XRE_DLL_BLOCKLIST_ENABLED;
|
|
#else
|
|
*aResult = false;
|
|
#endif
|
|
return NS_OK;
|
|
}
|
|
|
|
#ifdef XP_WIN
|
|
// Matches the enum in WinNT.h for the Vista SDK but renamed so that we can
|
|
// safely build with the Vista SDK and without it.
|
|
typedef enum
|
|
{
|
|
VistaTokenElevationTypeDefault = 1,
|
|
VistaTokenElevationTypeFull,
|
|
VistaTokenElevationTypeLimited
|
|
} VISTA_TOKEN_ELEVATION_TYPE;
|
|
|
|
// avoid collision with TokeElevationType enum in WinNT.h
|
|
// of the Vista SDK
|
|
#define VistaTokenElevationType static_cast< TOKEN_INFORMATION_CLASS >( 18 )
|
|
|
|
NS_IMETHODIMP
|
|
nsXULAppInfo::GetUserCanElevate(bool *aUserCanElevate)
|
|
{
|
|
HANDLE hToken;
|
|
|
|
VISTA_TOKEN_ELEVATION_TYPE elevationType;
|
|
DWORD dwSize;
|
|
|
|
if (!OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &hToken) ||
|
|
!GetTokenInformation(hToken, VistaTokenElevationType, &elevationType,
|
|
sizeof(elevationType), &dwSize)) {
|
|
*aUserCanElevate = false;
|
|
}
|
|
else {
|
|
// The possible values returned for elevationType and their meanings are:
|
|
// TokenElevationTypeDefault: The token does not have a linked token
|
|
// (e.g. UAC disabled or a standard user, so they can't be elevated)
|
|
// TokenElevationTypeFull: The token is linked to an elevated token
|
|
// (e.g. UAC is enabled and the user is already elevated so they can't
|
|
// be elevated again)
|
|
// TokenElevationTypeLimited: The token is linked to a limited token
|
|
// (e.g. UAC is enabled and the user is not elevated, so they can be
|
|
// elevated)
|
|
*aUserCanElevate = (elevationType == VistaTokenElevationTypeLimited);
|
|
}
|
|
|
|
if (hToken)
|
|
CloseHandle(hToken);
|
|
|
|
return NS_OK;
|
|
}
|
|
#endif
|
|
|
|
static const nsXULAppInfo kAppInfo;
|
|
static nsresult AppInfoConstructor(nsISupports* aOuter,
|
|
REFNSIID aIID, void **aResult)
|
|
{
|
|
NS_ENSURE_NO_AGGREGATION(aOuter);
|
|
|
|
return const_cast<nsXULAppInfo*>(&kAppInfo)->
|
|
QueryInterface(aIID, aResult);
|
|
}
|
|
|
|
bool gLogConsoleErrors = false;
|
|
|
|
#define NS_ENSURE_TRUE_LOG(x, ret) \
|
|
PR_BEGIN_MACRO \
|
|
if (MOZ_UNLIKELY(!(x))) { \
|
|
NS_WARNING("NS_ENSURE_TRUE(" #x ") failed"); \
|
|
gLogConsoleErrors = true; \
|
|
return ret; \
|
|
} \
|
|
PR_END_MACRO
|
|
|
|
#define NS_ENSURE_SUCCESS_LOG(res, ret) \
|
|
NS_ENSURE_TRUE_LOG(NS_SUCCEEDED(res), ret)
|
|
|
|
/**
|
|
* Because we're starting/stopping XPCOM several times in different scenarios,
|
|
* this class is a stack-based critter that makes sure that XPCOM is shut down
|
|
* during early returns.
|
|
*/
|
|
|
|
class ScopedXPCOMStartup
|
|
{
|
|
public:
|
|
ScopedXPCOMStartup() :
|
|
mServiceManager(nullptr) { }
|
|
~ScopedXPCOMStartup();
|
|
|
|
nsresult Initialize();
|
|
nsresult SetWindowCreator(nsINativeAppSupport* native);
|
|
|
|
static nsresult CreateAppSupport(nsISupports* aOuter, REFNSIID aIID, void** aResult);
|
|
|
|
private:
|
|
nsIServiceManager* mServiceManager;
|
|
static nsINativeAppSupport* gNativeAppSupport;
|
|
};
|
|
|
|
ScopedXPCOMStartup::~ScopedXPCOMStartup()
|
|
{
|
|
NS_IF_RELEASE(gNativeAppSupport);
|
|
|
|
if (mServiceManager) {
|
|
#ifdef XP_MACOSX
|
|
// On OS X, we need a pool to catch cocoa objects that are autoreleased
|
|
// during teardown.
|
|
mozilla::MacAutoreleasePool pool;
|
|
#endif
|
|
|
|
nsCOMPtr<nsIAppStartup> appStartup (do_GetService(NS_APPSTARTUP_CONTRACTID));
|
|
if (appStartup)
|
|
appStartup->DestroyHiddenWindow();
|
|
|
|
gDirServiceProvider->DoShutdown();
|
|
PROFILER_MARKER("Shutdown early");
|
|
|
|
WriteConsoleLog();
|
|
|
|
NS_ShutdownXPCOM(mServiceManager);
|
|
mServiceManager = nullptr;
|
|
}
|
|
}
|
|
|
|
// {95d89e3e-a169-41a3-8e56-719978e15b12}
|
|
#define APPINFO_CID \
|
|
{ 0x95d89e3e, 0xa169, 0x41a3, { 0x8e, 0x56, 0x71, 0x99, 0x78, 0xe1, 0x5b, 0x12 } }
|
|
|
|
// {0C4A446C-EE82-41f2-8D04-D366D2C7A7D4}
|
|
static const nsCID kNativeAppSupportCID =
|
|
{ 0xc4a446c, 0xee82, 0x41f2, { 0x8d, 0x4, 0xd3, 0x66, 0xd2, 0xc7, 0xa7, 0xd4 } };
|
|
|
|
// {5F5E59CE-27BC-47eb-9D1F-B09CA9049836}
|
|
static const nsCID kProfileServiceCID =
|
|
{ 0x5f5e59ce, 0x27bc, 0x47eb, { 0x9d, 0x1f, 0xb0, 0x9c, 0xa9, 0x4, 0x98, 0x36 } };
|
|
|
|
static already_AddRefed<nsIFactory>
|
|
ProfileServiceFactoryConstructor(const mozilla::Module& module, const mozilla::Module::CIDEntry& entry)
|
|
{
|
|
nsCOMPtr<nsIFactory> factory;
|
|
NS_NewToolkitProfileFactory(getter_AddRefs(factory));
|
|
return factory.forget();
|
|
}
|
|
|
|
NS_DEFINE_NAMED_CID(APPINFO_CID);
|
|
|
|
static const mozilla::Module::CIDEntry kXRECIDs[] = {
|
|
{ &kAPPINFO_CID, false, nullptr, AppInfoConstructor },
|
|
{ &kProfileServiceCID, false, ProfileServiceFactoryConstructor, nullptr },
|
|
{ &kNativeAppSupportCID, false, nullptr, ScopedXPCOMStartup::CreateAppSupport },
|
|
{ nullptr }
|
|
};
|
|
|
|
static const mozilla::Module::ContractIDEntry kXREContracts[] = {
|
|
{ XULAPPINFO_SERVICE_CONTRACTID, &kAPPINFO_CID },
|
|
{ XULRUNTIME_SERVICE_CONTRACTID, &kAPPINFO_CID },
|
|
{ NS_PROFILESERVICE_CONTRACTID, &kProfileServiceCID },
|
|
{ NS_NATIVEAPPSUPPORT_CONTRACTID, &kNativeAppSupportCID },
|
|
{ nullptr }
|
|
};
|
|
|
|
static const mozilla::Module kXREModule = {
|
|
mozilla::Module::kVersion,
|
|
kXRECIDs,
|
|
kXREContracts
|
|
};
|
|
|
|
NSMODULE_DEFN(Apprunner) = &kXREModule;
|
|
|
|
nsresult
|
|
ScopedXPCOMStartup::Initialize()
|
|
{
|
|
NS_ASSERTION(gDirServiceProvider, "Should not get here!");
|
|
|
|
nsresult rv;
|
|
|
|
rv = NS_InitXPCOM2(&mServiceManager, gDirServiceProvider->GetAppDir(),
|
|
gDirServiceProvider);
|
|
if (NS_FAILED(rv)) {
|
|
NS_ERROR("Couldn't start xpcom!");
|
|
mServiceManager = nullptr;
|
|
}
|
|
else {
|
|
#ifdef DEBUG
|
|
nsCOMPtr<nsIComponentRegistrar> reg =
|
|
do_QueryInterface(mServiceManager);
|
|
NS_ASSERTION(reg, "Service Manager doesn't QI to Registrar.");
|
|
#endif
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
/**
|
|
* This is a little factory class that serves as a singleton-service-factory
|
|
* for the nativeappsupport object.
|
|
*/
|
|
class nsSingletonFactory final : public nsIFactory
|
|
{
|
|
public:
|
|
NS_DECL_ISUPPORTS
|
|
NS_DECL_NSIFACTORY
|
|
|
|
explicit nsSingletonFactory(nsISupports* aSingleton);
|
|
|
|
private:
|
|
~nsSingletonFactory() { }
|
|
nsCOMPtr<nsISupports> mSingleton;
|
|
};
|
|
|
|
nsSingletonFactory::nsSingletonFactory(nsISupports* aSingleton)
|
|
: mSingleton(aSingleton)
|
|
{
|
|
NS_ASSERTION(mSingleton, "Singleton was null!");
|
|
}
|
|
|
|
NS_IMPL_ISUPPORTS(nsSingletonFactory, nsIFactory)
|
|
|
|
NS_IMETHODIMP
|
|
nsSingletonFactory::CreateInstance(nsISupports* aOuter,
|
|
const nsIID& aIID,
|
|
void* *aResult)
|
|
{
|
|
NS_ENSURE_NO_AGGREGATION(aOuter);
|
|
|
|
return mSingleton->QueryInterface(aIID, aResult);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsSingletonFactory::LockFactory(bool)
|
|
{
|
|
return NS_OK;
|
|
}
|
|
|
|
/**
|
|
* Set our windowcreator on the WindowWatcher service.
|
|
*/
|
|
nsresult
|
|
ScopedXPCOMStartup::SetWindowCreator(nsINativeAppSupport* native)
|
|
{
|
|
nsresult rv;
|
|
|
|
NS_IF_ADDREF(gNativeAppSupport = native);
|
|
|
|
// Inform the chrome registry about OS accessibility
|
|
nsCOMPtr<nsIToolkitChromeRegistry> cr =
|
|
mozilla::services::GetToolkitChromeRegistryService();
|
|
|
|
if (cr)
|
|
cr->CheckForOSAccessibility();
|
|
|
|
nsCOMPtr<nsIWindowCreator> creator (do_GetService(NS_APPSTARTUP_CONTRACTID));
|
|
if (!creator) return NS_ERROR_UNEXPECTED;
|
|
|
|
nsCOMPtr<nsIWindowWatcher> wwatch
|
|
(do_GetService(NS_WINDOWWATCHER_CONTRACTID, &rv));
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
return wwatch->SetWindowCreator(creator);
|
|
}
|
|
|
|
/* static */ nsresult
|
|
ScopedXPCOMStartup::CreateAppSupport(nsISupports* aOuter, REFNSIID aIID, void** aResult)
|
|
{
|
|
if (aOuter)
|
|
return NS_ERROR_NO_AGGREGATION;
|
|
|
|
if (!gNativeAppSupport)
|
|
return NS_ERROR_NOT_INITIALIZED;
|
|
|
|
return gNativeAppSupport->QueryInterface(aIID, aResult);
|
|
}
|
|
|
|
nsINativeAppSupport* ScopedXPCOMStartup::gNativeAppSupport;
|
|
|
|
static void DumpArbitraryHelp()
|
|
{
|
|
nsresult rv;
|
|
|
|
ScopedLogging log;
|
|
|
|
{
|
|
ScopedXPCOMStartup xpcom;
|
|
xpcom.Initialize();
|
|
|
|
nsCOMPtr<nsICommandLineRunner> cmdline
|
|
(do_CreateInstance("@mozilla.org/toolkit/command-line;1"));
|
|
if (!cmdline)
|
|
return;
|
|
|
|
nsCString text;
|
|
rv = cmdline->GetHelpText(text);
|
|
if (NS_SUCCEEDED(rv))
|
|
printf("%s", text.get());
|
|
}
|
|
}
|
|
|
|
// English text needs to go into a dtd file.
|
|
// But when this is called we have no components etc. These strings must either be
|
|
// here, or in a native resource file.
|
|
static void
|
|
DumpHelp()
|
|
{
|
|
printf("Usage: %s [ options ... ] [URL]\n"
|
|
" where options include:\n\n", gArgv[0]);
|
|
|
|
#ifdef MOZ_X11
|
|
printf("X11 options\n"
|
|
" --display=DISPLAY X display to use.\n"
|
|
" --sync Make X calls synchronous.\n");
|
|
#endif
|
|
#ifdef XP_UNIX
|
|
printf(" --g-fatal-warnings Make all warnings fatal.\n"
|
|
"\n%s options\n", gAppData->name);
|
|
#endif
|
|
|
|
printf(" -h or --help Print this message.\n"
|
|
" -v or --version Print %s version.\n"
|
|
" -P <profile> Start with <profile>.\n"
|
|
" --profile <path> Start with profile at <path>.\n"
|
|
#ifdef MC_BASILISK
|
|
" --migration Start with migration wizard.\n"
|
|
#endif
|
|
" --ProfileManager Start with ProfileManager.\n"
|
|
" --no-remote Do not accept or send remote commands;\n"
|
|
" implies --new-instance.\n"
|
|
" --new-instance Open new instance, not a new window\n"
|
|
" in running instance.\n"
|
|
" --UILocale <locale> Start with <locale> resources as UI Locale.\n"
|
|
" --safe-mode Disables extensions and themes for this session.\n", (const char*) gAppData->name);
|
|
|
|
#if defined(XP_WIN)
|
|
printf(" --console Start %s with a debugging console.\n", (const char*) gAppData->name);
|
|
#endif
|
|
|
|
// this works, but only after the components have registered. so if you drop in a new command line handler, --help
|
|
// won't not until the second run.
|
|
// out of the bug, because we ship a component.reg file, it works correctly.
|
|
DumpArbitraryHelp();
|
|
}
|
|
|
|
#if defined(DEBUG) && defined(XP_WIN)
|
|
#ifdef DEBUG_warren
|
|
#define _CRTDBG_MAP_ALLOC
|
|
#endif
|
|
// Set a CRT ReportHook function to capture and format MSCRT
|
|
// warnings, errors and assertions.
|
|
// See http://msdn.microsoft.com/en-US/library/74kabxyx(v=VS.80).aspx
|
|
#include <stdio.h>
|
|
#include <crtdbg.h>
|
|
#include "mozilla/mozalloc_abort.h"
|
|
static int MSCRTReportHook( int aReportType, char *aMessage, int *oReturnValue)
|
|
{
|
|
*oReturnValue = 0; // continue execution
|
|
|
|
// Do not use fprintf or other functions which may allocate
|
|
// memory from the heap which may be corrupted. Instead,
|
|
// use fputs to output the leading portion of the message
|
|
// and use mozalloc_abort to emit the remainder of the
|
|
// message.
|
|
|
|
switch(aReportType) {
|
|
case 0:
|
|
fputs("\nWARNING: CRT WARNING", stderr);
|
|
fputs(aMessage, stderr);
|
|
fputs("\n", stderr);
|
|
break;
|
|
case 1:
|
|
fputs("\n###!!! ABORT: CRT ERROR ", stderr);
|
|
mozalloc_abort(aMessage);
|
|
break;
|
|
case 2:
|
|
fputs("\n###!!! ABORT: CRT ASSERT ", stderr);
|
|
mozalloc_abort(aMessage);
|
|
break;
|
|
}
|
|
|
|
// do not invoke the debugger
|
|
return 1;
|
|
}
|
|
|
|
#endif
|
|
|
|
static inline void
|
|
DumpVersion()
|
|
{
|
|
if (gAppData->vendor)
|
|
printf("%s ", gAppData->vendor);
|
|
printf("%s %s", gAppData->name, gAppData->version);
|
|
if (gAppData->copyright)
|
|
printf(", %s", gAppData->copyright);
|
|
printf("\n");
|
|
}
|
|
|
|
#ifdef MOZ_ENABLE_XREMOTE
|
|
static RemoteResult
|
|
ParseRemoteCommandLine(nsCString& program,
|
|
const char** profile,
|
|
const char** username)
|
|
{
|
|
ArgResult ar;
|
|
|
|
ar = CheckArg("p", false, profile, false);
|
|
if (ar == ARG_BAD) {
|
|
// Leave it to the normal command line handling to handle this situation.
|
|
return REMOTE_NOT_FOUND;
|
|
}
|
|
|
|
const char *temp = nullptr;
|
|
ar = CheckArg("a", true, &temp);
|
|
if (ar == ARG_BAD) {
|
|
PR_fprintf(PR_STDERR, "Error: argument -a requires an application name\n");
|
|
return REMOTE_ARG_BAD;
|
|
} else if (ar == ARG_FOUND) {
|
|
program.Assign(temp);
|
|
}
|
|
|
|
ar = CheckArg("u", true, username);
|
|
if (ar == ARG_BAD) {
|
|
PR_fprintf(PR_STDERR, "Error: argument -u requires a username\n");
|
|
return REMOTE_ARG_BAD;
|
|
}
|
|
|
|
return REMOTE_FOUND;
|
|
}
|
|
|
|
static RemoteResult
|
|
StartRemoteClient(const char* aDesktopStartupID,
|
|
nsCString& program,
|
|
const char* profile,
|
|
const char* username)
|
|
{
|
|
XRemoteClient client;
|
|
nsresult rv = client.Init();
|
|
if (NS_FAILED(rv))
|
|
return REMOTE_NOT_FOUND;
|
|
|
|
nsXPIDLCString response;
|
|
bool success = false;
|
|
rv = client.SendCommandLine(program.get(), username, profile,
|
|
gArgc, gArgv, aDesktopStartupID,
|
|
getter_Copies(response), &success);
|
|
// did the command fail?
|
|
if (!success)
|
|
return REMOTE_NOT_FOUND;
|
|
|
|
// The "command not parseable" error is returned when the
|
|
// nsICommandLineHandler throws a NS_ERROR_ABORT.
|
|
if (response.EqualsLiteral("500 command not parseable"))
|
|
return REMOTE_ARG_BAD;
|
|
|
|
if (NS_FAILED(rv))
|
|
return REMOTE_NOT_FOUND;
|
|
|
|
return REMOTE_FOUND;
|
|
}
|
|
#endif // MOZ_ENABLE_XREMOTE
|
|
|
|
void
|
|
XRE_InitOmnijar(nsIFile* greOmni, nsIFile* appOmni)
|
|
{
|
|
mozilla::Omnijar::Init(greOmni, appOmni);
|
|
}
|
|
|
|
nsresult
|
|
XRE_GetBinaryPath(const char* argv0, nsIFile* *aResult)
|
|
{
|
|
return mozilla::BinaryPath::GetFile(argv0, aResult);
|
|
}
|
|
|
|
#ifdef XP_WIN
|
|
#include "nsWindowsRestart.cpp"
|
|
#include <shellapi.h>
|
|
|
|
typedef BOOL (WINAPI* SetProcessDEPPolicyFunc)(DWORD dwFlags);
|
|
#endif
|
|
|
|
// If aBlankCommandLine is true, then the application will be launched with a
|
|
// blank command line instead of being launched with the same command line that
|
|
// it was initially started with.
|
|
static nsresult LaunchChild(nsINativeAppSupport* aNative,
|
|
bool aBlankCommandLine = false)
|
|
{
|
|
aNative->Quit(); // release DDE mutex, if we're holding it
|
|
|
|
// Restart this process by exec'ing it into the current process
|
|
// if supported by the platform. Otherwise, use NSPR.
|
|
|
|
if (aBlankCommandLine) {
|
|
gRestartArgc = 1;
|
|
gRestartArgv[gRestartArgc] = nullptr;
|
|
}
|
|
|
|
SaveToEnv("MOZ_LAUNCHED_CHILD=1");
|
|
|
|
#if defined(MOZ_WIDGET_ANDROID)
|
|
java::GeckoAppShell::ScheduleRestart();
|
|
#else
|
|
#if defined(XP_MACOSX)
|
|
CommandLineServiceMac::SetupMacCommandLine(gRestartArgc, gRestartArgv, true);
|
|
LaunchChildMac(gRestartArgc, gRestartArgv);
|
|
#else
|
|
nsCOMPtr<nsIFile> lf;
|
|
nsresult rv = XRE_GetBinaryPath(gArgv[0], getter_AddRefs(lf));
|
|
if (NS_FAILED(rv))
|
|
return rv;
|
|
|
|
#if defined(XP_WIN)
|
|
nsAutoString exePath;
|
|
rv = lf->GetPath(exePath);
|
|
if (NS_FAILED(rv))
|
|
return rv;
|
|
|
|
if (!WinLaunchChild(exePath.get(), gRestartArgc, gRestartArgv))
|
|
return NS_ERROR_FAILURE;
|
|
|
|
#else
|
|
nsAutoCString exePath;
|
|
rv = lf->GetNativePath(exePath);
|
|
if (NS_FAILED(rv))
|
|
return rv;
|
|
|
|
#if defined(XP_UNIX)
|
|
if (execv(exePath.get(), gRestartArgv) == -1)
|
|
return NS_ERROR_FAILURE;
|
|
#else
|
|
PRProcess* process = PR_CreateProcess(exePath.get(), gRestartArgv,
|
|
nullptr, nullptr);
|
|
if (!process) return NS_ERROR_FAILURE;
|
|
|
|
int32_t exitCode;
|
|
PRStatus failed = PR_WaitProcess(process, &exitCode);
|
|
if (failed || exitCode)
|
|
return NS_ERROR_FAILURE;
|
|
#endif // XP_UNIX
|
|
#endif // WP_WIN
|
|
#endif // WP_MACOSX
|
|
#endif // MOZ_WIDGET_ANDROID
|
|
|
|
return NS_ERROR_LAUNCHED_CHILD_PROCESS;
|
|
}
|
|
|
|
static const char kProfileProperties[] =
|
|
"chrome://mozapps/locale/profile/profileSelection.properties";
|
|
|
|
namespace {
|
|
|
|
/**
|
|
* This class, instead of a raw nsresult, should be the return type of any
|
|
* function called by SelectProfile that initializes XPCOM.
|
|
*/
|
|
class ReturnAbortOnError
|
|
{
|
|
public:
|
|
MOZ_IMPLICIT ReturnAbortOnError(nsresult aRv)
|
|
{
|
|
mRv = ConvertRv(aRv);
|
|
}
|
|
|
|
operator nsresult()
|
|
{
|
|
return mRv;
|
|
}
|
|
|
|
private:
|
|
inline nsresult
|
|
ConvertRv(nsresult aRv)
|
|
{
|
|
if (NS_SUCCEEDED(aRv) || aRv == NS_ERROR_LAUNCHED_CHILD_PROCESS) {
|
|
return aRv;
|
|
}
|
|
return NS_ERROR_ABORT;
|
|
}
|
|
|
|
nsresult mRv;
|
|
};
|
|
|
|
} // namespace
|
|
|
|
static ReturnAbortOnError
|
|
ProfileLockedDialog(nsIFile* aProfileDir, nsIFile* aProfileLocalDir,
|
|
nsIProfileUnlocker* aUnlocker,
|
|
nsINativeAppSupport* aNative, nsIProfileLock* *aResult)
|
|
{
|
|
nsresult rv;
|
|
|
|
ScopedXPCOMStartup xpcom;
|
|
rv = xpcom.Initialize();
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
mozilla::Telemetry::WriteFailedProfileLock(aProfileDir);
|
|
|
|
rv = xpcom.SetWindowCreator(aNative);
|
|
NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);
|
|
|
|
{ //extra scoping is needed so we release these components before xpcom shutdown
|
|
nsCOMPtr<nsIStringBundleService> sbs =
|
|
mozilla::services::GetStringBundleService();
|
|
NS_ENSURE_TRUE(sbs, NS_ERROR_FAILURE);
|
|
|
|
nsCOMPtr<nsIStringBundle> sb;
|
|
sbs->CreateBundle(kProfileProperties, getter_AddRefs(sb));
|
|
NS_ENSURE_TRUE_LOG(sbs, NS_ERROR_FAILURE);
|
|
|
|
NS_ConvertUTF8toUTF16 appName(gAppData->name);
|
|
const char16_t* params[] = {appName.get(), appName.get()};
|
|
|
|
nsXPIDLString killMessage;
|
|
#ifndef XP_MACOSX
|
|
sb->FormatStringFromName(aUnlocker ? u"restartMessageUnlocker"
|
|
: u"restartMessageNoUnlocker",
|
|
params, 2, getter_Copies(killMessage));
|
|
#else
|
|
sb->FormatStringFromName(aUnlocker ? u"restartMessageUnlockerMac"
|
|
: u"restartMessageNoUnlockerMac",
|
|
params, 2, getter_Copies(killMessage));
|
|
#endif
|
|
|
|
nsXPIDLString killTitle;
|
|
sb->FormatStringFromName(u"restartTitle",
|
|
params, 1, getter_Copies(killTitle));
|
|
|
|
if (!killMessage || !killTitle)
|
|
return NS_ERROR_FAILURE;
|
|
|
|
nsCOMPtr<nsIPromptService> ps
|
|
(do_GetService(NS_PROMPTSERVICE_CONTRACTID));
|
|
NS_ENSURE_TRUE(ps, NS_ERROR_FAILURE);
|
|
|
|
if (aUnlocker) {
|
|
int32_t button;
|
|
#ifdef MOZ_WIDGET_ANDROID
|
|
java::GeckoAppShell::KillAnyZombies();
|
|
button = 0;
|
|
#else
|
|
const uint32_t flags =
|
|
(nsIPromptService::BUTTON_TITLE_IS_STRING *
|
|
nsIPromptService::BUTTON_POS_0) +
|
|
(nsIPromptService::BUTTON_TITLE_CANCEL *
|
|
nsIPromptService::BUTTON_POS_1);
|
|
|
|
bool checkState = false;
|
|
rv = ps->ConfirmEx(nullptr, killTitle, killMessage, flags,
|
|
killTitle, nullptr, nullptr, nullptr,
|
|
&checkState, &button);
|
|
NS_ENSURE_SUCCESS_LOG(rv, rv);
|
|
#endif
|
|
|
|
if (button == 0) {
|
|
rv = aUnlocker->Unlock(nsIProfileUnlocker::FORCE_QUIT);
|
|
if (NS_FAILED(rv)) {
|
|
return rv;
|
|
}
|
|
|
|
SaveFileToEnv("XRE_PROFILE_PATH", aProfileDir);
|
|
SaveFileToEnv("XRE_PROFILE_LOCAL_PATH", aProfileLocalDir);
|
|
|
|
return LaunchChild(aNative);
|
|
}
|
|
} else {
|
|
#ifdef MOZ_WIDGET_ANDROID
|
|
if (java::GeckoAppShell::UnlockProfile()) {
|
|
return NS_LockProfilePath(aProfileDir, aProfileLocalDir,
|
|
nullptr, aResult);
|
|
}
|
|
#else
|
|
rv = ps->Alert(nullptr, killTitle, killMessage);
|
|
NS_ENSURE_SUCCESS_LOG(rv, rv);
|
|
#endif
|
|
}
|
|
|
|
return NS_ERROR_ABORT;
|
|
}
|
|
}
|
|
|
|
static nsresult
|
|
ProfileMissingDialog(nsINativeAppSupport* aNative)
|
|
{
|
|
nsresult rv;
|
|
|
|
ScopedXPCOMStartup xpcom;
|
|
rv = xpcom.Initialize();
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
rv = xpcom.SetWindowCreator(aNative);
|
|
NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);
|
|
|
|
{ //extra scoping is needed so we release these components before xpcom shutdown
|
|
nsCOMPtr<nsIStringBundleService> sbs =
|
|
mozilla::services::GetStringBundleService();
|
|
NS_ENSURE_TRUE(sbs, NS_ERROR_FAILURE);
|
|
|
|
nsCOMPtr<nsIStringBundle> sb;
|
|
sbs->CreateBundle(kProfileProperties, getter_AddRefs(sb));
|
|
NS_ENSURE_TRUE_LOG(sbs, NS_ERROR_FAILURE);
|
|
|
|
NS_ConvertUTF8toUTF16 appName(gAppData->name);
|
|
const char16_t* params[] = {appName.get(), appName.get()};
|
|
|
|
nsXPIDLString missingMessage;
|
|
|
|
// profileMissing
|
|
sb->FormatStringFromName(u"profileMissing", params, 2, getter_Copies(missingMessage));
|
|
|
|
nsXPIDLString missingTitle;
|
|
sb->FormatStringFromName(u"profileMissingTitle",
|
|
params, 1, getter_Copies(missingTitle));
|
|
|
|
if (missingMessage && missingTitle) {
|
|
nsCOMPtr<nsIPromptService> ps
|
|
(do_GetService(NS_PROMPTSERVICE_CONTRACTID));
|
|
NS_ENSURE_TRUE(ps, NS_ERROR_FAILURE);
|
|
|
|
ps->Alert(nullptr, missingTitle, missingMessage);
|
|
}
|
|
|
|
return NS_ERROR_ABORT;
|
|
}
|
|
}
|
|
|
|
static nsresult
|
|
ProfileLockedDialog(nsIToolkitProfile* aProfile, nsIProfileUnlocker* aUnlocker,
|
|
nsINativeAppSupport* aNative, nsIProfileLock* *aResult)
|
|
{
|
|
nsCOMPtr<nsIFile> profileDir;
|
|
nsresult rv = aProfile->GetRootDir(getter_AddRefs(profileDir));
|
|
if (NS_FAILED(rv)) return rv;
|
|
|
|
bool exists;
|
|
profileDir->Exists(&exists);
|
|
if (!exists) {
|
|
return ProfileMissingDialog(aNative);
|
|
}
|
|
|
|
nsCOMPtr<nsIFile> profileLocalDir;
|
|
rv = aProfile->GetLocalDir(getter_AddRefs(profileLocalDir));
|
|
if (NS_FAILED(rv)) return rv;
|
|
|
|
return ProfileLockedDialog(profileDir, profileLocalDir, aUnlocker, aNative,
|
|
aResult);
|
|
}
|
|
|
|
static const char kProfileManagerURL[] =
|
|
"chrome://mozapps/content/profile/profileSelection.xul";
|
|
|
|
static ReturnAbortOnError
|
|
ShowProfileManager(nsIToolkitProfileService* aProfileSvc,
|
|
nsINativeAppSupport* aNative)
|
|
{
|
|
if (!CanShowProfileManager()) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
nsresult rv;
|
|
|
|
nsCOMPtr<nsIFile> profD, profLD;
|
|
char16_t* profileNamePtr;
|
|
nsAutoCString profileName;
|
|
|
|
{
|
|
ScopedXPCOMStartup xpcom;
|
|
rv = xpcom.Initialize();
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
// Initialize the graphics prefs, some of the paths need them before
|
|
// any other graphics is initialized (e.g., showing the profile chooser.)
|
|
gfxPrefs::GetSingleton();
|
|
|
|
rv = xpcom.SetWindowCreator(aNative);
|
|
NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);
|
|
|
|
#ifdef XP_MACOSX
|
|
CommandLineServiceMac::SetupMacCommandLine(gRestartArgc, gRestartArgv, true);
|
|
#endif
|
|
|
|
#ifdef XP_WIN
|
|
// we don't have to wait here because profile manager window will pump
|
|
// and DDE message will be handled
|
|
ProcessDDE(aNative, false);
|
|
#endif
|
|
|
|
{ //extra scoping is needed so we release these components before xpcom shutdown
|
|
nsCOMPtr<nsIWindowWatcher> windowWatcher
|
|
(do_GetService(NS_WINDOWWATCHER_CONTRACTID));
|
|
nsCOMPtr<nsIDialogParamBlock> ioParamBlock
|
|
(do_CreateInstance(NS_DIALOGPARAMBLOCK_CONTRACTID));
|
|
nsCOMPtr<nsIMutableArray> dlgArray (do_CreateInstance(NS_ARRAY_CONTRACTID));
|
|
NS_ENSURE_TRUE(windowWatcher && ioParamBlock && dlgArray, NS_ERROR_FAILURE);
|
|
|
|
ioParamBlock->SetObjects(dlgArray);
|
|
|
|
nsCOMPtr<nsIAppStartup> appStartup
|
|
(do_GetService(NS_APPSTARTUP_CONTRACTID));
|
|
NS_ENSURE_TRUE(appStartup, NS_ERROR_FAILURE);
|
|
|
|
nsCOMPtr<mozIDOMWindowProxy> newWindow;
|
|
rv = windowWatcher->OpenWindow(nullptr,
|
|
kProfileManagerURL,
|
|
"_blank",
|
|
"centerscreen,chrome,modal,titlebar",
|
|
ioParamBlock,
|
|
getter_AddRefs(newWindow));
|
|
|
|
NS_ENSURE_SUCCESS_LOG(rv, rv);
|
|
|
|
aProfileSvc->Flush();
|
|
|
|
int32_t dialogConfirmed;
|
|
rv = ioParamBlock->GetInt(0, &dialogConfirmed);
|
|
if (NS_FAILED(rv) || dialogConfirmed == 0) return NS_ERROR_ABORT;
|
|
|
|
nsCOMPtr<nsIProfileLock> lock;
|
|
rv = dlgArray->QueryElementAt(0, NS_GET_IID(nsIProfileLock),
|
|
getter_AddRefs(lock));
|
|
NS_ENSURE_SUCCESS_LOG(rv, rv);
|
|
|
|
rv = lock->GetDirectory(getter_AddRefs(profD));
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
rv = lock->GetLocalDirectory(getter_AddRefs(profLD));
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
rv = ioParamBlock->GetString(0, &profileNamePtr);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
CopyUTF16toUTF8(profileNamePtr, profileName);
|
|
free(profileNamePtr);
|
|
|
|
lock->Unlock();
|
|
}
|
|
}
|
|
|
|
SaveFileToEnv("XRE_PROFILE_PATH", profD);
|
|
SaveFileToEnv("XRE_PROFILE_LOCAL_PATH", profLD);
|
|
SaveWordToEnv("XRE_PROFILE_NAME", profileName);
|
|
|
|
bool offline = false;
|
|
aProfileSvc->GetStartOffline(&offline);
|
|
if (offline) {
|
|
SaveToEnv("XRE_START_OFFLINE=1");
|
|
}
|
|
|
|
return LaunchChild(aNative);
|
|
}
|
|
|
|
/**
|
|
* Get the currently running profile using its root directory.
|
|
*
|
|
* @param aProfileSvc The profile service
|
|
* @param aCurrentProfileRoot The root directory of the current profile.
|
|
* @param aProfile Out-param that returns the profile object.
|
|
* @return an error if aCurrentProfileRoot is not found
|
|
*/
|
|
static nsresult
|
|
GetCurrentProfile(nsIToolkitProfileService* aProfileSvc,
|
|
nsIFile* aCurrentProfileRoot,
|
|
nsIToolkitProfile** aProfile)
|
|
{
|
|
NS_ENSURE_ARG_POINTER(aProfileSvc);
|
|
NS_ENSURE_ARG_POINTER(aProfile);
|
|
|
|
nsCOMPtr<nsISimpleEnumerator> profiles;
|
|
nsresult rv = aProfileSvc->GetProfiles(getter_AddRefs(profiles));
|
|
if (NS_FAILED(rv))
|
|
return rv;
|
|
|
|
bool foundMatchingProfile = false;
|
|
nsCOMPtr<nsISupports> supports;
|
|
rv = profiles->GetNext(getter_AddRefs(supports));
|
|
while (NS_SUCCEEDED(rv)) {
|
|
nsCOMPtr<nsIToolkitProfile> profile = do_QueryInterface(supports);
|
|
nsCOMPtr<nsIFile> profileRoot;
|
|
profile->GetRootDir(getter_AddRefs(profileRoot));
|
|
profileRoot->Equals(aCurrentProfileRoot, &foundMatchingProfile);
|
|
if (foundMatchingProfile) {
|
|
profile.forget(aProfile);
|
|
return NS_OK;
|
|
}
|
|
rv = profiles->GetNext(getter_AddRefs(supports));
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
static bool gDoMigration = false;
|
|
static bool gDoProfileReset = false;
|
|
static nsAutoCString gResetOldProfileName;
|
|
|
|
// Pick a profile. We need to end up with a profile lock.
|
|
//
|
|
// 1) check for --profile <path>
|
|
// 2) check for -P <name>
|
|
// 3) check for --ProfileManager
|
|
// 4) use the default profile, if there is one
|
|
// 5) if there are *no* profiles, set up profile-migration
|
|
// 6) display the profile-manager UI
|
|
static nsresult
|
|
SelectProfile(nsIProfileLock* *aResult, nsIToolkitProfileService* aProfileSvc, nsINativeAppSupport* aNative,
|
|
bool* aStartOffline, nsACString* aProfileName,int prt)
|
|
{
|
|
StartupTimeline::Record(StartupTimeline::SELECT_PROFILE);
|
|
|
|
nsresult rv;
|
|
ArgResult ar;
|
|
const char* arg;
|
|
*aResult = nullptr;
|
|
*aStartOffline = false;
|
|
|
|
ar = CheckArg("offline", true);
|
|
if (ar == ARG_BAD) {
|
|
PR_fprintf(PR_STDERR, "Error: argument --offline is invalid when argument --osint is specified\n");
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
if (ar || EnvHasValue("XRE_START_OFFLINE"))
|
|
*aStartOffline = true;
|
|
|
|
if (EnvHasValue("MOZ_RESET_PROFILE_RESTART")) {
|
|
gDoProfileReset = true;
|
|
gDoMigration = true;
|
|
SaveToEnv("MOZ_RESET_PROFILE_RESTART=");
|
|
}
|
|
|
|
//MYPAL PORTABLE CODE START
|
|
nsCOMPtr<nsIFile> lf;
|
|
if (prt>0) {
|
|
//lstrcmpW(L"Teest",L"Teest");
|
|
|
|
nsCOMPtr<nsIFile> exeFile;
|
|
rv = XRE_GetBinaryPath(gArgv[0], getter_AddRefs(exeFile));
|
|
rv = exeFile->GetParent(getter_AddRefs(lf));
|
|
lf->AppendNative(*aProfileName);
|
|
|
|
// nsAutoString path1;
|
|
// rv = lf->GetPath(path1);
|
|
// ::MessageBoxW(NULL,path1.get(),L"Teest",MB_OKCANCEL);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
nsCOMPtr<nsIProfileUnlocker> unlocker;
|
|
|
|
bool exists;
|
|
lf->Exists(&exists);
|
|
if (!exists) {
|
|
rv = lf->Create(nsIFile::DIRECTORY_TYPE, 0700);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
}
|
|
|
|
// If a profile path is specified directory on the command line, then
|
|
// assume that the temp directory is the same as the given directory.
|
|
rv = NS_LockProfilePath(lf, lf, getter_AddRefs(unlocker), aResult);
|
|
if (NS_SUCCEEDED(rv))
|
|
return rv;
|
|
return ProfileLockedDialog(lf, lf, unlocker, aNative, aResult);}
|
|
//MYPAL PORTABLE CODE END
|
|
|
|
// reset-profile and migration args need to be checked before any profiles are chosen below.
|
|
ar = CheckArg("reset-profile", true);
|
|
if (ar == ARG_BAD) {
|
|
PR_fprintf(PR_STDERR, "Error: argument --reset-profile is invalid when argument --osint is specified\n");
|
|
return NS_ERROR_FAILURE;
|
|
} else if (ar == ARG_FOUND) {
|
|
gDoProfileReset = true;
|
|
}
|
|
|
|
ar = CheckArg("migration", true);
|
|
if (ar == ARG_BAD) {
|
|
PR_fprintf(PR_STDERR, "Error: argument --migration is invalid when argument --osint is specified\n");
|
|
return NS_ERROR_FAILURE;
|
|
} else if (ar == ARG_FOUND) {
|
|
gDoMigration = true;
|
|
}
|
|
|
|
lf = GetFileFromEnv("XRE_PROFILE_PATH");
|
|
if (lf) {
|
|
nsCOMPtr<nsIFile> localDir =
|
|
GetFileFromEnv("XRE_PROFILE_LOCAL_PATH");
|
|
if (!localDir) {
|
|
localDir = lf;
|
|
}
|
|
|
|
arg = PR_GetEnv("XRE_PROFILE_NAME");
|
|
if (arg && *arg && aProfileName) {
|
|
aProfileName->Assign(nsDependentCString(arg));
|
|
if (gDoProfileReset) {
|
|
gResetOldProfileName.Assign(*aProfileName);
|
|
}
|
|
}
|
|
|
|
// Clear out flags that we handled (or should have handled!) last startup.
|
|
const char *dummy;
|
|
CheckArg("p", false, &dummy);
|
|
CheckArg("profile", false, &dummy);
|
|
CheckArg("profilemanager");
|
|
|
|
if (gDoProfileReset) {
|
|
// If we're resetting a profile, create a new one and use it to startup.
|
|
nsCOMPtr<nsIToolkitProfile> newProfile;
|
|
rv = CreateResetProfile(aProfileSvc, gResetOldProfileName, getter_AddRefs(newProfile));
|
|
if (NS_SUCCEEDED(rv)) {
|
|
rv = newProfile->GetRootDir(getter_AddRefs(lf));
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
SaveFileToEnv("XRE_PROFILE_PATH", lf);
|
|
|
|
rv = newProfile->GetLocalDir(getter_AddRefs(localDir));
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
SaveFileToEnv("XRE_PROFILE_LOCAL_PATH", localDir);
|
|
|
|
rv = newProfile->GetName(*aProfileName);
|
|
if (NS_FAILED(rv))
|
|
aProfileName->Truncate(0);
|
|
SaveWordToEnv("XRE_PROFILE_NAME", *aProfileName);
|
|
} else {
|
|
NS_WARNING("Profile reset failed.");
|
|
gDoProfileReset = false;
|
|
}
|
|
}
|
|
|
|
return NS_LockProfilePath(lf, localDir, nullptr, aResult);
|
|
}
|
|
|
|
ar = CheckArg("profile", true, &arg);
|
|
if (ar == ARG_BAD) {
|
|
PR_fprintf(PR_STDERR, "Error: argument --profile requires a path\n");
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
if (ar) {
|
|
if (gDoProfileReset) {
|
|
NS_WARNING("Profile reset is not supported in conjunction with --profile.");
|
|
gDoProfileReset = false;
|
|
}
|
|
|
|
nsCOMPtr<nsIFile> lf;
|
|
rv = XRE_GetFileFromPath(arg, getter_AddRefs(lf));
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
nsCOMPtr<nsIProfileUnlocker> unlocker;
|
|
|
|
// Check if the profile path exists and it's a directory.
|
|
bool exists;
|
|
lf->Exists(&exists);
|
|
if (!exists) {
|
|
rv = lf->Create(nsIFile::DIRECTORY_TYPE, 0700);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
}
|
|
|
|
// If a profile path is specified directory on the command line, then
|
|
// assume that the temp directory is the same as the given directory.
|
|
rv = NS_LockProfilePath(lf, lf, getter_AddRefs(unlocker), aResult);
|
|
if (NS_SUCCEEDED(rv))
|
|
return rv;
|
|
|
|
return ProfileLockedDialog(lf, lf, unlocker, aNative, aResult);
|
|
}
|
|
|
|
ar = CheckArg("createprofile", true, &arg);
|
|
if (ar == ARG_BAD) {
|
|
PR_fprintf(PR_STDERR, "Error: argument --createprofile requires a profile name\n");
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
if (ar) {
|
|
nsCOMPtr<nsIToolkitProfile> profile;
|
|
|
|
const char* delim = strchr(arg, ' ');
|
|
if (delim) {
|
|
nsCOMPtr<nsIFile> lf;
|
|
rv = NS_NewNativeLocalFile(nsDependentCString(delim + 1),
|
|
true, getter_AddRefs(lf));
|
|
if (NS_FAILED(rv)) {
|
|
PR_fprintf(PR_STDERR, "Error: profile path not valid.\n");
|
|
return rv;
|
|
}
|
|
|
|
// As with --profile, assume that the given path will be used for the
|
|
// main profile directory.
|
|
rv = aProfileSvc->CreateProfile(lf, nsDependentCSubstring(arg, delim),
|
|
getter_AddRefs(profile));
|
|
} else {
|
|
rv = aProfileSvc->CreateProfile(nullptr, nsDependentCString(arg),
|
|
getter_AddRefs(profile));
|
|
}
|
|
// Some pathological arguments can make it this far
|
|
if (NS_FAILED(rv)) {
|
|
PR_fprintf(PR_STDERR, "Error creating profile.\n");
|
|
return rv;
|
|
}
|
|
rv = NS_ERROR_ABORT;
|
|
aProfileSvc->Flush();
|
|
|
|
// XXXben need to ensure prefs.js exists here so the tinderboxes will
|
|
// not go orange.
|
|
nsCOMPtr<nsIFile> prefsJSFile;
|
|
profile->GetRootDir(getter_AddRefs(prefsJSFile));
|
|
prefsJSFile->AppendNative(NS_LITERAL_CSTRING("prefs.js"));
|
|
nsAutoCString pathStr;
|
|
prefsJSFile->GetNativePath(pathStr);
|
|
PR_fprintf(PR_STDERR, "Success: created profile '%s' at '%s'\n", arg, pathStr.get());
|
|
bool exists;
|
|
prefsJSFile->Exists(&exists);
|
|
if (!exists) {
|
|
// Ignore any errors; we're about to return NS_ERROR_ABORT anyway.
|
|
Unused << prefsJSFile->Create(nsIFile::NORMAL_FILE_TYPE, 0644);
|
|
}
|
|
// XXXdarin perhaps 0600 would be better?
|
|
|
|
return rv;
|
|
}
|
|
|
|
uint32_t count;
|
|
rv = aProfileSvc->GetProfileCount(&count);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
ar = CheckArg("p", false, &arg);
|
|
if (ar == ARG_BAD) {
|
|
ar = CheckArg("osint");
|
|
if (ar == ARG_FOUND) {
|
|
PR_fprintf(PR_STDERR, "Error: argument -p is invalid when argument --osint is specified\n");
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
if (CanShowProfileManager()) {
|
|
return ShowProfileManager(aProfileSvc, aNative);
|
|
}
|
|
}
|
|
if (ar) {
|
|
ar = CheckArg("osint");
|
|
if (ar == ARG_FOUND) {
|
|
PR_fprintf(PR_STDERR, "Error: argument -p is invalid when argument --osint is specified\n");
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
nsCOMPtr<nsIToolkitProfile> profile;
|
|
rv = aProfileSvc->GetProfileByName(nsDependentCString(arg),
|
|
getter_AddRefs(profile));
|
|
if (NS_SUCCEEDED(rv)) {
|
|
if (gDoProfileReset) {
|
|
{
|
|
// Check that the source profile is not in use by temporarily acquiring its lock.
|
|
nsIProfileLock* tempProfileLock;
|
|
nsCOMPtr<nsIProfileUnlocker> unlocker;
|
|
rv = profile->Lock(getter_AddRefs(unlocker), &tempProfileLock);
|
|
if (NS_FAILED(rv))
|
|
return ProfileLockedDialog(profile, unlocker, aNative, &tempProfileLock);
|
|
}
|
|
|
|
nsresult gotName = profile->GetName(gResetOldProfileName);
|
|
if (NS_SUCCEEDED(gotName)) {
|
|
nsCOMPtr<nsIToolkitProfile> newProfile;
|
|
rv = CreateResetProfile(aProfileSvc, gResetOldProfileName, getter_AddRefs(newProfile));
|
|
if (NS_FAILED(rv)) {
|
|
NS_WARNING("Failed to create a profile to reset to.");
|
|
gDoProfileReset = false;
|
|
} else {
|
|
profile = newProfile;
|
|
}
|
|
} else {
|
|
NS_WARNING("Failed to get the name of the profile we're resetting, so aborting reset.");
|
|
gResetOldProfileName.Truncate(0);
|
|
gDoProfileReset = false;
|
|
}
|
|
}
|
|
|
|
nsCOMPtr<nsIProfileUnlocker> unlocker;
|
|
rv = profile->Lock(getter_AddRefs(unlocker), aResult);
|
|
if (NS_SUCCEEDED(rv)) {
|
|
if (aProfileName)
|
|
aProfileName->Assign(nsDependentCString(arg));
|
|
return NS_OK;
|
|
}
|
|
|
|
return ProfileLockedDialog(profile, unlocker, aNative, aResult);
|
|
}
|
|
|
|
if (CanShowProfileManager()) {
|
|
return ShowProfileManager(aProfileSvc, aNative);
|
|
}
|
|
}
|
|
|
|
ar = CheckArg("profilemanager", true);
|
|
if (ar == ARG_BAD) {
|
|
PR_fprintf(PR_STDERR, "Error: argument --profilemanager is invalid when argument --osint is specified\n");
|
|
return NS_ERROR_FAILURE;
|
|
} else if (ar == ARG_FOUND && CanShowProfileManager()) {
|
|
return ShowProfileManager(aProfileSvc, aNative);
|
|
}
|
|
|
|
#ifndef MOZ_DEV_EDITION
|
|
// If the only existing profile is the dev-edition-profile and this is not
|
|
// Developer Edition, then no valid profiles were found.
|
|
if (count == 1) {
|
|
nsCOMPtr<nsIToolkitProfile> deProfile;
|
|
// GetSelectedProfile will auto-select the only profile if there's just one
|
|
aProfileSvc->GetSelectedProfile(getter_AddRefs(deProfile));
|
|
nsAutoCString profileName;
|
|
deProfile->GetName(profileName);
|
|
if (profileName.EqualsLiteral("dev-edition-default")) {
|
|
count = 0;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
if (!count) {
|
|
gDoMigration = true;
|
|
gDoProfileReset = false;
|
|
|
|
// create a default profile
|
|
nsCOMPtr<nsIToolkitProfile> profile;
|
|
nsresult rv = aProfileSvc->CreateProfile(nullptr, // choose a default dir for us
|
|
#ifdef MOZ_DEV_EDITION
|
|
NS_LITERAL_CSTRING("dev-edition-default"),
|
|
#else
|
|
NS_LITERAL_CSTRING("default"),
|
|
#endif
|
|
getter_AddRefs(profile));
|
|
if (NS_SUCCEEDED(rv)) {
|
|
#ifndef MOZ_DEV_EDITION
|
|
aProfileSvc->SetDefaultProfile(profile);
|
|
#endif
|
|
aProfileSvc->Flush();
|
|
rv = profile->Lock(nullptr, aResult);
|
|
if (NS_SUCCEEDED(rv)) {
|
|
if (aProfileName)
|
|
#ifdef MOZ_DEV_EDITION
|
|
aProfileName->AssignLiteral("dev-edition-default");
|
|
#else
|
|
aProfileName->AssignLiteral("default");
|
|
#endif
|
|
return NS_OK;
|
|
}
|
|
}
|
|
}
|
|
|
|
bool useDefault = true;
|
|
if (count > 1 && CanShowProfileManager()) {
|
|
aProfileSvc->GetStartWithLastProfile(&useDefault);
|
|
}
|
|
|
|
if (useDefault) {
|
|
nsCOMPtr<nsIToolkitProfile> profile;
|
|
// GetSelectedProfile will auto-select the only profile if there's just one
|
|
aProfileSvc->GetSelectedProfile(getter_AddRefs(profile));
|
|
if (profile) {
|
|
// If we're resetting a profile, create a new one and use it to startup.
|
|
if (gDoProfileReset) {
|
|
{
|
|
// Check that the source profile is not in use by temporarily acquiring its lock.
|
|
nsIProfileLock* tempProfileLock;
|
|
nsCOMPtr<nsIProfileUnlocker> unlocker;
|
|
rv = profile->Lock(getter_AddRefs(unlocker), &tempProfileLock);
|
|
if (NS_FAILED(rv))
|
|
return ProfileLockedDialog(profile, unlocker, aNative, &tempProfileLock);
|
|
}
|
|
|
|
nsresult gotName = profile->GetName(gResetOldProfileName);
|
|
if (NS_SUCCEEDED(gotName)) {
|
|
nsCOMPtr<nsIToolkitProfile> newProfile;
|
|
rv = CreateResetProfile(aProfileSvc, gResetOldProfileName, getter_AddRefs(newProfile));
|
|
if (NS_FAILED(rv)) {
|
|
NS_WARNING("Failed to create a profile to reset to.");
|
|
gDoProfileReset = false;
|
|
}
|
|
else {
|
|
profile = newProfile;
|
|
}
|
|
}
|
|
else {
|
|
NS_WARNING("Failed to get the name of the profile we're resetting, so aborting reset.");
|
|
gResetOldProfileName.Truncate(0);
|
|
gDoProfileReset = false;
|
|
}
|
|
}
|
|
|
|
// If you close Firefox and very quickly reopen it, the old Firefox may
|
|
// still be closing down. Rather than immediately showing the
|
|
// "Firefox is running but is not responding" message, we spend a few
|
|
// seconds retrying first.
|
|
|
|
static const int kLockRetrySeconds = 5;
|
|
static const int kLockRetrySleepMS = 100;
|
|
|
|
nsCOMPtr<nsIProfileUnlocker> unlocker;
|
|
const TimeStamp start = TimeStamp::Now();
|
|
do {
|
|
rv = profile->Lock(getter_AddRefs(unlocker), aResult);
|
|
if (NS_SUCCEEDED(rv)) {
|
|
StartupTimeline::Record(StartupTimeline::AFTER_PROFILE_LOCKED);
|
|
// Try to grab the profile name.
|
|
if (aProfileName) {
|
|
rv = profile->GetName(*aProfileName);
|
|
if (NS_FAILED(rv))
|
|
aProfileName->Truncate(0);
|
|
}
|
|
return NS_OK;
|
|
}
|
|
PR_Sleep(kLockRetrySleepMS);
|
|
} while (TimeStamp::Now() - start < TimeDuration::FromSeconds(kLockRetrySeconds));
|
|
|
|
return ProfileLockedDialog(profile, unlocker, aNative, aResult);
|
|
}
|
|
}
|
|
|
|
if (!CanShowProfileManager()) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
return ShowProfileManager(aProfileSvc, aNative);
|
|
}
|
|
|
|
/**
|
|
* Checks the compatibility.ini file to see if we have updated our application
|
|
* or otherwise invalidated our caches. If the application has been updated,
|
|
* we return false; otherwise, we return true. We also write the status
|
|
* of the caches (valid/invalid) into the return param aCachesOK. The aCachesOK
|
|
* is always invalid if the application has been updated.
|
|
*/
|
|
static bool
|
|
CheckCompatibility(nsIFile* aProfileDir, const nsCString& aVersion,
|
|
const nsCString& aOSABI, nsIFile* aXULRunnerDir,
|
|
nsIFile* aAppDir, nsIFile* aFlagFile,
|
|
bool* aCachesOK)
|
|
{
|
|
*aCachesOK = false;
|
|
nsCOMPtr<nsIFile> file;
|
|
aProfileDir->Clone(getter_AddRefs(file));
|
|
if (!file)
|
|
return false;
|
|
file->AppendNative(FILE_COMPATIBILITY_INFO);
|
|
|
|
nsINIParser parser;
|
|
nsresult rv = parser.Init(file);
|
|
if (NS_FAILED(rv))
|
|
return false;
|
|
|
|
nsAutoCString buf;
|
|
rv = parser.GetString("Compatibility", "LastVersion", buf);
|
|
if (NS_FAILED(rv) || !aVersion.Equals(buf))
|
|
return false;
|
|
|
|
rv = parser.GetString("Compatibility", "LastOSABI", buf);
|
|
if (NS_FAILED(rv) || !aOSABI.Equals(buf))
|
|
return false;
|
|
|
|
rv = parser.GetString("Compatibility", "LastPlatformDir", buf);
|
|
if (NS_FAILED(rv))
|
|
return false;
|
|
|
|
nsCOMPtr<nsIFile> lf;
|
|
rv = NS_NewNativeLocalFile(buf, false,
|
|
getter_AddRefs(lf));
|
|
if (NS_FAILED(rv))
|
|
return false;
|
|
|
|
bool eq;
|
|
rv = lf->Equals(aXULRunnerDir, &eq);
|
|
if (NS_FAILED(rv) || !eq)
|
|
return false;
|
|
|
|
if (aAppDir) {
|
|
rv = parser.GetString("Compatibility", "LastAppDir", buf);
|
|
if (NS_FAILED(rv))
|
|
return false;
|
|
|
|
rv = NS_NewNativeLocalFile(buf, false,
|
|
getter_AddRefs(lf));
|
|
if (NS_FAILED(rv))
|
|
return false;
|
|
|
|
rv = lf->Equals(aAppDir, &eq);
|
|
if (NS_FAILED(rv) || !eq)
|
|
return false;
|
|
}
|
|
|
|
// If we see this flag, caches are invalid.
|
|
rv = parser.GetString("Compatibility", "InvalidateCaches", buf);
|
|
*aCachesOK = (NS_FAILED(rv) || !buf.EqualsLiteral("1"));
|
|
|
|
bool purgeCaches = false;
|
|
if (aFlagFile) {
|
|
aFlagFile->Exists(&purgeCaches);
|
|
}
|
|
|
|
*aCachesOK = !purgeCaches && *aCachesOK;
|
|
return true;
|
|
}
|
|
|
|
static void BuildVersion(nsCString &aBuf)
|
|
{
|
|
aBuf.Assign(gAppData->version);
|
|
aBuf.Append('_');
|
|
aBuf.Append(gAppData->buildID);
|
|
aBuf.Append('/');
|
|
aBuf.Append(gToolkitBuildID);
|
|
}
|
|
|
|
static void
|
|
WriteVersion(nsIFile* aProfileDir, const nsCString& aVersion,
|
|
const nsCString& aOSABI, nsIFile* aXULRunnerDir,
|
|
nsIFile* aAppDir, bool invalidateCache)
|
|
{
|
|
nsCOMPtr<nsIFile> file;
|
|
aProfileDir->Clone(getter_AddRefs(file));
|
|
if (!file)
|
|
return;
|
|
file->AppendNative(FILE_COMPATIBILITY_INFO);
|
|
|
|
nsAutoCString platformDir;
|
|
aXULRunnerDir->GetNativePath(platformDir);
|
|
|
|
nsAutoCString appDir;
|
|
if (aAppDir)
|
|
aAppDir->GetNativePath(appDir);
|
|
|
|
PRFileDesc *fd;
|
|
nsresult rv =
|
|
file->OpenNSPRFileDesc(PR_WRONLY | PR_CREATE_FILE | PR_TRUNCATE, 0600, &fd);
|
|
if (NS_FAILED(rv)) {
|
|
NS_ERROR("could not create output stream");
|
|
return;
|
|
}
|
|
|
|
static const char kHeader[] = "[Compatibility]" NS_LINEBREAK
|
|
"LastVersion=";
|
|
|
|
PR_Write(fd, kHeader, sizeof(kHeader) - 1);
|
|
PR_Write(fd, aVersion.get(), aVersion.Length());
|
|
|
|
static const char kOSABIHeader[] = NS_LINEBREAK "LastOSABI=";
|
|
PR_Write(fd, kOSABIHeader, sizeof(kOSABIHeader) - 1);
|
|
PR_Write(fd, aOSABI.get(), aOSABI.Length());
|
|
|
|
static const char kPlatformDirHeader[] = NS_LINEBREAK "LastPlatformDir=";
|
|
|
|
PR_Write(fd, kPlatformDirHeader, sizeof(kPlatformDirHeader) - 1);
|
|
PR_Write(fd, platformDir.get(), platformDir.Length());
|
|
|
|
static const char kAppDirHeader[] = NS_LINEBREAK "LastAppDir=";
|
|
if (aAppDir) {
|
|
PR_Write(fd, kAppDirHeader, sizeof(kAppDirHeader) - 1);
|
|
PR_Write(fd, appDir.get(), appDir.Length());
|
|
}
|
|
|
|
static const char kInvalidationHeader[] = NS_LINEBREAK "InvalidateCaches=1";
|
|
if (invalidateCache)
|
|
PR_Write(fd, kInvalidationHeader, sizeof(kInvalidationHeader) - 1);
|
|
|
|
static const char kNL[] = NS_LINEBREAK;
|
|
PR_Write(fd, kNL, sizeof(kNL) - 1);
|
|
|
|
PR_Close(fd);
|
|
}
|
|
|
|
/**
|
|
* Returns true if the startup cache file was successfully removed.
|
|
* Returns false if file->Clone fails at any point (OOM) or if unable
|
|
* to remove the startup cache file. Note in particular the return value
|
|
* is unaffected by a failure to remove extensions.ini
|
|
*/
|
|
static bool
|
|
RemoveComponentRegistries(nsIFile* aProfileDir, nsIFile* aLocalProfileDir,
|
|
bool aRemoveEMFiles)
|
|
{
|
|
nsCOMPtr<nsIFile> file;
|
|
aProfileDir->Clone(getter_AddRefs(file));
|
|
if (!file)
|
|
return false;
|
|
|
|
if (aRemoveEMFiles) {
|
|
file->SetNativeLeafName(NS_LITERAL_CSTRING("extensions.ini"));
|
|
file->Remove(false);
|
|
}
|
|
|
|
aLocalProfileDir->Clone(getter_AddRefs(file));
|
|
if (!file)
|
|
return false;
|
|
|
|
#if defined(XP_UNIX)
|
|
#define PLATFORM_FASL_SUFFIX ".mfasl"
|
|
#elif defined(XP_WIN)
|
|
#define PLATFORM_FASL_SUFFIX ".mfl"
|
|
#endif
|
|
|
|
file->AppendNative(NS_LITERAL_CSTRING("XUL" PLATFORM_FASL_SUFFIX));
|
|
file->Remove(false);
|
|
|
|
file->SetNativeLeafName(NS_LITERAL_CSTRING("XPC" PLATFORM_FASL_SUFFIX));
|
|
file->Remove(false);
|
|
|
|
file->SetNativeLeafName(NS_LITERAL_CSTRING("startupCache"));
|
|
nsresult rv = file->Remove(true);
|
|
return NS_SUCCEEDED(rv) || rv == NS_ERROR_FILE_TARGET_DOES_NOT_EXIST;
|
|
}
|
|
|
|
// To support application initiated restart via nsIAppStartup.quit, we
|
|
// need to save various environment variables, and then restore them
|
|
// before re-launching the application.
|
|
|
|
static struct SavedVar {
|
|
const char *name;
|
|
char *value;
|
|
} gSavedVars[] = {
|
|
{"XUL_APP_FILE", nullptr}
|
|
};
|
|
|
|
static void SaveStateForAppInitiatedRestart()
|
|
{
|
|
for (size_t i = 0; i < ArrayLength(gSavedVars); ++i) {
|
|
const char *s = PR_GetEnv(gSavedVars[i].name);
|
|
if (s)
|
|
gSavedVars[i].value = PR_smprintf("%s=%s", gSavedVars[i].name, s);
|
|
}
|
|
}
|
|
|
|
static void RestoreStateForAppInitiatedRestart()
|
|
{
|
|
for (size_t i = 0; i < ArrayLength(gSavedVars); ++i) {
|
|
if (gSavedVars[i].value)
|
|
PR_SetEnv(gSavedVars[i].value);
|
|
}
|
|
}
|
|
|
|
const nsXREAppData* gAppData = nullptr;
|
|
|
|
#ifdef MOZ_WIDGET_GTK
|
|
static void MOZ_gdk_display_close(GdkDisplay *display)
|
|
{
|
|
#if CLEANUP_MEMORY
|
|
// XXX wallpaper for bug 417163: don't close the Display if we're using the
|
|
// Qt theme because we crash (in Qt code) when using jemalloc.
|
|
bool skip_display_close = false;
|
|
GtkSettings* settings =
|
|
gtk_settings_get_for_screen(gdk_display_get_default_screen(display));
|
|
gchar *theme_name;
|
|
g_object_get(settings, "gtk-theme-name", &theme_name, nullptr);
|
|
if (theme_name) {
|
|
skip_display_close = strcmp(theme_name, "Qt") == 0;
|
|
if (skip_display_close)
|
|
NS_WARNING("wallpaper bug 417163 for Qt theme");
|
|
g_free(theme_name);
|
|
}
|
|
|
|
#if (MOZ_WIDGET_GTK == 3)
|
|
// A workaround for https://bugzilla.gnome.org/show_bug.cgi?id=703257
|
|
if (gtk_check_version(3,9,8) != NULL)
|
|
skip_display_close = true;
|
|
#endif
|
|
|
|
// Get a (new) Pango context that holds a reference to the fontmap that
|
|
// GTK has been using. gdk_pango_context_get() must be called while GTK
|
|
// has a default display.
|
|
PangoContext *pangoContext = gdk_pango_context_get();
|
|
|
|
bool buggyCairoShutdown = cairo_version() < CAIRO_VERSION_ENCODE(1, 4, 0);
|
|
|
|
if (!buggyCairoShutdown) {
|
|
// We should shut down GDK before we shut down libraries it depends on
|
|
// like Pango and cairo. But if cairo shutdown is buggy, we should
|
|
// shut down cairo first otherwise it may crash because of dangling
|
|
// references to Display objects (see bug 469831).
|
|
if (!skip_display_close)
|
|
gdk_display_close(display);
|
|
}
|
|
|
|
// Clean up PangoCairo's default fontmap.
|
|
// This pango_fc_font_map_shutdown call (and the associated code to
|
|
// get the font map) really shouldn't be needed anymore, except that
|
|
// it's needed to avoid having cairo_debug_reset_static_data fatally
|
|
// assert if we've leaked other things that hold on to the fontmap,
|
|
// which is something that currently happens in mochitest-plugins.
|
|
// Even if it didn't happen in mochitest-plugins, we probably want to
|
|
// avoid the crash-on-leak problem since it makes it harder to use
|
|
// many of our leak tools to debug leaks.
|
|
|
|
// This doesn't take a reference.
|
|
PangoFontMap *fontmap = pango_context_get_font_map(pangoContext);
|
|
// Do some shutdown of the fontmap, which releases the fonts, clearing a
|
|
// bunch of circular references from the fontmap through the fonts back to
|
|
// itself. The shutdown that this does is much less than what's done by
|
|
// the fontmap's finalize, though.
|
|
if (PANGO_IS_FC_FONT_MAP(fontmap))
|
|
pango_fc_font_map_shutdown(PANGO_FC_FONT_MAP(fontmap));
|
|
g_object_unref(pangoContext);
|
|
|
|
// Tell PangoCairo to release its default fontmap.
|
|
pango_cairo_font_map_set_default(nullptr);
|
|
|
|
// cairo_debug_reset_static_data() is prototyped through cairo.h included
|
|
// by gtk.h.
|
|
#ifdef cairo_debug_reset_static_data
|
|
#error "Looks like we're including Mozilla's cairo instead of system cairo"
|
|
#endif
|
|
cairo_debug_reset_static_data();
|
|
// FIXME: Do we need to call this in non-GTK2 cases as well?
|
|
FcFini();
|
|
|
|
if (buggyCairoShutdown) {
|
|
if (!skip_display_close)
|
|
gdk_display_close(display);
|
|
}
|
|
#else // not CLEANUP_MEMORY
|
|
// Don't do anything to avoid running into driver bugs under XCloseDisplay().
|
|
// See bug 973192.
|
|
(void) display;
|
|
#endif
|
|
}
|
|
|
|
static const char* detectDisplay(void)
|
|
{
|
|
bool tryX11 = false;
|
|
bool tryWayland = false;
|
|
bool tryBroadway = false;
|
|
|
|
// Honor user backend selection
|
|
const char *backend = PR_GetEnv("GDK_BACKEND");
|
|
if (!backend || strstr(backend, "*")) {
|
|
// Try all backends
|
|
tryX11 = true;
|
|
tryWayland = true;
|
|
tryBroadway = true;
|
|
} else if (backend) {
|
|
if (strstr(backend, "x11"))
|
|
tryX11 = true;
|
|
if (strstr(backend, "wayland"))
|
|
tryWayland = true;
|
|
if (strstr(backend, "broadway"))
|
|
tryBroadway = true;
|
|
}
|
|
|
|
const char *display_name;
|
|
if (tryX11 && (display_name = PR_GetEnv("DISPLAY"))) {
|
|
return display_name;
|
|
} else if (tryWayland && (display_name = PR_GetEnv("WAYLAND_DISPLAY"))) {
|
|
return display_name;
|
|
} else if (tryBroadway && (display_name = PR_GetEnv("BROADWAY_DISPLAY"))) {
|
|
return display_name;
|
|
}
|
|
|
|
PR_fprintf(PR_STDERR, "Error: GDK_BACKEND does not match available displays\n");
|
|
return nullptr;
|
|
}
|
|
#endif // MOZ_WIDGET_GTK
|
|
|
|
/**
|
|
* NSPR will search for the "nspr_use_zone_allocator" symbol throughout
|
|
* the process and use it to determine whether the application defines its own
|
|
* memory allocator or not.
|
|
*
|
|
* Since most applications (e.g. Firefox and Thunderbird) don't use any special
|
|
* allocators and therefore don't define this symbol, NSPR must search the
|
|
* entire process, which reduces startup performance.
|
|
*
|
|
* By defining the symbol here, we can avoid the wasted lookup and hopefully
|
|
* improve startup performance.
|
|
*/
|
|
NS_VISIBILITY_DEFAULT PRBool nspr_use_zone_allocator = PR_FALSE;
|
|
|
|
#ifdef CAIRO_HAS_DWRITE_FONT
|
|
|
|
#include <dwrite.h>
|
|
|
|
#ifdef DEBUG_DWRITE_STARTUP
|
|
|
|
#define LOGREGISTRY(msg) LogRegistryEvent(msg)
|
|
|
|
// for use when monitoring process
|
|
static void LogRegistryEvent(const wchar_t *msg)
|
|
{
|
|
HKEY dummyKey;
|
|
HRESULT hr;
|
|
wchar_t buf[512];
|
|
|
|
wsprintf(buf, L" log %s", msg);
|
|
hr = RegOpenKeyEx(HKEY_LOCAL_MACHINE, buf, 0, KEY_READ, &dummyKey);
|
|
if (SUCCEEDED(hr)) {
|
|
RegCloseKey(dummyKey);
|
|
}
|
|
}
|
|
#else
|
|
|
|
#define LOGREGISTRY(msg)
|
|
|
|
#endif
|
|
|
|
static DWORD WINAPI InitDwriteBG(LPVOID lpdwThreadParam)
|
|
{
|
|
SetThreadPriority(GetCurrentThread(), THREAD_MODE_BACKGROUND_BEGIN);
|
|
LOGREGISTRY(L"loading dwrite.dll");
|
|
HMODULE dwdll = LoadLibraryW(L"dwrite.dll");
|
|
if (dwdll) {
|
|
decltype(DWriteCreateFactory)* createDWriteFactory = (decltype(DWriteCreateFactory)*)
|
|
GetProcAddress(dwdll, "DWriteCreateFactory");
|
|
if (createDWriteFactory) {
|
|
LOGREGISTRY(L"creating dwrite factory");
|
|
IDWriteFactory *factory;
|
|
HRESULT hr = createDWriteFactory(
|
|
DWRITE_FACTORY_TYPE_SHARED,
|
|
__uuidof(IDWriteFactory),
|
|
reinterpret_cast<IUnknown**>(&factory));
|
|
if (SUCCEEDED(hr)) {
|
|
LOGREGISTRY(L"dwrite factory done");
|
|
factory->Release();
|
|
LOGREGISTRY(L"freed factory");
|
|
} else {
|
|
LOGREGISTRY(L"failed to create factory");
|
|
}
|
|
}
|
|
}
|
|
SetThreadPriority(GetCurrentThread(), THREAD_MODE_BACKGROUND_END);
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
#ifdef USE_GLX_TEST
|
|
bool fire_glxtest_process();
|
|
#endif
|
|
|
|
#include "GeckoProfiler.h"
|
|
|
|
// Encapsulates startup and shutdown state for XRE_main
|
|
class XREMain
|
|
{
|
|
public:
|
|
XREMain() :
|
|
mStartOffline(false)
|
|
, mShuttingDown(false)
|
|
#ifdef MOZ_ENABLE_XREMOTE
|
|
, mDisableRemote(false)
|
|
#endif
|
|
#if defined(MOZ_WIDGET_GTK)
|
|
, mGdkDisplay(nullptr)
|
|
#endif
|
|
{};
|
|
|
|
~XREMain() {
|
|
mScopedXPCOM = nullptr;
|
|
mAppData = nullptr;
|
|
}
|
|
|
|
int XRE_main(int argc, char* argv[], const nsXREAppData* aAppData);
|
|
int XRE_mainInit(bool* aExitFlag);
|
|
int XRE_mainStartup(bool* aExitFlag);
|
|
int portable();
|
|
nsresult XRE_mainRun();
|
|
|
|
nsCOMPtr<nsINativeAppSupport> mNativeApp;
|
|
nsCOMPtr<nsIToolkitProfileService> mProfileSvc;
|
|
nsCOMPtr<nsIFile> mProfD;
|
|
nsCOMPtr<nsIFile> mProfLD;
|
|
nsCOMPtr<nsIProfileLock> mProfileLock;
|
|
#ifdef MOZ_ENABLE_XREMOTE
|
|
nsCOMPtr<nsIRemoteService> mRemoteService;
|
|
nsProfileLock mRemoteLock;
|
|
nsCOMPtr<nsIFile> mRemoteLockDir;
|
|
#endif
|
|
|
|
UniquePtr<ScopedXPCOMStartup> mScopedXPCOM;
|
|
nsAutoPtr<mozilla::ScopedAppData> mAppData;
|
|
|
|
nsXREDirProvider mDirProvider;
|
|
nsAutoCString mProfileName;
|
|
nsAutoCString mDesktopStartupID;
|
|
|
|
bool mStartOffline;
|
|
bool mShuttingDown;
|
|
#ifdef MOZ_ENABLE_XREMOTE
|
|
bool mDisableRemote;
|
|
#endif
|
|
|
|
#if defined(MOZ_WIDGET_GTK)
|
|
GdkDisplay* mGdkDisplay;
|
|
#endif
|
|
};
|
|
|
|
//MYPAL CODE
|
|
int XREMain::portable(){
|
|
bool portable;
|
|
nsCOMPtr<nsIFile> portmodemark;
|
|
mDirProvider.GetAppDir()->Clone(getter_AddRefs(portmodemark));
|
|
portmodemark->AppendNative(NS_LITERAL_CSTRING("pmprt.mod"));
|
|
portmodemark->Exists(&portable);
|
|
if (portable) return 1;
|
|
mDirProvider.GetAppDir()->Clone(getter_AddRefs(portmodemark));
|
|
portmodemark->AppendNative(NS_LITERAL_CSTRING("pmundprt.mod"));
|
|
portmodemark->Exists(&portable);
|
|
if (portable) return 2;
|
|
else return 0;
|
|
}
|
|
|
|
/*
|
|
* XRE_mainInit - Initial setup and command line parameter processing.
|
|
* Main() will exit early if either return value != 0 or if aExitFlag is
|
|
* true.
|
|
*/
|
|
int
|
|
XREMain::XRE_mainInit(bool* aExitFlag)
|
|
{
|
|
if (!aExitFlag)
|
|
return 1;
|
|
*aExitFlag = false;
|
|
|
|
atexit(UnexpectedExit);
|
|
auto expectedShutdown = mozilla::MakeScopeExit([&] {
|
|
MozExpectedExit();
|
|
});
|
|
|
|
StartupTimeline::Record(StartupTimeline::MAIN);
|
|
|
|
if (PR_GetEnv("MOZ_CHAOSMODE")) {
|
|
ChaosFeature feature = ChaosFeature::Any;
|
|
long featureInt = strtol(PR_GetEnv("MOZ_CHAOSMODE"), nullptr, 16);
|
|
if (featureInt) {
|
|
// NOTE: MOZ_CHAOSMODE=0 or a non-hex value maps to Any feature.
|
|
feature = static_cast<ChaosFeature>(featureInt);
|
|
}
|
|
ChaosMode::SetChaosFeature(feature);
|
|
}
|
|
|
|
if (ChaosMode::isActive(ChaosFeature::Any)) {
|
|
printf_stderr("*** You are running in chaos test mode. See ChaosMode.h. ***\n");
|
|
}
|
|
|
|
nsresult rv;
|
|
ArgResult ar;
|
|
|
|
#ifdef DEBUG
|
|
if (PR_GetEnv("XRE_MAIN_BREAK"))
|
|
NS_BREAK();
|
|
#endif
|
|
|
|
#ifdef USE_GLX_TEST
|
|
// bug 639842 - it's very important to fire this process BEFORE we set up
|
|
// error handling. indeed, this process is expected to be crashy, and we
|
|
// don't want the user to see its crashes. That's the whole reason for
|
|
// doing this in a separate process.
|
|
//
|
|
// This call will cause a fork and the fork will terminate itself separately
|
|
// from the usual shutdown sequence
|
|
fire_glxtest_process();
|
|
#endif
|
|
|
|
SetupErrorHandling(gArgv[0]);
|
|
|
|
#ifdef CAIRO_HAS_DWRITE_FONT
|
|
{
|
|
// Bug 602792 - when DWriteCreateFactory is called the dwrite client dll
|
|
// starts the FntCache service if it isn't already running (it's set
|
|
// to manual startup by default in Windows 7 RTM). Subsequent DirectWrite
|
|
// calls cause the IDWriteFactory object to communicate with the FntCache
|
|
// service with a timeout; if there's no response after the timeout, the
|
|
// DirectWrite client library will assume the service isn't around and do
|
|
// manual font file I/O on _all_ system fonts. To avoid this, load the
|
|
// dwrite library and create a factory as early as possible so that the
|
|
// FntCache service is ready by the time it's needed.
|
|
|
|
if (IsVistaOrLater()) {
|
|
CreateThread(nullptr, 0, &InitDwriteBG, nullptr, 0, nullptr);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
#ifdef XP_UNIX
|
|
const char *home = PR_GetEnv("HOME");
|
|
if (!home || !*home) {
|
|
struct passwd *pw = getpwuid(geteuid());
|
|
if (!pw || !pw->pw_dir) {
|
|
Output(true, "Could not determine HOME directory");
|
|
return 1;
|
|
}
|
|
SaveWordToEnv("HOME", nsDependentCString(pw->pw_dir));
|
|
}
|
|
#endif
|
|
|
|
#ifdef MOZ_ACCESSIBILITY_ATK
|
|
// Suppress atk-bridge init at startup, until mozilla accessibility is
|
|
// initialized. This works after gnome 2.24.2.
|
|
SaveToEnv("NO_AT_BRIDGE=1");
|
|
#endif
|
|
|
|
// Check for application.ini overrides
|
|
const char* override = nullptr;
|
|
ar = CheckArg("override", true, &override);
|
|
if (ar == ARG_BAD) {
|
|
Output(true, "Incorrect number of arguments passed to --override");
|
|
return 1;
|
|
}
|
|
else if (ar == ARG_FOUND) {
|
|
nsCOMPtr<nsIFile> overrideLF;
|
|
rv = XRE_GetFileFromPath(override, getter_AddRefs(overrideLF));
|
|
if (NS_FAILED(rv)) {
|
|
Output(true, "Error: unrecognized override.ini path.\n");
|
|
return 1;
|
|
}
|
|
|
|
rv = XRE_ParseAppData(overrideLF, mAppData.get());
|
|
if (NS_FAILED(rv)) {
|
|
Output(true, "Couldn't read override.ini");
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
// Check sanity and correctness of app data.
|
|
|
|
if (!mAppData->name) {
|
|
Output(true, "Error: App:Name not specified in application.ini\n");
|
|
return 1;
|
|
}
|
|
if (!mAppData->buildID) {
|
|
Output(true, "Error: App:BuildID not specified in application.ini\n");
|
|
return 1;
|
|
}
|
|
|
|
// XXX Originally ScopedLogging was here? Now it's in XRE_main above
|
|
// XRE_mainInit.
|
|
|
|
if (!mAppData->xreDirectory) {
|
|
nsCOMPtr<nsIFile> lf;
|
|
rv = XRE_GetBinaryPath(gArgv[0], getter_AddRefs(lf));
|
|
if (NS_FAILED(rv))
|
|
return 2;
|
|
|
|
nsCOMPtr<nsIFile> greDir;
|
|
rv = lf->GetParent(getter_AddRefs(greDir));
|
|
if (NS_FAILED(rv))
|
|
return 2;
|
|
|
|
#ifdef XP_MACOSX
|
|
nsCOMPtr<nsIFile> parent;
|
|
greDir->GetParent(getter_AddRefs(parent));
|
|
greDir = parent.forget();
|
|
greDir->AppendNative(NS_LITERAL_CSTRING("Resources"));
|
|
#endif
|
|
|
|
greDir.forget(&mAppData->xreDirectory);
|
|
}
|
|
|
|
if (!mAppData->directory) {
|
|
NS_IF_ADDREF(mAppData->directory = mAppData->xreDirectory);
|
|
}
|
|
|
|
if (mAppData->size > offsetof(nsXREAppData, minVersion)) {
|
|
if (!mAppData->minVersion) {
|
|
Output(true, "Error: Gecko:MinVersion not specified in application.ini\n");
|
|
return 1;
|
|
}
|
|
|
|
if (!mAppData->maxVersion) {
|
|
// If no maxVersion is specified, we assume the app is only compatible
|
|
// with the initial preview release. Do not increment this number ever!
|
|
SetAllocatedString(mAppData->maxVersion, "1.*");
|
|
}
|
|
|
|
if (mozilla::Version(mAppData->minVersion) > gToolkitVersion ||
|
|
mozilla::Version(mAppData->maxVersion) < gToolkitVersion) {
|
|
Output(true, "Error: Platform version '%s' is not compatible with\n"
|
|
"minVersion >= %s\nmaxVersion <= %s\n",
|
|
gToolkitVersion,
|
|
mAppData->minVersion, mAppData->maxVersion);
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
rv = mDirProvider.Initialize(mAppData->directory, mAppData->xreDirectory);
|
|
if (NS_FAILED(rv))
|
|
return 1;
|
|
|
|
#ifdef XP_MACOSX
|
|
// Set up ability to respond to system (Apple) events. This must occur before
|
|
// ProcessUpdates to ensure that links clicked in external applications aren't
|
|
// lost when updates are pending.
|
|
SetupMacApplicationDelegate();
|
|
|
|
if (EnvHasValue("MOZ_LAUNCHED_CHILD")) {
|
|
// This is needed, on relaunch, to force the OS to use the "Cocoa Dock
|
|
// API". Otherwise the call to ReceiveNextEvent() below will make it
|
|
// use the "Carbon Dock API". For more info see bmo bug 377166.
|
|
EnsureUseCocoaDockAPI();
|
|
|
|
// When the app relaunches, the original process exits. This causes
|
|
// the dock tile to stop bouncing, lose the "running" triangle, and
|
|
// if the tile does not permanently reside in the Dock, even disappear.
|
|
// This can be confusing to the user, who is expecting the app to launch.
|
|
// Calling ReceiveNextEvent without requesting any event is enough to
|
|
// cause a dock tile for the child process to appear.
|
|
const EventTypeSpec kFakeEventList[] = { { INT_MAX, INT_MAX } };
|
|
EventRef event;
|
|
::ReceiveNextEvent(GetEventTypeCount(kFakeEventList), kFakeEventList,
|
|
kEventDurationNoWait, false, &event);
|
|
}
|
|
|
|
if (CheckArg("foreground")) {
|
|
// The original process communicates that it was in the foreground by
|
|
// adding this argument. This new process, which is taking over for
|
|
// the old one, should make itself the active application.
|
|
ProcessSerialNumber psn;
|
|
if (::GetCurrentProcess(&psn) == noErr)
|
|
::SetFrontProcess(&psn);
|
|
}
|
|
#endif
|
|
|
|
SaveToEnv("MOZ_LAUNCHED_CHILD=");
|
|
|
|
gRestartArgc = gArgc;
|
|
gRestartArgv = (char**) malloc(sizeof(char*) * (gArgc + 1 + (override ? 2 : 0)));
|
|
if (!gRestartArgv) {
|
|
return 1;
|
|
}
|
|
|
|
int i;
|
|
for (i = 0; i < gArgc; ++i) {
|
|
gRestartArgv[i] = gArgv[i];
|
|
}
|
|
|
|
// Add the -override argument back (it is removed automatically be CheckArg) if there is one
|
|
if (override) {
|
|
gRestartArgv[gRestartArgc++] = const_cast<char*>("-override");
|
|
gRestartArgv[gRestartArgc++] = const_cast<char*>(override);
|
|
}
|
|
|
|
gRestartArgv[gRestartArgc] = nullptr;
|
|
|
|
|
|
if (EnvHasValue("MOZ_SAFE_MODE_RESTART")) {
|
|
gSafeMode = true;
|
|
// unset the env variable
|
|
SaveToEnv("MOZ_SAFE_MODE_RESTART=");
|
|
}
|
|
|
|
ar = CheckArg("safe-mode", true);
|
|
if (ar == ARG_BAD) {
|
|
PR_fprintf(PR_STDERR, "Error: argument --safe-mode is invalid when argument --osint is specified\n");
|
|
return 1;
|
|
} else if (ar == ARG_FOUND) {
|
|
gSafeMode = true;
|
|
}
|
|
|
|
#ifdef XP_WIN
|
|
// If the shift key is pressed and the ctrl and / or alt keys are not pressed
|
|
// during startup start in safe mode. GetKeyState returns a short and the high
|
|
// order bit will be 1 if the key is pressed. By masking the returned short
|
|
// with 0x8000 the result will be 0 if the key is not pressed and non-zero
|
|
// otherwise.
|
|
if ((GetKeyState(VK_SHIFT) & 0x8000) &&
|
|
!(GetKeyState(VK_CONTROL) & 0x8000) &&
|
|
!(GetKeyState(VK_MENU) & 0x8000) &&
|
|
!EnvHasValue("MOZ_DISABLE_SAFE_MODE_KEY")) {
|
|
gSafeMode = true;
|
|
}
|
|
#endif
|
|
|
|
#ifdef XP_MACOSX
|
|
if ((GetCurrentEventKeyModifiers() & optionKey) &&
|
|
!EnvHasValue("MOZ_DISABLE_SAFE_MODE_KEY"))
|
|
gSafeMode = true;
|
|
#endif
|
|
|
|
#ifdef XP_WIN
|
|
{
|
|
// Add CPU microcode version to the crash report as "CPUMicrocodeVersion".
|
|
// It feels like this code may belong in nsSystemInfo instead.
|
|
int cpuUpdateRevision = -1;
|
|
HKEY key;
|
|
static const WCHAR keyName[] =
|
|
L"HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\0";
|
|
|
|
if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, keyName , 0, KEY_QUERY_VALUE, &key) == ERROR_SUCCESS) {
|
|
|
|
DWORD updateRevision[2];
|
|
DWORD len = sizeof(updateRevision);
|
|
DWORD vtype;
|
|
|
|
// Windows 7 uses "Update Signature", 8 uses "Update Revision".
|
|
// For AMD CPUs, "CurrentPatchLevel" is sometimes used.
|
|
// Take the first one we find.
|
|
LPCWSTR choices[] = {L"Update Signature", L"Update Revision", L"CurrentPatchLevel"};
|
|
for (size_t oneChoice=0; oneChoice<ArrayLength(choices); oneChoice++) {
|
|
if (RegQueryValueExW(key, choices[oneChoice],
|
|
0, &vtype,
|
|
reinterpret_cast<LPBYTE>(updateRevision),
|
|
&len) == ERROR_SUCCESS) {
|
|
if (vtype == REG_BINARY && len == sizeof(updateRevision)) {
|
|
// The first word is unused
|
|
cpuUpdateRevision = static_cast<int>(updateRevision[1]);
|
|
break;
|
|
} else if (vtype == REG_DWORD && len == sizeof(updateRevision[0])) {
|
|
cpuUpdateRevision = static_cast<int>(updateRevision[0]);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
#endif
|
|
|
|
// Handle --no-remote and --new-instance command line arguments. Setup
|
|
// the environment to better accommodate other components and various
|
|
// restart scenarios.
|
|
ar = CheckArg("no-remote", true);
|
|
if (ar == ARG_BAD) {
|
|
PR_fprintf(PR_STDERR, "Error: argument --no-remote is invalid when argument --osint is specified\n");
|
|
return 1;
|
|
} else if (ar == ARG_FOUND) {
|
|
SaveToEnv("MOZ_NO_REMOTE=1");
|
|
}
|
|
//MYPAL CODE
|
|
//lstrcmpW(L"Teest",L"Teest");
|
|
if (portable()==1) SaveToEnv("MOZ_NO_REMOTE=1");
|
|
|
|
ar = CheckArg("new-instance", true);
|
|
if (ar == ARG_BAD) {
|
|
PR_fprintf(PR_STDERR, "Error: argument --new-instance is invalid when argument --osint is specified\n");
|
|
return 1;
|
|
} else if (ar == ARG_FOUND) {
|
|
SaveToEnv("MOZ_NEW_INSTANCE=1");
|
|
}
|
|
|
|
// Handle --help and --version command line arguments.
|
|
// They should return quickly, so we deal with them here.
|
|
if (CheckArg("h") || CheckArg("help") || CheckArg("?")) {
|
|
DumpHelp();
|
|
*aExitFlag = true;
|
|
return 0;
|
|
}
|
|
|
|
if (CheckArg("v") || CheckArg("version")) {
|
|
DumpVersion();
|
|
*aExitFlag = true;
|
|
return 0;
|
|
}
|
|
|
|
rv = XRE_InitCommandLine(gArgc, gArgv);
|
|
NS_ENSURE_SUCCESS(rv, 1);
|
|
|
|
// Check for --register, which registers chrome and then exits immediately.
|
|
ar = CheckArg("register", true);
|
|
if (ar == ARG_BAD) {
|
|
PR_fprintf(PR_STDERR, "Error: argument --register is invalid when argument --osint is specified\n");
|
|
return 1;
|
|
} else if (ar == ARG_FOUND) {
|
|
ScopedXPCOMStartup xpcom;
|
|
rv = xpcom.Initialize();
|
|
NS_ENSURE_SUCCESS(rv, 1);
|
|
{
|
|
nsCOMPtr<nsIChromeRegistry> chromeReg =
|
|
mozilla::services::GetChromeRegistryService();
|
|
NS_ENSURE_TRUE(chromeReg, 1);
|
|
|
|
chromeReg->CheckForNewChrome();
|
|
}
|
|
*aExitFlag = true;
|
|
return 0;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
namespace mozilla {
|
|
ShutdownChecksMode gShutdownChecks = SCM_NOTHING;
|
|
} // namespace mozilla
|
|
|
|
static void SetShutdownChecks() {
|
|
// Set default first. On debug builds we crash. On nightly and local
|
|
// builds we record. Nightlies will then send the info via telemetry,
|
|
// but it is usefull to have the data in about:telemetry in local builds
|
|
// too.
|
|
|
|
#ifdef DEBUG
|
|
gShutdownChecks = SCM_CRASH;
|
|
#else
|
|
const char* releaseChannel = NS_STRINGIFY(MOZ_UPDATE_CHANNEL);
|
|
if (strcmp(releaseChannel, "nightly") == 0 ||
|
|
strcmp(releaseChannel, "default") == 0) {
|
|
gShutdownChecks = SCM_RECORD;
|
|
} else {
|
|
gShutdownChecks = SCM_NOTHING;
|
|
}
|
|
#endif
|
|
|
|
// We let an environment variable override the default so that addons
|
|
// authors can use it for debugging shutdown with released firefox versions.
|
|
const char* mozShutdownChecksEnv = PR_GetEnv("MOZ_SHUTDOWN_CHECKS");
|
|
if (mozShutdownChecksEnv) {
|
|
if (strcmp(mozShutdownChecksEnv, "crash") == 0) {
|
|
gShutdownChecks = SCM_CRASH;
|
|
} else if (strcmp(mozShutdownChecksEnv, "record") == 0) {
|
|
gShutdownChecks = SCM_RECORD;
|
|
} else if (strcmp(mozShutdownChecksEnv, "nothing") == 0) {
|
|
gShutdownChecks = SCM_NOTHING;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
/*
|
|
* XRE_mainStartup - Initializes the profile and various other services.
|
|
* Main() will exit early if either return value != 0 or if aExitFlag is
|
|
* true.
|
|
*/
|
|
int
|
|
XREMain::XRE_mainStartup(bool* aExitFlag)
|
|
{
|
|
nsresult rv;
|
|
|
|
if (!aExitFlag)
|
|
return 1;
|
|
*aExitFlag = false;
|
|
|
|
SetShutdownChecks();
|
|
|
|
// Enable Telemetry IO Reporting on DEBUG, nightly and local builds
|
|
#ifdef DEBUG
|
|
mozilla::Telemetry::InitIOReporting(gAppData->xreDirectory);
|
|
#else
|
|
{
|
|
const char* releaseChannel = NS_STRINGIFY(MOZ_UPDATE_CHANNEL);
|
|
if (strcmp(releaseChannel, "nightly") == 0 ||
|
|
strcmp(releaseChannel, "default") == 0) {
|
|
mozilla::Telemetry::InitIOReporting(gAppData->xreDirectory);
|
|
}
|
|
}
|
|
#endif /* DEBUG */
|
|
|
|
#if defined(MOZ_WIDGET_GTK) || defined(MOZ_ENABLE_XREMOTE)
|
|
// Stash DESKTOP_STARTUP_ID in malloc'ed memory because gtk_init will clear it.
|
|
#define HAVE_DESKTOP_STARTUP_ID
|
|
const char* desktopStartupIDEnv = PR_GetEnv("DESKTOP_STARTUP_ID");
|
|
if (desktopStartupIDEnv) {
|
|
mDesktopStartupID.Assign(desktopStartupIDEnv);
|
|
}
|
|
#endif
|
|
|
|
#if defined(MOZ_WIDGET_GTK)
|
|
// setup for private colormap. Ideally we'd like to do this
|
|
// in nsAppShell::Create, but we need to get in before gtk
|
|
// has been initialized to make sure everything is running
|
|
// consistently.
|
|
#if (MOZ_WIDGET_GTK == 2)
|
|
if (CheckArg("install"))
|
|
gdk_rgb_set_install(TRUE);
|
|
#endif
|
|
|
|
// Set program name to the one defined in application.ini.
|
|
{
|
|
nsAutoCString program(gAppData->name);
|
|
ToLowerCase(program);
|
|
g_set_prgname(program.get());
|
|
}
|
|
|
|
// Initialize GTK here for splash.
|
|
|
|
#if (MOZ_WIDGET_GTK == 3) && defined(MOZ_X11)
|
|
// Disable XInput2 support due to focus bugginess. See bugs 1182700, 1170342.
|
|
const char* useXI2 = PR_GetEnv("MOZ_USE_XINPUT2");
|
|
if (!useXI2 || (*useXI2 == '0'))
|
|
gdk_disable_multidevice();
|
|
#endif
|
|
|
|
// Open the display ourselves instead of using gtk_init, so that we can
|
|
// close it without fear that one day gtk might clean up the display it
|
|
// opens.
|
|
if (!gtk_parse_args(&gArgc, &gArgv))
|
|
return 1;
|
|
#endif /* MOZ_WIDGET_GTK */
|
|
|
|
#ifdef LIBFUZZER
|
|
if (PR_GetEnv("LIBFUZZER")) {
|
|
*aExitFlag = true;
|
|
return mozilla::libFuzzerRunner->Run();
|
|
}
|
|
#endif
|
|
|
|
if (PR_GetEnv("MOZ_RUN_GTEST")) {
|
|
int result;
|
|
#ifdef XP_WIN
|
|
UseParentConsole();
|
|
#endif
|
|
// RunGTest will only be set if we're in xul-unit
|
|
if (mozilla::RunGTest) {
|
|
gIsGtest = true;
|
|
result = mozilla::RunGTest();
|
|
gIsGtest = false;
|
|
} else {
|
|
result = 1;
|
|
printf("TEST-UNEXPECTED-FAIL | gtest | Not compiled with enable-tests\n");
|
|
}
|
|
*aExitFlag = true;
|
|
return result;
|
|
}
|
|
|
|
#if defined(MOZ_WIDGET_GTK)
|
|
// display_name is owned by gdk.
|
|
const char *display_name = gdk_get_display_arg_name();
|
|
bool saveDisplayArg = false;
|
|
if (display_name) {
|
|
saveDisplayArg = true;
|
|
} else {
|
|
display_name = detectDisplay();
|
|
if (!display_name) {
|
|
return 1;
|
|
}
|
|
}
|
|
#endif /* MOZ_WIDGET_GTK */
|
|
#ifdef MOZ_X11
|
|
// Init X11 in thread-safe mode. Must be called prior to the first call to XOpenDisplay
|
|
// (called inside gdk_display_open). This is a requirement for off main tread compositing.
|
|
XInitThreads();
|
|
#endif
|
|
#if defined(MOZ_WIDGET_GTK)
|
|
mGdkDisplay = gdk_display_open(display_name);
|
|
if (!mGdkDisplay) {
|
|
PR_fprintf(PR_STDERR, "Error: cannot open display: %s\n", display_name);
|
|
return 1;
|
|
}
|
|
gdk_display_manager_set_default_display (gdk_display_manager_get(),
|
|
mGdkDisplay);
|
|
if (GDK_IS_X11_DISPLAY(mGdkDisplay)) {
|
|
if (saveDisplayArg) {
|
|
SaveWordToEnv("DISPLAY", nsDependentCString(display_name));
|
|
}
|
|
} else {
|
|
mDisableRemote = true;
|
|
}
|
|
#endif
|
|
#ifdef MOZ_ENABLE_XREMOTE
|
|
// handle --remote now that xpcom is fired up
|
|
bool newInstance;
|
|
{
|
|
char *e = PR_GetEnv("MOZ_NO_REMOTE");
|
|
mDisableRemote = (mDisableRemote || (e && *e));
|
|
if (mDisableRemote) {
|
|
newInstance = true;
|
|
} else {
|
|
e = PR_GetEnv("MOZ_NEW_INSTANCE");
|
|
newInstance = (e && *e);
|
|
}
|
|
}
|
|
|
|
if (!newInstance) {
|
|
nsAutoCString program(gAppData->remotingName);
|
|
ToLowerCase(program);
|
|
|
|
const char* username = getenv("LOGNAME");
|
|
const char* profile = nullptr;
|
|
|
|
RemoteResult rr = ParseRemoteCommandLine(program, &profile, &username);
|
|
if (rr == REMOTE_ARG_BAD) {
|
|
return 1;
|
|
}
|
|
|
|
if (!username) {
|
|
struct passwd *pw = getpwuid(geteuid());
|
|
if (pw && pw->pw_name) {
|
|
// Beware that another call to getpwent/getpwname/getpwuid will overwrite
|
|
// pw, but we don't have such another call between here and when username
|
|
// is used last.
|
|
username = pw->pw_name;
|
|
}
|
|
}
|
|
|
|
nsCOMPtr<nsIFile> mutexDir;
|
|
rv = GetSpecialSystemDirectory(OS_TemporaryDirectory, getter_AddRefs(mutexDir));
|
|
if (NS_SUCCEEDED(rv)) {
|
|
nsAutoCString mutexPath = program + NS_LITERAL_CSTRING("_");
|
|
// In the unlikely even that LOGNAME is not set and getpwuid failed, just
|
|
// don't put the username in the mutex directory. It will conflict with
|
|
// other users mutex, but the worst that can happen is that they wait for
|
|
// MOZ_XREMOTE_START_TIMEOUT_SEC during startup in that case.
|
|
if (username) {
|
|
mutexPath.Append(username);
|
|
}
|
|
if (profile) {
|
|
mutexPath.Append(NS_LITERAL_CSTRING("_") + nsDependentCString(profile));
|
|
}
|
|
mutexDir->AppendNative(mutexPath);
|
|
|
|
rv = mutexDir->Create(nsIFile::DIRECTORY_TYPE, 0700);
|
|
if (NS_SUCCEEDED(rv) || rv == NS_ERROR_FILE_ALREADY_EXISTS) {
|
|
mRemoteLockDir = mutexDir;
|
|
}
|
|
}
|
|
|
|
if (mRemoteLockDir) {
|
|
const TimeStamp epoch = mozilla::TimeStamp::Now();
|
|
do {
|
|
rv = mRemoteLock.Lock(mRemoteLockDir, nullptr);
|
|
if (NS_SUCCEEDED(rv))
|
|
break;
|
|
sched_yield();
|
|
} while ((TimeStamp::Now() - epoch)
|
|
< TimeDuration::FromSeconds(MOZ_XREMOTE_START_TIMEOUT_SEC));
|
|
if (NS_FAILED(rv)) {
|
|
NS_WARNING("Cannot lock XRemote start mutex");
|
|
}
|
|
}
|
|
|
|
// Try to remote the entire command line. If this fails, start up normally.
|
|
const char* desktopStartupIDPtr =
|
|
mDesktopStartupID.IsEmpty() ? nullptr : mDesktopStartupID.get();
|
|
|
|
rr = StartRemoteClient(desktopStartupIDPtr, program, profile, username);
|
|
if (rr == REMOTE_FOUND) {
|
|
*aExitFlag = true;
|
|
return 0;
|
|
} else if (rr == REMOTE_ARG_BAD) {
|
|
return 1;
|
|
}
|
|
}
|
|
#endif
|
|
#if defined(MOZ_WIDGET_GTK)
|
|
g_set_application_name(mAppData->name);
|
|
gtk_window_set_auto_startup_notification(false);
|
|
|
|
#if (MOZ_WIDGET_GTK == 2)
|
|
gtk_widget_set_default_colormap(gdk_rgb_get_colormap());
|
|
#endif /* (MOZ_WIDGET_GTK == 2) */
|
|
#endif /* defined(MOZ_WIDGET_GTK) */
|
|
#ifdef MOZ_X11
|
|
// Do this after initializing GDK, or GDK will install its own handler.
|
|
XRE_InstallX11ErrorHandler();
|
|
#endif
|
|
|
|
rv = NS_CreateNativeAppSupport(getter_AddRefs(mNativeApp));
|
|
if (NS_FAILED(rv))
|
|
return 1;
|
|
|
|
bool canRun = false;
|
|
rv = mNativeApp->Start(&canRun);
|
|
if (NS_FAILED(rv) || !canRun) {
|
|
return 1;
|
|
}
|
|
|
|
#if defined(HAVE_DESKTOP_STARTUP_ID) && defined(MOZ_WIDGET_GTK)
|
|
// DESKTOP_STARTUP_ID is cleared now,
|
|
// we recover it in case we need a restart.
|
|
if (!mDesktopStartupID.IsEmpty()) {
|
|
nsAutoCString desktopStartupEnv;
|
|
desktopStartupEnv.AssignLiteral("DESKTOP_STARTUP_ID=");
|
|
desktopStartupEnv.Append(mDesktopStartupID);
|
|
// Leak it with extreme prejudice!
|
|
PR_SetEnv(ToNewCString(desktopStartupEnv));
|
|
}
|
|
#endif
|
|
|
|
#if defined(MOZ_UPDATER) && !defined(MOZ_WIDGET_ANDROID)
|
|
// Check for and process any available updates
|
|
nsCOMPtr<nsIFile> updRoot;
|
|
bool persistent;
|
|
rv = mDirProvider.GetFile(XRE_UPDATE_ROOT_DIR, &persistent,
|
|
getter_AddRefs(updRoot));
|
|
// XRE_UPDATE_ROOT_DIR may fail. Fallback to appDir if failed
|
|
if (NS_FAILED(rv))
|
|
updRoot = mDirProvider.GetAppDir();
|
|
|
|
// If the MOZ_TEST_PROCESS_UPDATES environment variable already exists, then
|
|
// we are being called from the callback application.
|
|
if (EnvHasValue("MOZ_TEST_PROCESS_UPDATES")) {
|
|
// If the caller has asked us to log our arguments, do so. This is used
|
|
// to make sure that the maintenance service successfully launches the
|
|
// callback application.
|
|
const char *logFile = nullptr;
|
|
if (ARG_FOUND == CheckArg("dump-args", false, &logFile)) {
|
|
FILE* logFP = fopen(logFile, "wb");
|
|
if (logFP) {
|
|
for (int i = 1; i < gRestartArgc; ++i) {
|
|
fprintf(logFP, "%s\n", gRestartArgv[i]);
|
|
}
|
|
fclose(logFP);
|
|
}
|
|
}
|
|
*aExitFlag = true;
|
|
return 0;
|
|
}
|
|
|
|
// Support for processing an update and exiting. The MOZ_TEST_PROCESS_UPDATES
|
|
// environment variable will be part of the updater's environment and the
|
|
// application that is relaunched by the updater. When the application is
|
|
// relaunched by the updater it will be removed below and the application
|
|
// will exit.
|
|
if (CheckArg("test-process-updates")) {
|
|
SaveToEnv("MOZ_TEST_PROCESS_UPDATES=1");
|
|
}
|
|
nsCOMPtr<nsIFile> exeFile, exeDir;
|
|
rv = mDirProvider.GetFile(XRE_EXECUTABLE_FILE, &persistent,
|
|
getter_AddRefs(exeFile));
|
|
NS_ENSURE_SUCCESS(rv, 1);
|
|
rv = exeFile->GetParent(getter_AddRefs(exeDir));
|
|
NS_ENSURE_SUCCESS(rv, 1);
|
|
ProcessUpdates(mDirProvider.GetGREDir(),
|
|
exeDir,
|
|
updRoot,
|
|
gRestartArgc,
|
|
gRestartArgv,
|
|
mAppData->version);
|
|
if (EnvHasValue("MOZ_TEST_PROCESS_UPDATES")) {
|
|
SaveToEnv("MOZ_TEST_PROCESS_UPDATES=");
|
|
*aExitFlag = true;
|
|
return 0;
|
|
}
|
|
#endif
|
|
//MYPAL CODE
|
|
int prt=portable();
|
|
if (prt>0) mProfileName.Assign("\Profile");
|
|
|
|
rv = NS_NewToolkitProfileService(getter_AddRefs(mProfileSvc),prt);
|
|
if (rv == NS_ERROR_FILE_ACCESS_DENIED) {
|
|
PR_fprintf(PR_STDERR, "Error: Access was denied while trying to open files in " \
|
|
"your profile directory.\n");
|
|
}
|
|
if (NS_FAILED(rv)) {
|
|
// We failed to choose or create profile - notify user and quit
|
|
ProfileMissingDialog(mNativeApp);
|
|
return 1;
|
|
}
|
|
|
|
rv = SelectProfile(getter_AddRefs(mProfileLock), mProfileSvc, mNativeApp, &mStartOffline,
|
|
&mProfileName,prt);
|
|
if (rv == NS_ERROR_LAUNCHED_CHILD_PROCESS ||
|
|
rv == NS_ERROR_ABORT) {
|
|
*aExitFlag = true;
|
|
return 0;
|
|
}
|
|
|
|
if (NS_FAILED(rv)) {
|
|
// We failed to choose or create profile - notify user and quit
|
|
ProfileMissingDialog(mNativeApp);
|
|
return 1;
|
|
}
|
|
gProfileLock = mProfileLock;
|
|
|
|
rv = mProfileLock->GetDirectory(getter_AddRefs(mProfD));
|
|
NS_ENSURE_SUCCESS(rv, 1);
|
|
|
|
rv = mProfileLock->GetLocalDirectory(getter_AddRefs(mProfLD));
|
|
NS_ENSURE_SUCCESS(rv, 1);
|
|
|
|
rv = mDirProvider.SetProfile(mProfD, mProfLD);
|
|
NS_ENSURE_SUCCESS(rv, 1);
|
|
|
|
//////////////////////// NOW WE HAVE A PROFILE ////////////////////////
|
|
|
|
mozilla::Telemetry::SetProfileDir(mProfD);
|
|
|
|
nsAutoCString version;
|
|
BuildVersion(version);
|
|
|
|
#ifdef TARGET_OS_ABI
|
|
NS_NAMED_LITERAL_CSTRING(osABI, TARGET_OS_ABI);
|
|
#else
|
|
// No TARGET_XPCOM_ABI, but at least the OS is known
|
|
NS_NAMED_LITERAL_CSTRING(osABI, OS_TARGET "_UNKNOWN");
|
|
#endif
|
|
|
|
// Check for version compatibility with the last version of the app this
|
|
// profile was started with. The format of the version stamp is defined
|
|
// by the BuildVersion function.
|
|
// Also check to see if something has happened to invalidate our
|
|
// fastload caches, like an extension upgrade or installation.
|
|
|
|
// If we see .purgecaches, that means someone did a make.
|
|
// Re-register components to catch potential changes.
|
|
nsCOMPtr<nsIFile> flagFile;
|
|
|
|
rv = NS_ERROR_FILE_NOT_FOUND;
|
|
nsCOMPtr<nsIFile> fFlagFile;
|
|
if (mAppData->directory) {
|
|
rv = mAppData->directory->Clone(getter_AddRefs(fFlagFile));
|
|
}
|
|
flagFile = do_QueryInterface(fFlagFile);
|
|
if (flagFile) {
|
|
flagFile->AppendNative(FILE_INVALIDATE_CACHES);
|
|
}
|
|
|
|
bool cachesOK;
|
|
bool versionOK = CheckCompatibility(mProfD, version, osABI,
|
|
mDirProvider.GetGREDir(),
|
|
mAppData->directory, flagFile,
|
|
&cachesOK);
|
|
if (CheckArg("purgecaches")) {
|
|
cachesOK = false;
|
|
}
|
|
if (PR_GetEnv("MOZ_PURGE_CACHES")) {
|
|
cachesOK = false;
|
|
}
|
|
|
|
// Every time a profile is loaded by a build with a different version,
|
|
// it updates the compatibility.ini file saying what version last wrote
|
|
// the fastload caches. On subsequent launches if the version matches,
|
|
// there is no need for re-registration. If the user loads the same
|
|
// profile in different builds the component registry must be
|
|
// re-generated to prevent mysterious component loading failures.
|
|
//
|
|
bool startupCacheValid = true;
|
|
if (gSafeMode) {
|
|
startupCacheValid = RemoveComponentRegistries(mProfD, mProfLD, false);
|
|
WriteVersion(mProfD, NS_LITERAL_CSTRING("Safe Mode"), osABI,
|
|
mDirProvider.GetGREDir(), mAppData->directory, !startupCacheValid);
|
|
}
|
|
else if (versionOK) {
|
|
if (!cachesOK) {
|
|
// Remove caches, forcing component re-registration.
|
|
// The new list of additional components directories is derived from
|
|
// information in "extensions.ini".
|
|
startupCacheValid = RemoveComponentRegistries(mProfD, mProfLD, false);
|
|
|
|
// Rewrite compatibility.ini to remove the flag
|
|
WriteVersion(mProfD, version, osABI,
|
|
mDirProvider.GetGREDir(), mAppData->directory, !startupCacheValid);
|
|
}
|
|
// Nothing need be done for the normal startup case.
|
|
}
|
|
else {
|
|
// Remove caches, forcing component re-registration
|
|
// with the default set of components (this disables any potentially
|
|
// troublesome incompatible XPCOM components).
|
|
startupCacheValid = RemoveComponentRegistries(mProfD, mProfLD, true);
|
|
|
|
// Write out version
|
|
WriteVersion(mProfD, version, osABI,
|
|
mDirProvider.GetGREDir(), mAppData->directory, !startupCacheValid);
|
|
}
|
|
|
|
if (!startupCacheValid)
|
|
StartupCache::IgnoreDiskCache();
|
|
|
|
if (flagFile) {
|
|
flagFile->Remove(true);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* XRE_mainRun - Command line startup, profile migration, and
|
|
* the calling of appStartup->Run().
|
|
*/
|
|
nsresult
|
|
XREMain::XRE_mainRun()
|
|
{
|
|
nsresult rv = NS_OK;
|
|
NS_ASSERTION(mScopedXPCOM, "Scoped xpcom not initialized.");
|
|
|
|
#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");
|
|
|
|
comp = do_GetService("@mozilla.org/network/socket-transport-service;1");
|
|
|
|
comp = do_GetService("@mozilla.org/network/dns-service;1");
|
|
|
|
comp = do_GetService("@mozilla.org/network/io-service;1");
|
|
|
|
comp = do_GetService("@mozilla.org/chrome/chrome-registry;1");
|
|
|
|
comp = do_GetService("@mozilla.org/focus-event-suppressor-service;1");
|
|
}
|
|
#endif
|
|
|
|
rv = mScopedXPCOM->SetWindowCreator(mNativeApp);
|
|
NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);
|
|
|
|
if (mStartOffline) {
|
|
nsCOMPtr<nsIIOService2> io (do_GetService("@mozilla.org/network/io-service;1"));
|
|
NS_ENSURE_TRUE(io, NS_ERROR_FAILURE);
|
|
io->SetManageOfflineStatus(false);
|
|
io->SetOffline(true);
|
|
}
|
|
|
|
{
|
|
nsCOMPtr<nsIObserver> startupNotifier
|
|
(do_CreateInstance(NS_APPSTARTUPNOTIFIER_CONTRACTID, &rv));
|
|
NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);
|
|
|
|
startupNotifier->Observe(nullptr, APPSTARTUP_TOPIC, nullptr);
|
|
}
|
|
|
|
nsCOMPtr<nsIAppStartup> appStartup
|
|
(do_GetService(NS_APPSTARTUP_CONTRACTID));
|
|
NS_ENSURE_TRUE(appStartup, NS_ERROR_FAILURE);
|
|
|
|
if (gDoMigration) {
|
|
nsCOMPtr<nsIFile> file;
|
|
mDirProvider.GetAppDir()->Clone(getter_AddRefs(file));
|
|
file->AppendNative(NS_LITERAL_CSTRING("override.ini"));
|
|
nsINIParser parser;
|
|
nsresult rv = parser.Init(file);
|
|
// if override.ini doesn't exist, also check for distribution.ini
|
|
if (NS_FAILED(rv)) {
|
|
bool persistent;
|
|
mDirProvider.GetFile(XRE_APP_DISTRIBUTION_DIR, &persistent,
|
|
getter_AddRefs(file));
|
|
file->AppendNative(NS_LITERAL_CSTRING("distribution.ini"));
|
|
rv = parser.Init(file);
|
|
}
|
|
if (NS_SUCCEEDED(rv)) {
|
|
nsAutoCString buf;
|
|
rv = parser.GetString("XRE", "EnableProfileMigrator", buf);
|
|
if (NS_SUCCEEDED(rv)) {
|
|
if (buf[0] == '0' || buf[0] == 'f' || buf[0] == 'F') {
|
|
gDoMigration = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
{
|
|
nsCOMPtr<nsIToolkitProfile> profileBeingReset;
|
|
bool profileWasSelected = false;
|
|
if (gDoProfileReset) {
|
|
if (gResetOldProfileName.IsEmpty()) {
|
|
NS_WARNING("Not resetting profile as the profile has no name.");
|
|
gDoProfileReset = false;
|
|
} else {
|
|
rv = mProfileSvc->GetProfileByName(gResetOldProfileName,
|
|
getter_AddRefs(profileBeingReset));
|
|
if (NS_FAILED(rv)) {
|
|
gDoProfileReset = false;
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
nsCOMPtr<nsIToolkitProfile> defaultProfile;
|
|
// This can fail if there is no default profile.
|
|
// That shouldn't stop reset from proceeding.
|
|
nsresult gotSelected = mProfileSvc->GetSelectedProfile(getter_AddRefs(defaultProfile));
|
|
if (NS_SUCCEEDED(gotSelected)) {
|
|
profileWasSelected = defaultProfile == profileBeingReset;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Profile Migration
|
|
if (mAppData->flags & NS_XRE_ENABLE_PROFILE_MIGRATOR && gDoMigration) {
|
|
gDoMigration = false;
|
|
nsCOMPtr<nsIProfileMigrator> pm(do_CreateInstance(NS_PROFILEMIGRATOR_CONTRACTID));
|
|
if (pm) {
|
|
nsAutoCString aKey;
|
|
if (gDoProfileReset) {
|
|
// Automatically migrate from the current application if we just
|
|
// reset the profile.
|
|
// For Basilisk and Pale Moon:
|
|
// Hard-code MOZ_APP_NAME to firefox because of hard-coded type in migrator.
|
|
aKey = (((MOZ_APP_NAME == "basilisk")
|
|
|| (MOZ_APP_NAME == "palemoon"))
|
|
? "firefox" : MOZ_APP_NAME);
|
|
|
|
}
|
|
pm->Migrate(&mDirProvider, aKey, gResetOldProfileName);
|
|
}
|
|
}
|
|
|
|
if (gDoProfileReset) {
|
|
nsresult backupCreated = ProfileResetCleanup(profileBeingReset);
|
|
if (NS_FAILED(backupCreated)) NS_WARNING("Could not cleanup the profile that was reset");
|
|
|
|
nsCOMPtr<nsIToolkitProfile> newProfile;
|
|
rv = GetCurrentProfile(mProfileSvc, mProfD, getter_AddRefs(newProfile));
|
|
if (NS_SUCCEEDED(rv)) {
|
|
newProfile->SetName(gResetOldProfileName);
|
|
mProfileName.Assign(gResetOldProfileName);
|
|
// Set the new profile as the default after we're done cleaning up the old profile,
|
|
// iff that profile was already the default
|
|
if (profileWasSelected) {
|
|
rv = mProfileSvc->SetDefaultProfile(newProfile);
|
|
if (NS_FAILED(rv)) NS_WARNING("Could not set current profile as the default");
|
|
}
|
|
} else {
|
|
NS_WARNING("Could not find current profile to set as default / change name.");
|
|
}
|
|
|
|
// Need to write out the fact that the profile has been removed, the new profile
|
|
// renamed, and potentially that the selected/default profile changed.
|
|
mProfileSvc->Flush();
|
|
}
|
|
}
|
|
|
|
mDirProvider.DoStartup();
|
|
|
|
// As FilePreferences need the profile directory, we must initialize right here.
|
|
mozilla::FilePreferences::InitDirectoriesWhitelist();
|
|
mozilla::FilePreferences::InitPrefs();
|
|
|
|
OverrideDefaultLocaleIfNeeded();
|
|
|
|
appStartup->GetShuttingDown(&mShuttingDown);
|
|
|
|
nsCOMPtr<nsICommandLineRunner> cmdLine;
|
|
|
|
nsCOMPtr<nsIFile> workingDir;
|
|
rv = NS_GetSpecialDirectory(NS_OS_CURRENT_WORKING_DIR, getter_AddRefs(workingDir));
|
|
NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);
|
|
|
|
if (!mShuttingDown) {
|
|
cmdLine = do_CreateInstance("@mozilla.org/toolkit/command-line;1");
|
|
NS_ENSURE_TRUE(cmdLine, NS_ERROR_FAILURE);
|
|
|
|
rv = cmdLine->Init(gArgc, gArgv, workingDir,
|
|
nsICommandLine::STATE_INITIAL_LAUNCH);
|
|
NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);
|
|
|
|
/* Special-case services that need early access to the command
|
|
line. */
|
|
nsCOMPtr<nsIObserverService> obsService =
|
|
mozilla::services::GetObserverService();
|
|
if (obsService) {
|
|
obsService->NotifyObservers(cmdLine, "command-line-startup", nullptr);
|
|
}
|
|
}
|
|
|
|
#ifdef XP_WIN
|
|
// Hack to sync up the various environment storages. XUL_APP_FILE is special
|
|
// in that it comes from a different CRT (firefox.exe's static-linked copy).
|
|
// Ugly details in http://bugzil.la/1175039#c27
|
|
char appFile[MAX_PATH];
|
|
if (GetEnvironmentVariableA("XUL_APP_FILE", appFile, sizeof(appFile))) {
|
|
char* saved = PR_smprintf("XUL_APP_FILE=%s", appFile);
|
|
PR_SetEnv(saved);
|
|
PR_smprintf_free(saved);
|
|
}
|
|
#endif
|
|
|
|
SaveStateForAppInitiatedRestart();
|
|
|
|
// clear out any environment variables which may have been set
|
|
// during the relaunch process now that we know we won't be relaunching.
|
|
SaveToEnv("XRE_PROFILE_PATH=");
|
|
SaveToEnv("XRE_PROFILE_LOCAL_PATH=");
|
|
SaveToEnv("XRE_PROFILE_NAME=");
|
|
SaveToEnv("XRE_START_OFFLINE=");
|
|
SaveToEnv("NO_EM_RESTART=");
|
|
SaveToEnv("XUL_APP_FILE=");
|
|
SaveToEnv("XRE_BINARY_PATH=");
|
|
|
|
if (!mShuttingDown) {
|
|
rv = appStartup->CreateHiddenWindow();
|
|
NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);
|
|
|
|
#ifdef MOZ_STYLO
|
|
// We initialize Servo here so that the hidden DOM window is available,
|
|
// since initializing Servo calls style struct constructors, and the
|
|
// HackilyFindDeviceContext stuff we have right now depends on the hidden
|
|
// DOM window. When we fix that, this should move back to
|
|
// nsLayoutStatics.cpp
|
|
Servo_Initialize();
|
|
#endif
|
|
|
|
#if defined(HAVE_DESKTOP_STARTUP_ID) && defined(MOZ_WIDGET_GTK)
|
|
nsGTKToolkit* toolkit = nsGTKToolkit::GetToolkit();
|
|
if (toolkit && !mDesktopStartupID.IsEmpty()) {
|
|
toolkit->SetDesktopStartupID(mDesktopStartupID);
|
|
}
|
|
// Clear the environment variable so it won't be inherited by
|
|
// child processes and confuse things.
|
|
g_unsetenv ("DESKTOP_STARTUP_ID");
|
|
#endif
|
|
|
|
#ifdef XP_MACOSX
|
|
// we re-initialize the command-line service and do appleevents munging
|
|
// after we are sure that we're not restarting
|
|
cmdLine = do_CreateInstance("@mozilla.org/toolkit/command-line;1");
|
|
NS_ENSURE_TRUE(cmdLine, NS_ERROR_FAILURE);
|
|
|
|
CommandLineServiceMac::SetupMacCommandLine(gArgc, gArgv, false);
|
|
|
|
rv = cmdLine->Init(gArgc, gArgv,
|
|
workingDir, nsICommandLine::STATE_INITIAL_LAUNCH);
|
|
NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);
|
|
#endif
|
|
|
|
nsCOMPtr<nsIObserverService> obsService =
|
|
mozilla::services::GetObserverService();
|
|
if (obsService)
|
|
obsService->NotifyObservers(nullptr, "final-ui-startup", nullptr);
|
|
|
|
(void)appStartup->DoneStartingUp();
|
|
|
|
appStartup->GetShuttingDown(&mShuttingDown);
|
|
}
|
|
|
|
if (!mShuttingDown) {
|
|
rv = cmdLine->Run();
|
|
NS_ENSURE_SUCCESS_LOG(rv, NS_ERROR_FAILURE);
|
|
|
|
appStartup->GetShuttingDown(&mShuttingDown);
|
|
}
|
|
|
|
if (!mShuttingDown) {
|
|
#ifdef MOZ_ENABLE_XREMOTE
|
|
// if we have X remote support, start listening for requests on the
|
|
// proxy window.
|
|
if (!mDisableRemote)
|
|
mRemoteService = do_GetService("@mozilla.org/toolkit/remote-service;1");
|
|
if (mRemoteService)
|
|
mRemoteService->Startup(mAppData->remotingName, mProfileName.get());
|
|
if (mRemoteLockDir) {
|
|
mRemoteLock.Unlock();
|
|
mRemoteLockDir->Remove(false);
|
|
}
|
|
#endif /* MOZ_ENABLE_XREMOTE */
|
|
|
|
mNativeApp->Enable();
|
|
}
|
|
|
|
#ifdef MOZ_INSTRUMENT_EVENT_LOOP
|
|
if (PR_GetEnv("MOZ_INSTRUMENT_EVENT_LOOP")) {
|
|
bool logToConsole = true;
|
|
mozilla::InitEventTracing(logToConsole);
|
|
}
|
|
#endif /* MOZ_INSTRUMENT_EVENT_LOOP */
|
|
|
|
{
|
|
rv = appStartup->Run();
|
|
if (NS_FAILED(rv)) {
|
|
NS_ERROR("failed to run appstartup");
|
|
gLogConsoleErrors = true;
|
|
}
|
|
}
|
|
|
|
#ifdef MOZ_STYLO
|
|
// This, along with the call to Servo_Initialize, should eventually move back
|
|
// to nsLayoutStatics.cpp.
|
|
Servo_Shutdown();
|
|
#endif
|
|
|
|
return rv;
|
|
}
|
|
|
|
#if MOZ_WIDGET_GTK == 2
|
|
void XRE_GlibInit()
|
|
{
|
|
static bool ran_once = false;
|
|
|
|
// glib < 2.24 doesn't want g_thread_init to be invoked twice, so ensure
|
|
// we only do it once. No need for thread safety here, since this is invoked
|
|
// well before any thread is spawned.
|
|
if (!ran_once) {
|
|
// glib version < 2.36 doesn't initialize g_slice in a static initializer.
|
|
// Ensure this happens through g_thread_init (glib version < 2.32) or
|
|
// g_type_init (2.32 <= gLib version < 2.36)."
|
|
g_thread_init(nullptr);
|
|
g_type_init();
|
|
ran_once = true;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
// Separate stub function to let us specifically suppress it in Valgrind
|
|
void
|
|
XRE_CreateStatsObject()
|
|
{
|
|
// Initialize global variables used by histogram collection
|
|
// machinery that is used by by Telemetry. Note: is never de-initialised.
|
|
Telemetry::CreateStatisticsRecorder();
|
|
}
|
|
|
|
/*
|
|
* XRE_main - A class based main entry point used by most platforms.
|
|
* Note that on OSX, aAppData->xreDirectory will point to
|
|
* .app/Contents/Resources.
|
|
*/
|
|
int
|
|
XREMain::XRE_main(int argc, char* argv[], const nsXREAppData* aAppData)
|
|
{
|
|
ScopedLogging log;
|
|
|
|
// NB: this must happen after the creation of |ScopedLogging log| since
|
|
// ScopedLogging::ScopedLogging calls NS_LogInit, and
|
|
// XRE_CreateStatsObject calls Telemetry::CreateStatisticsRecorder,
|
|
// and NS_LogInit must be called before Telemetry::CreateStatisticsRecorder.
|
|
// NS_LogInit must be called before Telemetry::CreateStatisticsRecorder
|
|
// so as to avoid many log messages of the form
|
|
// WARNING: XPCOM objects created/destroyed from static ctor/dtor: [..]
|
|
// See bug 1279614.
|
|
XRE_CreateStatsObject();
|
|
|
|
char aLocal;
|
|
GeckoProfilerInitRAII profilerGuard(&aLocal);
|
|
|
|
PROFILER_LABEL("Startup", "XRE_Main",
|
|
js::ProfileEntry::Category::OTHER);
|
|
|
|
nsresult rv = NS_OK;
|
|
|
|
gArgc = argc;
|
|
gArgv = argv;
|
|
|
|
NS_ENSURE_TRUE(aAppData, 2);
|
|
|
|
mAppData = new ScopedAppData(aAppData);
|
|
if (!mAppData)
|
|
return 1;
|
|
if (!mAppData->remotingName) {
|
|
SetAllocatedString(mAppData->remotingName, mAppData->name);
|
|
}
|
|
// used throughout this file
|
|
gAppData = mAppData;
|
|
|
|
nsCOMPtr<nsIFile> binFile;
|
|
rv = XRE_GetBinaryPath(argv[0], getter_AddRefs(binFile));
|
|
NS_ENSURE_SUCCESS(rv, 1);
|
|
|
|
rv = binFile->GetPath(gAbsoluteArgv0Path);
|
|
NS_ENSURE_SUCCESS(rv, 1);
|
|
|
|
mozilla::IOInterposerInit ioInterposerGuard;
|
|
|
|
#if defined(XP_WIN)
|
|
// Some COM settings are global to the process and must be set before any non-
|
|
// trivial COM is run in the application. Since these settings may affect
|
|
// stability, we should instantiate COM ASAP so that we can ensure that these
|
|
// global settings are configured before anything can interfere.
|
|
mozilla::mscom::MainThreadRuntime msCOMRuntime;
|
|
#endif
|
|
|
|
#if MOZ_WIDGET_GTK == 2
|
|
XRE_GlibInit();
|
|
#endif
|
|
|
|
// init
|
|
bool exit = false;
|
|
int result = XRE_mainInit(&exit);
|
|
if (result != 0 || exit)
|
|
return result;
|
|
|
|
// startup
|
|
result = XRE_mainStartup(&exit);
|
|
if (result != 0 || exit)
|
|
return result;
|
|
|
|
bool appInitiatedRestart = false;
|
|
|
|
// Start the real application
|
|
mScopedXPCOM = MakeUnique<ScopedXPCOMStartup>();
|
|
if (!mScopedXPCOM)
|
|
return 1;
|
|
|
|
rv = mScopedXPCOM->Initialize();
|
|
NS_ENSURE_SUCCESS(rv, 1);
|
|
|
|
// run!
|
|
rv = XRE_mainRun();
|
|
|
|
#ifdef MOZ_INSTRUMENT_EVENT_LOOP
|
|
mozilla::ShutdownEventTracing();
|
|
#endif
|
|
|
|
gAbsoluteArgv0Path.Truncate();
|
|
|
|
// Check for an application initiated restart. This is one that
|
|
// corresponds to nsIAppStartup.quit(eRestart)
|
|
if (rv == NS_SUCCESS_RESTART_APP
|
|
|| rv == NS_SUCCESS_RESTART_APP_NOT_SAME_PROFILE) {
|
|
appInitiatedRestart = true;
|
|
|
|
// We have an application restart don't do any shutdown checks here
|
|
// In particular we don't want to poison IO for checking late-writes.
|
|
gShutdownChecks = SCM_NOTHING;
|
|
}
|
|
|
|
if (!mShuttingDown) {
|
|
#ifdef MOZ_ENABLE_XREMOTE
|
|
// shut down the x remote proxy window
|
|
if (mRemoteService) {
|
|
mRemoteService->Shutdown();
|
|
}
|
|
#endif /* MOZ_ENABLE_XREMOTE */
|
|
}
|
|
|
|
mScopedXPCOM = nullptr;
|
|
|
|
#if defined(XP_WIN)
|
|
mozilla::widget::StopAudioSession();
|
|
#endif
|
|
|
|
// unlock the profile after ScopedXPCOMStartup object (xpcom)
|
|
// has gone out of scope. see bug #386739 for more details
|
|
mProfileLock->Unlock();
|
|
gProfileLock = nullptr;
|
|
|
|
// Restart the app after XPCOM has been shut down cleanly.
|
|
if (appInitiatedRestart) {
|
|
RestoreStateForAppInitiatedRestart();
|
|
|
|
if (rv != NS_SUCCESS_RESTART_APP_NOT_SAME_PROFILE) {
|
|
// Ensure that these environment variables are set:
|
|
SaveFileToEnvIfUnset("XRE_PROFILE_PATH", mProfD);
|
|
SaveFileToEnvIfUnset("XRE_PROFILE_LOCAL_PATH", mProfLD);
|
|
SaveWordToEnvIfUnset("XRE_PROFILE_NAME", mProfileName);
|
|
}
|
|
|
|
#ifdef MOZ_WIDGET_GTK
|
|
MOZ_gdk_display_close(mGdkDisplay);
|
|
#endif
|
|
|
|
{
|
|
rv = LaunchChild(mNativeApp, true);
|
|
}
|
|
|
|
return rv == NS_ERROR_LAUNCHED_CHILD_PROCESS ? 0 : 1;
|
|
}
|
|
|
|
#ifdef MOZ_WIDGET_GTK
|
|
// gdk_display_close also calls gdk_display_manager_set_default_display
|
|
// appropriately when necessary.
|
|
MOZ_gdk_display_close(mGdkDisplay);
|
|
#endif
|
|
|
|
XRE_DeinitCommandLine();
|
|
|
|
return NS_FAILED(rv) ? 1 : 0;
|
|
}
|
|
|
|
void
|
|
XRE_StopLateWriteChecks(void) {
|
|
mozilla::StopLateWriteChecks();
|
|
}
|
|
|
|
int
|
|
XRE_main(int argc, char* argv[], const nsXREAppData* aAppData, uint32_t aFlags)
|
|
{
|
|
XREMain main;
|
|
|
|
int result = main.XRE_main(argc, argv, aAppData);
|
|
mozilla::RecordShutdownEndTimeStamp();
|
|
return result;
|
|
}
|
|
|
|
nsresult
|
|
XRE_InitCommandLine(int aArgc, char* aArgv[])
|
|
{
|
|
nsresult rv = NS_OK;
|
|
|
|
#if defined(OS_WIN)
|
|
CommandLine::Init(aArgc, aArgv);
|
|
#else
|
|
|
|
// these leak on error, but that's OK: we'll just exit()
|
|
char** canonArgs = new char*[aArgc];
|
|
|
|
// get the canonical version of the binary's path
|
|
nsCOMPtr<nsIFile> binFile;
|
|
rv = XRE_GetBinaryPath(aArgv[0], getter_AddRefs(binFile));
|
|
if (NS_FAILED(rv))
|
|
return NS_ERROR_FAILURE;
|
|
|
|
nsAutoCString canonBinPath;
|
|
rv = binFile->GetNativePath(canonBinPath);
|
|
if (NS_FAILED(rv))
|
|
return NS_ERROR_FAILURE;
|
|
|
|
canonArgs[0] = strdup(canonBinPath.get());
|
|
|
|
for (int i = 1; i < aArgc; ++i) {
|
|
if (aArgv[i]) {
|
|
canonArgs[i] = strdup(aArgv[i]);
|
|
}
|
|
}
|
|
|
|
NS_ASSERTION(!CommandLine::IsInitialized(), "Bad news!");
|
|
CommandLine::Init(aArgc, canonArgs);
|
|
|
|
for (int i = 0; i < aArgc; ++i)
|
|
free(canonArgs[i]);
|
|
delete[] canonArgs;
|
|
#endif
|
|
|
|
const char *path = nullptr;
|
|
ArgResult ar = CheckArg("greomni", true, &path);
|
|
if (ar == ARG_BAD) {
|
|
PR_fprintf(PR_STDERR,
|
|
"Error: argument --greomni requires a path argument or the "
|
|
"--osint argument was specified with the --greomni argument "
|
|
"which is invalid.\n");
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
if (!path)
|
|
return rv;
|
|
|
|
nsCOMPtr<nsIFile> greOmni;
|
|
rv = XRE_GetFileFromPath(path, getter_AddRefs(greOmni));
|
|
if (NS_FAILED(rv)) {
|
|
PR_fprintf(PR_STDERR, "Error: argument --greomni requires a valid path\n");
|
|
return rv;
|
|
}
|
|
|
|
ar = CheckArg("appomni", true, &path);
|
|
if (ar == ARG_BAD) {
|
|
PR_fprintf(PR_STDERR,
|
|
"Error: argument --appomni requires a path argument or the "
|
|
"--osint argument was specified with the --appomni argument "
|
|
"which is invalid.\n");
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
nsCOMPtr<nsIFile> appOmni;
|
|
if (path) {
|
|
rv = XRE_GetFileFromPath(path, getter_AddRefs(appOmni));
|
|
if (NS_FAILED(rv)) {
|
|
PR_fprintf(PR_STDERR, "Error: argument --appomni requires a valid path\n");
|
|
return rv;
|
|
}
|
|
}
|
|
|
|
mozilla::Omnijar::Init(greOmni, appOmni);
|
|
return rv;
|
|
}
|
|
|
|
nsresult
|
|
XRE_DeinitCommandLine()
|
|
{
|
|
nsresult rv = NS_OK;
|
|
|
|
CommandLine::Terminate();
|
|
|
|
return rv;
|
|
}
|
|
|
|
GeckoProcessType
|
|
XRE_GetProcessType()
|
|
{
|
|
return mozilla::startup::sChildProcessType;
|
|
}
|
|
|
|
bool
|
|
XRE_IsGPUProcess()
|
|
{
|
|
return XRE_GetProcessType() == GeckoProcessType_GPU;
|
|
}
|
|
|
|
bool
|
|
XRE_IsParentProcess()
|
|
{
|
|
return XRE_GetProcessType() == GeckoProcessType_Default;
|
|
}
|
|
|
|
bool
|
|
XRE_IsContentProcess()
|
|
{
|
|
return XRE_GetProcessType() == GeckoProcessType_Content;
|
|
}
|
|
|
|
// If you add anything to this enum, please update about:support to reflect it
|
|
enum {
|
|
kE10sEnabledByUser = 0,
|
|
kE10sEnabledByDefault = 1,
|
|
kE10sDisabledByUser = 2,
|
|
// kE10sDisabledInSafeMode = 3, was removed in bug 1172491.
|
|
kE10sDisabledForAccessibility = 4,
|
|
// kE10sDisabledForMacGfx = 5, was removed in bug 1068674.
|
|
// kE10sDisabledForBidi = 6, removed in bug 1309599
|
|
kE10sDisabledForAddons = 7,
|
|
kE10sForceDisabled = 8,
|
|
// kE10sDisabledForXPAcceleration = 9, removed in bug 1296353
|
|
kE10sDisabledForOperatingSystem = 10,
|
|
};
|
|
|
|
const char* kAccessibilityLastRunDatePref = "accessibility.lastLoadDate";
|
|
const char* kAccessibilityLoadedLastSessionPref = "accessibility.loadedInLastSession";
|
|
|
|
#if defined(XP_WIN)
|
|
static inline uint32_t
|
|
PRTimeToSeconds(PRTime t_usec)
|
|
{
|
|
PRTime usec_per_sec = PR_USEC_PER_SEC;
|
|
return uint32_t(t_usec /= usec_per_sec);
|
|
}
|
|
#endif
|
|
|
|
const char* kForceEnableE10sPref = "browser.tabs.remote.force-enable";
|
|
const char* kForceDisableE10sPref = "browser.tabs.remote.force-disable";
|
|
|
|
uint32_t
|
|
MultiprocessBlockPolicy() {
|
|
if (gMultiprocessBlockPolicyInitialized) {
|
|
return gMultiprocessBlockPolicy;
|
|
}
|
|
gMultiprocessBlockPolicyInitialized = true;
|
|
|
|
/**
|
|
* Avoids enabling e10s if there are add-ons installed.
|
|
*/
|
|
bool addonsCanDisable = Preferences::GetBool("extensions.e10sBlocksEnabling", false);
|
|
bool disabledByAddons = Preferences::GetBool("extensions.e10sBlockedByAddons", false);
|
|
|
|
if (addonsCanDisable && disabledByAddons) {
|
|
gMultiprocessBlockPolicy = kE10sDisabledForAddons;
|
|
}
|
|
|
|
#if defined(XP_WIN)
|
|
|
|
/**
|
|
* Avoids enabling e10s for Windows XP users on the release channel.
|
|
*/
|
|
if (!IsVistaOrLater()) {
|
|
nsAdoptingCString channelName = Preferences::GetDefaultCString("app.update.channel");
|
|
if (channelName.EqualsLiteral("release") || channelName.EqualsLiteral("esr")) {
|
|
gMultiprocessBlockPolicy = kE10sDisabledForOperatingSystem;
|
|
return gMultiprocessBlockPolicy;
|
|
}
|
|
}
|
|
|
|
bool disabledForA11y = false;
|
|
/**
|
|
* Avoids enabling e10s if accessibility has recently loaded. Performs the
|
|
* following checks:
|
|
* 1) Checks a pref indicating if a11y loaded in the last session. This pref
|
|
* is set in nsBrowserGlue.js. If a11y was loaded in the last session we
|
|
* do not enable e10s in this session.
|
|
* 2) Accessibility stores a last run date (PR_IntervalNow) when it is
|
|
* initialized (see nsBaseWidget.cpp). We check if this pref exists and
|
|
* compare it to now. If a11y hasn't run in an extended period of time or
|
|
* if the date pref does not exist we load e10s.
|
|
*/
|
|
disabledForA11y = Preferences::GetBool(kAccessibilityLoadedLastSessionPref, false);
|
|
if (!disabledForA11y &&
|
|
Preferences::HasUserValue(kAccessibilityLastRunDatePref)) {
|
|
#define ONE_WEEK_IN_SECONDS (60*60*24*7)
|
|
uint32_t a11yRunDate = Preferences::GetInt(kAccessibilityLastRunDatePref, 0);
|
|
MOZ_ASSERT(0 != a11yRunDate);
|
|
// If a11y hasn't run for a period of time, clear the pref and load e10s
|
|
uint32_t now = PRTimeToSeconds(PR_Now());
|
|
uint32_t difference = now - a11yRunDate;
|
|
if (difference > ONE_WEEK_IN_SECONDS || !a11yRunDate) {
|
|
Preferences::ClearUser(kAccessibilityLastRunDatePref);
|
|
} else {
|
|
disabledForA11y = true;
|
|
}
|
|
}
|
|
|
|
if (disabledForA11y) {
|
|
gMultiprocessBlockPolicy = kE10sDisabledForAccessibility;
|
|
}
|
|
#endif
|
|
|
|
// We do not support E10S, block by policy.
|
|
gMultiprocessBlockPolicy = kE10sForceDisabled;
|
|
|
|
return gMultiprocessBlockPolicy;
|
|
}
|
|
|
|
bool
|
|
mozilla::BrowserTabsRemoteAutostart()
|
|
{
|
|
if (gBrowserTabsRemoteAutostartInitialized) {
|
|
return gBrowserTabsRemoteAutostart;
|
|
}
|
|
gBrowserTabsRemoteAutostartInitialized = true;
|
|
|
|
// If we're in the content process, we are running E10S.
|
|
if (XRE_IsContentProcess()) {
|
|
gBrowserTabsRemoteAutostart = true;
|
|
return gBrowserTabsRemoteAutostart;
|
|
}
|
|
|
|
bool optInPref = Preferences::GetBool("browser.tabs.remote.autostart", false);
|
|
bool trialPref = Preferences::GetBool("browser.tabs.remote.autostart.2", false);
|
|
bool prefEnabled = optInPref || trialPref;
|
|
int status;
|
|
if (optInPref) {
|
|
status = kE10sEnabledByUser;
|
|
} else if (trialPref) {
|
|
status = kE10sEnabledByDefault;
|
|
} else {
|
|
status = kE10sDisabledByUser;
|
|
}
|
|
|
|
if (prefEnabled) {
|
|
uint32_t blockPolicy = MultiprocessBlockPolicy();
|
|
if (blockPolicy != 0) {
|
|
status = blockPolicy;
|
|
} else {
|
|
gBrowserTabsRemoteAutostart = true;
|
|
}
|
|
}
|
|
|
|
// Uber override pref for manual testing purposes
|
|
if (Preferences::GetBool(kForceEnableE10sPref, false)) {
|
|
gBrowserTabsRemoteAutostart = true;
|
|
prefEnabled = true;
|
|
status = kE10sEnabledByUser;
|
|
}
|
|
|
|
// Uber override pref for emergency blocking
|
|
if (gBrowserTabsRemoteAutostart &&
|
|
(Preferences::GetBool(kForceDisableE10sPref, false) ||
|
|
EnvHasValue("MOZ_FORCE_DISABLE_E10S"))) {
|
|
gBrowserTabsRemoteAutostart = false;
|
|
status = kE10sForceDisabled;
|
|
}
|
|
|
|
gBrowserTabsRemoteStatus = status;
|
|
|
|
return gBrowserTabsRemoteAutostart;
|
|
}
|
|
|
|
void
|
|
SetupErrorHandling(const char* progname)
|
|
{
|
|
#ifdef XP_WIN
|
|
/* On Windows XPSP3 and Windows Vista if DEP is configured off-by-default
|
|
we still want DEP protection: enable it explicitly and programmatically.
|
|
|
|
This function is not available on WinXPSP2 so we dynamically load it.
|
|
*/
|
|
|
|
HMODULE kernel32 = GetModuleHandleW(L"kernel32.dll");
|
|
SetProcessDEPPolicyFunc _SetProcessDEPPolicy =
|
|
(SetProcessDEPPolicyFunc) GetProcAddress(kernel32, "SetProcessDEPPolicy");
|
|
if (_SetProcessDEPPolicy)
|
|
_SetProcessDEPPolicy(PROCESS_DEP_ENABLE);
|
|
#endif
|
|
|
|
#ifdef XP_WIN32
|
|
// Suppress the "DLL Foo could not be found" dialog, such that if dependent
|
|
// libraries (such as GDI+) are not preset, we gracefully fail to load those
|
|
// XPCOM components, instead of being ungraceful.
|
|
UINT realMode = SetErrorMode(0);
|
|
realMode |= SEM_FAILCRITICALERRORS;
|
|
// If XRE_NO_WINDOWS_CRASH_DIALOG is set, suppress displaying the "This
|
|
// application has crashed" dialog box. This is mainly useful for
|
|
// automated testing environments, e.g. tinderbox, where there's no need
|
|
// for a dozen of the dialog boxes to litter the console
|
|
if (getenv("XRE_NO_WINDOWS_CRASH_DIALOG"))
|
|
realMode |= SEM_NOGPFAULTERRORBOX | SEM_NOOPENFILEERRORBOX;
|
|
|
|
SetErrorMode(realMode);
|
|
|
|
#endif
|
|
|
|
#if defined (DEBUG) && defined(XP_WIN)
|
|
// Send MSCRT Warnings, Errors and Assertions to stderr.
|
|
// See http://msdn.microsoft.com/en-us/library/1y71x448(v=VS.80).aspx
|
|
// and http://msdn.microsoft.com/en-us/library/a68f826y(v=VS.80).aspx.
|
|
|
|
_CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE);
|
|
_CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR);
|
|
_CrtSetReportMode(_CRT_ERROR, _CRTDBG_MODE_FILE);
|
|
_CrtSetReportFile(_CRT_ERROR, _CRTDBG_FILE_STDERR);
|
|
_CrtSetReportMode(_CRT_ASSERT, _CRTDBG_MODE_FILE);
|
|
_CrtSetReportFile(_CRT_ASSERT, _CRTDBG_FILE_STDERR);
|
|
|
|
_CrtSetReportHook(MSCRTReportHook);
|
|
#endif
|
|
|
|
InstallSignalHandlers(progname);
|
|
|
|
// Unbuffer stdout, needed for tinderbox tests.
|
|
setbuf(stdout, 0);
|
|
}
|
|
|
|
void
|
|
OverrideDefaultLocaleIfNeeded() {
|
|
// Read pref to decide whether to override default locale with US English.
|
|
if (mozilla::Preferences::GetBool("javascript.use_us_english_locale", false)) {
|
|
// Set the application-wide C-locale. Needed to resist fingerprinting
|
|
// of Date.toLocaleFormat(). We use the locale to "C.UTF-8" if possible,
|
|
// to avoid interfering with non-ASCII keyboard input on some Linux desktops.
|
|
// Otherwise fall back to the "C" locale, which is available on all platforms.
|
|
setlocale(LC_ALL, "C.UTF-8") || setlocale(LC_ALL, "C");
|
|
}
|
|
}
|
|
|
|
void
|
|
XRE_EnableSameExecutableForContentProc() {
|
|
if (!PR_GetEnv("MOZ_SEPARATE_CHILD_PROCESS")) {
|
|
mozilla::ipc::GeckoChildProcessHost::EnableSameExecutableForContentProc();
|
|
}
|
|
}
|