summaryrefslogtreecommitdiffstats
path: root/toolkit/components/startup
diff options
context:
space:
mode:
Diffstat (limited to 'toolkit/components/startup')
-rw-r--r--toolkit/components/startup/StartupTimeline.cpp36
-rw-r--r--toolkit/components/startup/StartupTimeline.h100
-rw-r--r--toolkit/components/startup/moz.build38
-rw-r--r--toolkit/components/startup/mozprofilerprobe.mof29
-rw-r--r--toolkit/components/startup/nsAppStartup.cpp1030
-rw-r--r--toolkit/components/startup/nsAppStartup.h76
-rw-r--r--toolkit/components/startup/nsUserInfo.h23
-rw-r--r--toolkit/components/startup/nsUserInfoMac.h25
-rw-r--r--toolkit/components/startup/nsUserInfoMac.mm84
-rw-r--r--toolkit/components/startup/nsUserInfoUnix.cpp167
-rw-r--r--toolkit/components/startup/nsUserInfoWin.cpp133
-rw-r--r--toolkit/components/startup/public/moz.build13
-rw-r--r--toolkit/components/startup/public/nsIAppStartup.idl195
-rw-r--r--toolkit/components/startup/public/nsIUserInfo.idl32
-rw-r--r--toolkit/components/startup/tests/browser/.eslintrc.js7
-rw-r--r--toolkit/components/startup/tests/browser/beforeunload.html10
-rw-r--r--toolkit/components/startup/tests/browser/browser.ini8
-rw-r--r--toolkit/components/startup/tests/browser/browser_bug511456.js47
-rw-r--r--toolkit/components/startup/tests/browser/browser_bug537449.js53
-rw-r--r--toolkit/components/startup/tests/browser/browser_crash_detection.js23
-rw-r--r--toolkit/components/startup/tests/browser/head.js29
-rw-r--r--toolkit/components/startup/tests/unit/.eslintrc.js7
-rw-r--r--toolkit/components/startup/tests/unit/head_startup.js30
-rw-r--r--toolkit/components/startup/tests/unit/test_startup_crash.js300
-rw-r--r--toolkit/components/startup/tests/unit/xpcshell.ini6
25 files changed, 2501 insertions, 0 deletions
diff --git a/toolkit/components/startup/StartupTimeline.cpp b/toolkit/components/startup/StartupTimeline.cpp
new file mode 100644
index 000000000..e4762af15
--- /dev/null
+++ b/toolkit/components/startup/StartupTimeline.cpp
@@ -0,0 +1,36 @@
+/* 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 "StartupTimeline.h"
+#include "mozilla/Telemetry.h"
+#include "mozilla/TimeStamp.h"
+#include "nsXULAppAPI.h"
+
+namespace mozilla {
+
+TimeStamp StartupTimeline::sStartupTimeline[StartupTimeline::MAX_EVENT_ID];
+const char *StartupTimeline::sStartupTimelineDesc[StartupTimeline::MAX_EVENT_ID] = {
+#define mozilla_StartupTimeline_Event(ev, desc) desc,
+#include "StartupTimeline.h"
+#undef mozilla_StartupTimeline_Event
+};
+
+} /* namespace mozilla */
+
+using mozilla::StartupTimeline;
+using mozilla::TimeStamp;
+
+/**
+ * The XRE_StartupTimeline_Record function is to be used by embedding
+ * applications that can't use mozilla::StartupTimeline::Record() directly.
+ *
+ * @param aEvent The event to be recorded, must correspond to an element of the
+ * mozilla::StartupTimeline::Event enumartion
+ * @param aWhen The time at which the event happened
+ */
+void
+XRE_StartupTimelineRecord(int aEvent, TimeStamp aWhen)
+{
+ StartupTimeline::Record((StartupTimeline::Event)aEvent, aWhen);
+}
diff --git a/toolkit/components/startup/StartupTimeline.h b/toolkit/components/startup/StartupTimeline.h
new file mode 100644
index 000000000..8a966f173
--- /dev/null
+++ b/toolkit/components/startup/StartupTimeline.h
@@ -0,0 +1,100 @@
+/* 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/. */
+
+#ifdef mozilla_StartupTimeline_Event
+mozilla_StartupTimeline_Event(PROCESS_CREATION, "process")
+mozilla_StartupTimeline_Event(START, "start")
+mozilla_StartupTimeline_Event(MAIN, "main")
+mozilla_StartupTimeline_Event(SELECT_PROFILE, "selectProfile")
+mozilla_StartupTimeline_Event(AFTER_PROFILE_LOCKED, "afterProfileLocked")
+// Record the beginning and end of startup crash detection to compare with crash stats to know whether
+// detection should be improved to start or end sooner.
+mozilla_StartupTimeline_Event(STARTUP_CRASH_DETECTION_BEGIN, "startupCrashDetectionBegin")
+mozilla_StartupTimeline_Event(STARTUP_CRASH_DETECTION_END, "startupCrashDetectionEnd")
+mozilla_StartupTimeline_Event(FIRST_PAINT, "firstPaint")
+mozilla_StartupTimeline_Event(SESSION_RESTORE_INIT, "sessionRestoreInit")
+mozilla_StartupTimeline_Event(SESSION_RESTORED, "sessionRestored")
+mozilla_StartupTimeline_Event(CREATE_TOP_LEVEL_WINDOW, "createTopLevelWindow")
+mozilla_StartupTimeline_Event(LINKER_INITIALIZED, "linkerInitialized")
+mozilla_StartupTimeline_Event(LIBRARIES_LOADED, "librariesLoaded")
+mozilla_StartupTimeline_Event(FIRST_LOAD_URI, "firstLoadURI")
+
+// The following are actually shutdown events, used to monitor the duration of shutdown
+mozilla_StartupTimeline_Event(QUIT_APPLICATION, "quitApplication")
+mozilla_StartupTimeline_Event(PROFILE_BEFORE_CHANGE, "profileBeforeChange")
+#else
+
+#ifndef mozilla_StartupTimeline
+#define mozilla_StartupTimeline
+
+#include "mozilla/TimeStamp.h"
+#include "nscore.h"
+#include "GeckoProfiler.h"
+
+#ifdef MOZ_LINKER
+extern "C" {
+/* This symbol is resolved by the custom linker. The function it resolves
+ * to dumps some statistics about the linker at the key events recorded
+ * by the startup timeline. */
+extern void __moz_linker_stats(const char *str)
+NS_VISIBILITY_DEFAULT __attribute__((weak));
+} /* extern "C" */
+#else
+
+#endif
+
+namespace mozilla {
+
+void RecordShutdownEndTimeStamp();
+void RecordShutdownStartTimeStamp();
+
+class StartupTimeline {
+public:
+ enum Event {
+ #define mozilla_StartupTimeline_Event(ev, z) ev,
+ #include "StartupTimeline.h"
+ #undef mozilla_StartupTimeline_Event
+ MAX_EVENT_ID
+ };
+
+ static TimeStamp Get(Event ev) {
+ return sStartupTimeline[ev];
+ }
+
+ static const char *Describe(Event ev) {
+ return sStartupTimelineDesc[ev];
+ }
+
+ static void Record(Event ev) {
+ PROFILER_MARKER(Describe(ev));
+ Record(ev, TimeStamp::Now());
+ }
+
+ static void Record(Event ev, TimeStamp when) {
+ sStartupTimeline[ev] = when;
+#ifdef MOZ_LINKER
+ if (__moz_linker_stats)
+ __moz_linker_stats(Describe(ev));
+#endif
+ }
+
+ static void RecordOnce(Event ev) {
+ if (!HasRecord(ev))
+ Record(ev);
+ }
+
+ static bool HasRecord(Event ev) {
+ return !sStartupTimeline[ev].IsNull();
+ }
+
+private:
+ static NS_EXTERNAL_VIS_(TimeStamp) sStartupTimeline[MAX_EVENT_ID];
+ static NS_EXTERNAL_VIS_(const char *) sStartupTimelineDesc[MAX_EVENT_ID];
+};
+
+} // namespace mozilla
+
+#endif /* mozilla_StartupTimeline */
+
+#endif /* mozilla_StartupTimeline_Event */
diff --git a/toolkit/components/startup/moz.build b/toolkit/components/startup/moz.build
new file mode 100644
index 000000000..dbd580384
--- /dev/null
+++ b/toolkit/components/startup/moz.build
@@ -0,0 +1,38 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+DIRS += ['public']
+
+EXPORTS.mozilla += [
+ 'StartupTimeline.h',
+]
+
+BROWSER_CHROME_MANIFESTS += ['tests/browser/browser.ini']
+XPCSHELL_TESTS_MANIFESTS += ['tests/unit/xpcshell.ini']
+
+UNIFIED_SOURCES += [
+ 'nsAppStartup.cpp',
+ 'StartupTimeline.cpp',
+]
+
+if CONFIG['OS_ARCH'] == 'WINNT':
+ # This file cannot be built in unified mode because of name clashes with Windows headers.
+ SOURCES += [
+ 'nsUserInfoWin.cpp',
+ ]
+elif CONFIG['MOZ_WIDGET_TOOLKIT'] == 'cocoa':
+ UNIFIED_SOURCES += [
+ 'nsUserInfoMac.mm',
+ ]
+else:
+ UNIFIED_SOURCES += [
+ 'nsUserInfoUnix.cpp',
+ ]
+
+FINAL_LIBRARY = 'xul'
+
+with Files('**'):
+ BUG_COMPONENT = ('Toolkit', 'Startup and Profile System')
diff --git a/toolkit/components/startup/mozprofilerprobe.mof b/toolkit/components/startup/mozprofilerprobe.mof
new file mode 100644
index 000000000..03379ba1d
--- /dev/null
+++ b/toolkit/components/startup/mozprofilerprobe.mof
@@ -0,0 +1,29 @@
+#pragma namespace("\\\\.\\root\\wmi")
+#pragma autorecover
+
+[dynamic: ToInstance, Description("Mozilla Generic Provider"),
+ Guid("{509962E0-406B-46F4-99BA-5A009F8D2225}")]
+class MozillaProvider : EventTrace
+{
+};
+
+[dynamic: ToInstance, Description("Mozilla Event: Places Init is complete."): Amended,
+ Guid("{A3DA04E0-57D7-482A-A1C1-61DA5F95BACB}"),
+ EventType(1)]
+class MozillaEventPlacesInit : MozillaProvider
+{
+};
+
+[dynamic: ToInstance, Description("Mozilla Event: Session Store Window Restored."): Amended,
+ Guid("{917B96B1-ECAD-4DAB-A760-8D49027748AE}"),
+ EventType(1)]
+class MozillaEventSessionStoreWindowRestored : MozillaProvider
+{
+};
+
+[dynamic: ToInstance, Description("Mozilla Event: XPCOM Shutdown."): Amended,
+ Guid("{26D1E091-0AE7-4F49-A554-4214445C505C}"),
+ EventType(1)]
+class MozillaEventXPCOMShutdown : MozillaProvider
+{
+};
diff --git a/toolkit/components/startup/nsAppStartup.cpp b/toolkit/components/startup/nsAppStartup.cpp
new file mode 100644
index 000000000..85d5afdf9
--- /dev/null
+++ b/toolkit/components/startup/nsAppStartup.cpp
@@ -0,0 +1,1030 @@
+/* -*- 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 "nsAppStartup.h"
+
+#include "nsIAppShellService.h"
+#include "nsPIDOMWindow.h"
+#include "nsIInterfaceRequestor.h"
+#include "nsIFile.h"
+#include "nsIObserverService.h"
+#include "nsIPrefBranch.h"
+#include "nsIPrefService.h"
+#include "nsIProcess.h"
+#include "nsIPromptService.h"
+#include "nsIStringBundle.h"
+#include "nsISupportsPrimitives.h"
+#include "nsIToolkitProfile.h"
+#include "nsIWebBrowserChrome.h"
+#include "nsIWindowMediator.h"
+#include "nsIWindowWatcher.h"
+#include "nsIXULRuntime.h"
+#include "nsIXULWindow.h"
+#include "nsNativeCharsetUtils.h"
+#include "nsThreadUtils.h"
+#include "nsAutoPtr.h"
+#include "nsString.h"
+#include "mozilla/Preferences.h"
+#include "GeckoProfiler.h"
+
+#include "prprf.h"
+#include "nsIInterfaceRequestorUtils.h"
+#include "nsWidgetsCID.h"
+#include "nsAppRunner.h"
+#include "nsAppShellCID.h"
+#include "nsXPCOMCIDInternal.h"
+#include "mozilla/Services.h"
+#include "nsIXPConnect.h"
+#include "jsapi.h"
+#include "js/Date.h"
+#include "prenv.h"
+#include "nsAppDirectoryServiceDefs.h"
+
+#if defined(XP_WIN)
+// Prevent collisions with nsAppStartup::GetStartupInfo()
+#undef GetStartupInfo
+#endif
+
+#include "mozilla/IOInterposer.h"
+#include "mozilla/Telemetry.h"
+#include "mozilla/StartupTimeline.h"
+
+static NS_DEFINE_CID(kAppShellCID, NS_APPSHELL_CID);
+
+#define kPrefLastSuccess "toolkit.startup.last_success"
+#define kPrefMaxResumedCrashes "toolkit.startup.max_resumed_crashes"
+#define kPrefRecentCrashes "toolkit.startup.recent_crashes"
+#define kPrefAlwaysUseSafeMode "toolkit.startup.always_use_safe_mode"
+
+#if defined(XP_WIN)
+#include "mozilla/perfprobe.h"
+/**
+ * Events sent to the system for profiling purposes
+ */
+//Keep them syncronized with the .mof file
+
+//Process-wide GUID, used by the OS to differentiate sources
+// {509962E0-406B-46F4-99BA-5A009F8D2225}
+//Keep it synchronized with the .mof file
+#define NS_APPLICATION_TRACING_CID \
+ { 0x509962E0, 0x406B, 0x46F4, \
+ { 0x99, 0xBA, 0x5A, 0x00, 0x9F, 0x8D, 0x22, 0x25} }
+
+//Event-specific GUIDs, used by the OS to differentiate events
+// {A3DA04E0-57D7-482A-A1C1-61DA5F95BACB}
+#define NS_PLACES_INIT_COMPLETE_EVENT_CID \
+ { 0xA3DA04E0, 0x57D7, 0x482A, \
+ { 0xA1, 0xC1, 0x61, 0xDA, 0x5F, 0x95, 0xBA, 0xCB} }
+// {917B96B1-ECAD-4DAB-A760-8D49027748AE}
+#define NS_SESSION_STORE_WINDOW_RESTORED_EVENT_CID \
+ { 0x917B96B1, 0xECAD, 0x4DAB, \
+ { 0xA7, 0x60, 0x8D, 0x49, 0x02, 0x77, 0x48, 0xAE} }
+// {26D1E091-0AE7-4F49-A554-4214445C505C}
+#define NS_XPCOM_SHUTDOWN_EVENT_CID \
+ { 0x26D1E091, 0x0AE7, 0x4F49, \
+ { 0xA5, 0x54, 0x42, 0x14, 0x44, 0x5C, 0x50, 0x5C} }
+
+static NS_DEFINE_CID(kApplicationTracingCID,
+ NS_APPLICATION_TRACING_CID);
+static NS_DEFINE_CID(kPlacesInitCompleteCID,
+ NS_PLACES_INIT_COMPLETE_EVENT_CID);
+static NS_DEFINE_CID(kSessionStoreWindowRestoredCID,
+ NS_SESSION_STORE_WINDOW_RESTORED_EVENT_CID);
+static NS_DEFINE_CID(kXPCOMShutdownCID,
+ NS_XPCOM_SHUTDOWN_EVENT_CID);
+#endif //defined(XP_WIN)
+
+using namespace mozilla;
+
+class nsAppExitEvent : public mozilla::Runnable {
+private:
+ RefPtr<nsAppStartup> mService;
+
+public:
+ explicit nsAppExitEvent(nsAppStartup *service) : mService(service) {}
+
+ NS_IMETHOD Run() override {
+ // Tell the appshell to exit
+ mService->mAppShell->Exit();
+
+ mService->mRunning = false;
+ return NS_OK;
+ }
+};
+
+/**
+ * Computes an approximation of the absolute time represented by @a stamp
+ * which is comparable to those obtained via PR_Now(). If the current absolute
+ * time varies a lot (e.g. DST adjustments) since the first call then the
+ * resulting times may be inconsistent.
+ *
+ * @param stamp The timestamp to be converted
+ * @returns The converted timestamp
+ */
+uint64_t ComputeAbsoluteTimestamp(PRTime prnow, TimeStamp now, TimeStamp stamp)
+{
+ static PRTime sAbsoluteNow = PR_Now();
+ static TimeStamp sMonotonicNow = TimeStamp::Now();
+
+ return sAbsoluteNow - (sMonotonicNow - stamp).ToMicroseconds();
+}
+
+//
+// nsAppStartup
+//
+
+nsAppStartup::nsAppStartup() :
+ mConsiderQuitStopper(0),
+ mRunning(false),
+ mShuttingDown(false),
+ mStartingUp(true),
+ mAttemptingQuit(false),
+ mRestart(false),
+ mInterrupted(false),
+ mIsSafeModeNecessary(false),
+ mStartupCrashTrackingEnded(false),
+ mRestartNotSameProfile(false)
+{ }
+
+
+nsresult
+nsAppStartup::Init()
+{
+ nsresult rv;
+
+ // Create widget application shell
+ mAppShell = do_GetService(kAppShellCID, &rv);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ nsCOMPtr<nsIObserverService> os =
+ mozilla::services::GetObserverService();
+ if (!os)
+ return NS_ERROR_FAILURE;
+
+ os->AddObserver(this, "quit-application", true);
+ os->AddObserver(this, "quit-application-forced", true);
+ os->AddObserver(this, "sessionstore-init-started", true);
+ os->AddObserver(this, "sessionstore-windows-restored", true);
+ os->AddObserver(this, "profile-change-teardown", true);
+ os->AddObserver(this, "xul-window-registered", true);
+ os->AddObserver(this, "xul-window-destroyed", true);
+ os->AddObserver(this, "profile-before-change", true);
+ os->AddObserver(this, "xpcom-shutdown", true);
+
+#if defined(XP_WIN)
+ os->AddObserver(this, "places-init-complete", true);
+ // This last event is only interesting to us for xperf-based measures
+
+ // Initialize interaction with profiler
+ mProbesManager =
+ new ProbeManager(
+ kApplicationTracingCID,
+ NS_LITERAL_CSTRING("Application startup probe"));
+ // Note: The operation is meant mostly for in-house profiling.
+ // Therefore, we do not warn if probes manager cannot be initialized
+
+ if (mProbesManager) {
+ mPlacesInitCompleteProbe =
+ mProbesManager->
+ GetProbe(kPlacesInitCompleteCID,
+ NS_LITERAL_CSTRING("places-init-complete"));
+ NS_WARNING_ASSERTION(mPlacesInitCompleteProbe,
+ "Cannot initialize probe 'places-init-complete'");
+
+ mSessionWindowRestoredProbe =
+ mProbesManager->
+ GetProbe(kSessionStoreWindowRestoredCID,
+ NS_LITERAL_CSTRING("sessionstore-windows-restored"));
+ NS_WARNING_ASSERTION(
+ mSessionWindowRestoredProbe,
+ "Cannot initialize probe 'sessionstore-windows-restored'");
+
+ mXPCOMShutdownProbe =
+ mProbesManager->
+ GetProbe(kXPCOMShutdownCID,
+ NS_LITERAL_CSTRING("xpcom-shutdown"));
+ NS_WARNING_ASSERTION(mXPCOMShutdownProbe,
+ "Cannot initialize probe 'xpcom-shutdown'");
+
+ rv = mProbesManager->StartSession();
+ NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+ "Cannot initialize system probe manager");
+ }
+#endif //defined(XP_WIN)
+
+ return NS_OK;
+}
+
+
+//
+// nsAppStartup->nsISupports
+//
+
+NS_IMPL_ISUPPORTS(nsAppStartup,
+ nsIAppStartup,
+ nsIWindowCreator,
+ nsIWindowCreator2,
+ nsIObserver,
+ nsISupportsWeakReference)
+
+
+//
+// nsAppStartup->nsIAppStartup
+//
+
+NS_IMETHODIMP
+nsAppStartup::CreateHiddenWindow()
+{
+#if defined(MOZ_WIDGET_GONK) || defined(MOZ_WIDGET_UIKIT)
+ return NS_OK;
+#else
+ nsCOMPtr<nsIAppShellService> appShellService
+ (do_GetService(NS_APPSHELLSERVICE_CONTRACTID));
+ NS_ENSURE_TRUE(appShellService, NS_ERROR_FAILURE);
+
+ return appShellService->CreateHiddenWindow();
+#endif
+}
+
+
+NS_IMETHODIMP
+nsAppStartup::DestroyHiddenWindow()
+{
+#if defined(MOZ_WIDGET_GONK) || defined(MOZ_WIDGET_UIKIT)
+ return NS_OK;
+#else
+ nsCOMPtr<nsIAppShellService> appShellService
+ (do_GetService(NS_APPSHELLSERVICE_CONTRACTID));
+ NS_ENSURE_TRUE(appShellService, NS_ERROR_FAILURE);
+
+ return appShellService->DestroyHiddenWindow();
+#endif
+}
+
+NS_IMETHODIMP
+nsAppStartup::Run(void)
+{
+ NS_ASSERTION(!mRunning, "Reentrant appstartup->Run()");
+
+ // If we have no windows open and no explicit calls to
+ // enterLastWindowClosingSurvivalArea, or somebody has explicitly called
+ // quit, don't bother running the event loop which would probably leave us
+ // with a zombie process.
+
+ if (!mShuttingDown && mConsiderQuitStopper != 0) {
+#ifdef XP_MACOSX
+ EnterLastWindowClosingSurvivalArea();
+#endif
+
+ mRunning = true;
+
+ nsresult rv = mAppShell->Run();
+ if (NS_FAILED(rv))
+ return rv;
+ }
+
+ nsresult retval = NS_OK;
+ if (mRestart) {
+ retval = NS_SUCCESS_RESTART_APP;
+ } else if (mRestartNotSameProfile) {
+ retval = NS_SUCCESS_RESTART_APP_NOT_SAME_PROFILE;
+ }
+
+ return retval;
+}
+
+
+
+NS_IMETHODIMP
+nsAppStartup::Quit(uint32_t aMode)
+{
+ uint32_t ferocity = (aMode & 0xF);
+
+ // Quit the application. We will asynchronously call the appshell's
+ // Exit() method via nsAppExitEvent to allow one last pass
+ // through any events in the queue. This guarantees a tidy cleanup.
+ nsresult rv = NS_OK;
+ bool postedExitEvent = false;
+
+ if (mShuttingDown)
+ return NS_OK;
+
+ // If we're considering quitting, we will only do so if:
+ if (ferocity == eConsiderQuit) {
+#ifdef XP_MACOSX
+ nsCOMPtr<nsIAppShellService> appShell
+ (do_GetService(NS_APPSHELLSERVICE_CONTRACTID));
+ bool hasHiddenPrivateWindow = false;
+ if (appShell) {
+ appShell->GetHasHiddenPrivateWindow(&hasHiddenPrivateWindow);
+ }
+ int32_t suspiciousCount = hasHiddenPrivateWindow ? 2 : 1;
+#endif
+
+ if (mConsiderQuitStopper == 0) {
+ // there are no windows...
+ ferocity = eAttemptQuit;
+ }
+#ifdef XP_MACOSX
+ else if (mConsiderQuitStopper == suspiciousCount) {
+ // ... or there is only a hiddenWindow left, and it's useless:
+
+ // Failure shouldn't be fatal, but will abort quit attempt:
+ if (!appShell)
+ return NS_OK;
+
+ bool usefulHiddenWindow;
+ appShell->GetApplicationProvidedHiddenWindow(&usefulHiddenWindow);
+ nsCOMPtr<nsIXULWindow> hiddenWindow;
+ appShell->GetHiddenWindow(getter_AddRefs(hiddenWindow));
+ // If the remaining windows are useful, we won't quit:
+ nsCOMPtr<nsIXULWindow> hiddenPrivateWindow;
+ if (hasHiddenPrivateWindow) {
+ appShell->GetHiddenPrivateWindow(getter_AddRefs(hiddenPrivateWindow));
+ if ((!hiddenWindow && !hiddenPrivateWindow) || usefulHiddenWindow)
+ return NS_OK;
+ } else if (!hiddenWindow || usefulHiddenWindow) {
+ return NS_OK;
+ }
+
+ ferocity = eAttemptQuit;
+ }
+#endif
+ }
+
+ nsCOMPtr<nsIObserverService> obsService;
+ if (ferocity == eAttemptQuit || ferocity == eForceQuit) {
+
+ nsCOMPtr<nsISimpleEnumerator> windowEnumerator;
+ nsCOMPtr<nsIWindowMediator> mediator (do_GetService(NS_WINDOWMEDIATOR_CONTRACTID));
+ if (mediator) {
+ mediator->GetEnumerator(nullptr, getter_AddRefs(windowEnumerator));
+ if (windowEnumerator) {
+ bool more;
+ windowEnumerator->HasMoreElements(&more);
+ // If we reported no windows, we definitely shouldn't be
+ // iterating any here.
+ MOZ_ASSERT_IF(!mConsiderQuitStopper, !more);
+
+ while (more) {
+ nsCOMPtr<nsISupports> window;
+ windowEnumerator->GetNext(getter_AddRefs(window));
+ nsCOMPtr<nsPIDOMWindowOuter> domWindow(do_QueryInterface(window));
+ if (domWindow) {
+ MOZ_ASSERT(domWindow->IsOuterWindow());
+ if (!domWindow->CanClose())
+ return NS_OK;
+ }
+ windowEnumerator->HasMoreElements(&more);
+ }
+ }
+ }
+
+ PROFILER_MARKER("Shutdown start");
+ mozilla::RecordShutdownStartTimeStamp();
+ mShuttingDown = true;
+ if (!mRestart) {
+ mRestart = (aMode & eRestart) != 0;
+ }
+
+ if (!mRestartNotSameProfile) {
+ mRestartNotSameProfile = (aMode & eRestartNotSameProfile) != 0;
+ }
+
+ if (mRestart || mRestartNotSameProfile) {
+ // Mark the next startup as a restart.
+ PR_SetEnv("MOZ_APP_RESTART=1");
+
+ /* Firefox-restarts reuse the process so regular process start-time isn't
+ a useful indicator of startup time anymore. */
+ TimeStamp::RecordProcessRestart();
+ }
+
+ obsService = mozilla::services::GetObserverService();
+
+ if (!mAttemptingQuit) {
+ mAttemptingQuit = true;
+#ifdef XP_MACOSX
+ // now even the Mac wants to quit when the last window is closed
+ ExitLastWindowClosingSurvivalArea();
+#endif
+ if (obsService)
+ obsService->NotifyObservers(nullptr, "quit-application-granted", nullptr);
+ }
+
+ /* Enumerate through each open window and close it. It's important to do
+ this before we forcequit because this can control whether we really quit
+ at all. e.g. if one of these windows has an unload handler that
+ opens a new window. Ugh. I know. */
+ CloseAllWindows();
+
+ if (mediator) {
+ if (ferocity == eAttemptQuit) {
+ ferocity = eForceQuit; // assume success
+
+ /* Were we able to immediately close all windows? if not, eAttemptQuit
+ failed. This could happen for a variety of reasons; in fact it's
+ very likely. Perhaps we're being called from JS and the window->Close
+ method hasn't had a chance to wrap itself up yet. So give up.
+ We'll return (with eConsiderQuit) as the remaining windows are
+ closed. */
+ mediator->GetEnumerator(nullptr, getter_AddRefs(windowEnumerator));
+ if (windowEnumerator) {
+ bool more;
+ while (windowEnumerator->HasMoreElements(&more), more) {
+ /* we can't quit immediately. we'll try again as the last window
+ finally closes. */
+ ferocity = eAttemptQuit;
+ nsCOMPtr<nsISupports> window;
+ windowEnumerator->GetNext(getter_AddRefs(window));
+ nsCOMPtr<nsPIDOMWindowOuter> domWindow = do_QueryInterface(window);
+ if (domWindow) {
+ if (!domWindow->Closed()) {
+ rv = NS_ERROR_FAILURE;
+ break;
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ if (ferocity == eForceQuit) {
+ // do it!
+
+ // No chance of the shutdown being cancelled from here on; tell people
+ // we're shutting down for sure while all services are still available.
+ if (obsService) {
+ NS_NAMED_LITERAL_STRING(shutdownStr, "shutdown");
+ NS_NAMED_LITERAL_STRING(restartStr, "restart");
+ obsService->NotifyObservers(nullptr, "quit-application",
+ (mRestart || mRestartNotSameProfile) ?
+ restartStr.get() : shutdownStr.get());
+ }
+
+ if (!mRunning) {
+ postedExitEvent = true;
+ }
+ else {
+ // no matter what, make sure we send the exit event. If
+ // worst comes to worst, we'll do a leaky shutdown but we WILL
+ // shut down. Well, assuming that all *this* stuff works ;-).
+ nsCOMPtr<nsIRunnable> event = new nsAppExitEvent(this);
+ rv = NS_DispatchToCurrentThread(event);
+ if (NS_SUCCEEDED(rv)) {
+ postedExitEvent = true;
+ }
+ else {
+ NS_WARNING("failed to dispatch nsAppExitEvent");
+ }
+ }
+ }
+
+ // turn off the reentrancy check flag, but not if we have
+ // more asynchronous work to do still.
+ if (!postedExitEvent)
+ mShuttingDown = false;
+ return rv;
+}
+
+
+void
+nsAppStartup::CloseAllWindows()
+{
+ nsCOMPtr<nsIWindowMediator> mediator
+ (do_GetService(NS_WINDOWMEDIATOR_CONTRACTID));
+
+ nsCOMPtr<nsISimpleEnumerator> windowEnumerator;
+
+ mediator->GetEnumerator(nullptr, getter_AddRefs(windowEnumerator));
+
+ if (!windowEnumerator)
+ return;
+
+ bool more;
+ while (NS_SUCCEEDED(windowEnumerator->HasMoreElements(&more)) && more) {
+ nsCOMPtr<nsISupports> isupports;
+ if (NS_FAILED(windowEnumerator->GetNext(getter_AddRefs(isupports))))
+ break;
+
+ nsCOMPtr<nsPIDOMWindowOuter> window = do_QueryInterface(isupports);
+ NS_ASSERTION(window, "not an nsPIDOMWindow");
+ if (window) {
+ MOZ_ASSERT(window->IsOuterWindow());
+ window->ForceClose();
+ }
+ }
+}
+
+NS_IMETHODIMP
+nsAppStartup::EnterLastWindowClosingSurvivalArea(void)
+{
+ ++mConsiderQuitStopper;
+ return NS_OK;
+}
+
+
+NS_IMETHODIMP
+nsAppStartup::ExitLastWindowClosingSurvivalArea(void)
+{
+ NS_ASSERTION(mConsiderQuitStopper > 0, "consider quit stopper out of bounds");
+ --mConsiderQuitStopper;
+
+ if (mRunning)
+ Quit(eConsiderQuit);
+
+ return NS_OK;
+}
+
+//
+// nsAppStartup->nsIAppStartup2
+//
+
+NS_IMETHODIMP
+nsAppStartup::GetShuttingDown(bool *aResult)
+{
+ *aResult = mShuttingDown;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAppStartup::GetStartingUp(bool *aResult)
+{
+ *aResult = mStartingUp;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAppStartup::DoneStartingUp()
+{
+ // This must be called once at most
+ MOZ_ASSERT(mStartingUp);
+
+ mStartingUp = false;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAppStartup::GetRestarting(bool *aResult)
+{
+ *aResult = mRestart;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAppStartup::GetWasRestarted(bool *aResult)
+{
+ char *mozAppRestart = PR_GetEnv("MOZ_APP_RESTART");
+
+ /* When calling PR_SetEnv() with an empty value the existing variable may
+ * be unset or set to the empty string depending on the underlying platform
+ * thus we have to check if the variable is present and not empty. */
+ *aResult = mozAppRestart && (strcmp(mozAppRestart, "") != 0);
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAppStartup::SetInterrupted(bool aInterrupted)
+{
+ mInterrupted = aInterrupted;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAppStartup::GetInterrupted(bool *aInterrupted)
+{
+ *aInterrupted = mInterrupted;
+ return NS_OK;
+}
+
+//
+// nsAppStartup->nsIWindowCreator
+//
+
+NS_IMETHODIMP
+nsAppStartup::CreateChromeWindow(nsIWebBrowserChrome *aParent,
+ uint32_t aChromeFlags,
+ nsIWebBrowserChrome **_retval)
+{
+ bool cancel;
+ return CreateChromeWindow2(aParent, aChromeFlags, 0, nullptr, nullptr, &cancel, _retval);
+}
+
+
+//
+// nsAppStartup->nsIWindowCreator2
+//
+
+NS_IMETHODIMP
+nsAppStartup::SetScreenId(uint32_t aScreenId)
+{
+ nsCOMPtr<nsIAppShellService> appShell(do_GetService(NS_APPSHELLSERVICE_CONTRACTID));
+ if (!appShell) {
+ return NS_ERROR_FAILURE;
+ }
+
+ return appShell->SetScreenId(aScreenId);
+}
+
+NS_IMETHODIMP
+nsAppStartup::CreateChromeWindow2(nsIWebBrowserChrome *aParent,
+ uint32_t aChromeFlags,
+ uint32_t aContextFlags,
+ nsITabParent *aOpeningTab,
+ mozIDOMWindowProxy* aOpener,
+ bool *aCancel,
+ nsIWebBrowserChrome **_retval)
+{
+ NS_ENSURE_ARG_POINTER(aCancel);
+ NS_ENSURE_ARG_POINTER(_retval);
+ *aCancel = false;
+ *_retval = 0;
+
+ // Non-modal windows cannot be opened if we are attempting to quit
+ if (mAttemptingQuit && (aChromeFlags & nsIWebBrowserChrome::CHROME_MODAL) == 0)
+ return NS_ERROR_ILLEGAL_DURING_SHUTDOWN;
+
+ nsCOMPtr<nsIXULWindow> newWindow;
+
+ if (aParent) {
+ nsCOMPtr<nsIXULWindow> xulParent(do_GetInterface(aParent));
+ NS_ASSERTION(xulParent, "window created using non-XUL parent. that's unexpected, but may work.");
+
+ if (xulParent)
+ xulParent->CreateNewWindow(aChromeFlags, aOpeningTab, aOpener, getter_AddRefs(newWindow));
+ // And if it fails, don't try again without a parent. It could fail
+ // intentionally (bug 115969).
+ } else { // try using basic methods:
+ /* You really shouldn't be making dependent windows without a parent.
+ But unparented modal (and therefore dependent) windows happen
+ in our codebase, so we allow it after some bellyaching: */
+ if (aChromeFlags & nsIWebBrowserChrome::CHROME_DEPENDENT)
+ NS_WARNING("dependent window created without a parent");
+
+ nsCOMPtr<nsIAppShellService> appShell(do_GetService(NS_APPSHELLSERVICE_CONTRACTID));
+ if (!appShell)
+ return NS_ERROR_FAILURE;
+
+ appShell->CreateTopLevelWindow(0, 0, aChromeFlags,
+ nsIAppShellService::SIZE_TO_CONTENT,
+ nsIAppShellService::SIZE_TO_CONTENT,
+ aOpeningTab, aOpener,
+ getter_AddRefs(newWindow));
+ }
+
+ // if anybody gave us anything to work with, use it
+ if (newWindow) {
+ newWindow->SetContextFlags(aContextFlags);
+ nsCOMPtr<nsIInterfaceRequestor> thing(do_QueryInterface(newWindow));
+ if (thing)
+ CallGetInterface(thing.get(), _retval);
+ }
+
+ return *_retval ? NS_OK : NS_ERROR_FAILURE;
+}
+
+
+//
+// nsAppStartup->nsIObserver
+//
+
+NS_IMETHODIMP
+nsAppStartup::Observe(nsISupports *aSubject,
+ const char *aTopic, const char16_t *aData)
+{
+ NS_ASSERTION(mAppShell, "appshell service notified before appshell built");
+ if (!strcmp(aTopic, "quit-application-forced")) {
+ mShuttingDown = true;
+ }
+ else if (!strcmp(aTopic, "profile-change-teardown")) {
+ if (!mShuttingDown) {
+ EnterLastWindowClosingSurvivalArea();
+ CloseAllWindows();
+ ExitLastWindowClosingSurvivalArea();
+ }
+ } else if (!strcmp(aTopic, "xul-window-registered")) {
+ EnterLastWindowClosingSurvivalArea();
+ } else if (!strcmp(aTopic, "xul-window-destroyed")) {
+ ExitLastWindowClosingSurvivalArea();
+ } else if (!strcmp(aTopic, "sessionstore-windows-restored")) {
+ StartupTimeline::Record(StartupTimeline::SESSION_RESTORED);
+ IOInterposer::EnteringNextStage();
+#if defined(XP_WIN)
+ if (mSessionWindowRestoredProbe) {
+ mSessionWindowRestoredProbe->Trigger();
+ }
+ } else if (!strcmp(aTopic, "places-init-complete")) {
+ if (mPlacesInitCompleteProbe) {
+ mPlacesInitCompleteProbe->Trigger();
+ }
+#endif //defined(XP_WIN)
+ } else if (!strcmp(aTopic, "sessionstore-init-started")) {
+ StartupTimeline::Record(StartupTimeline::SESSION_RESTORE_INIT);
+ } else if (!strcmp(aTopic, "xpcom-shutdown")) {
+ IOInterposer::EnteringNextStage();
+#if defined(XP_WIN)
+ if (mXPCOMShutdownProbe) {
+ mXPCOMShutdownProbe->Trigger();
+ }
+#endif // defined(XP_WIN)
+ } else if (!strcmp(aTopic, "quit-application")) {
+ StartupTimeline::Record(StartupTimeline::QUIT_APPLICATION);
+ } else if (!strcmp(aTopic, "profile-before-change")) {
+ StartupTimeline::Record(StartupTimeline::PROFILE_BEFORE_CHANGE);
+ } else {
+ NS_ERROR("Unexpected observer topic.");
+ }
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAppStartup::GetStartupInfo(JSContext* aCx, JS::MutableHandle<JS::Value> aRetval)
+{
+ JS::Rooted<JSObject*> obj(aCx, JS_NewPlainObject(aCx));
+
+ aRetval.setObject(*obj);
+
+ TimeStamp procTime = StartupTimeline::Get(StartupTimeline::PROCESS_CREATION);
+ TimeStamp now = TimeStamp::Now();
+ PRTime absNow = PR_Now();
+
+ if (procTime.IsNull()) {
+ bool error = false;
+
+ procTime = TimeStamp::ProcessCreation(error);
+
+ if (error) {
+ Telemetry::Accumulate(Telemetry::STARTUP_MEASUREMENT_ERRORS,
+ StartupTimeline::PROCESS_CREATION);
+ }
+
+ StartupTimeline::Record(StartupTimeline::PROCESS_CREATION, procTime);
+ }
+
+ for (int i = StartupTimeline::PROCESS_CREATION;
+ i < StartupTimeline::MAX_EVENT_ID;
+ ++i)
+ {
+ StartupTimeline::Event ev = static_cast<StartupTimeline::Event>(i);
+ TimeStamp stamp = StartupTimeline::Get(ev);
+
+ if (stamp.IsNull() && (ev == StartupTimeline::MAIN)) {
+ // Always define main to aid with bug 689256.
+ stamp = procTime;
+ MOZ_ASSERT(!stamp.IsNull());
+ Telemetry::Accumulate(Telemetry::STARTUP_MEASUREMENT_ERRORS,
+ StartupTimeline::MAIN);
+ }
+
+ if (!stamp.IsNull()) {
+ if (stamp >= procTime) {
+ PRTime prStamp = ComputeAbsoluteTimestamp(absNow, now, stamp)
+ / PR_USEC_PER_MSEC;
+ JS::Rooted<JSObject*> date(aCx, JS::NewDateObject(aCx, JS::TimeClip(prStamp)));
+ JS_DefineProperty(aCx, obj, StartupTimeline::Describe(ev), date, JSPROP_ENUMERATE);
+ } else {
+ Telemetry::Accumulate(Telemetry::STARTUP_MEASUREMENT_ERRORS, ev);
+ }
+ }
+ }
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAppStartup::GetAutomaticSafeModeNecessary(bool *_retval)
+{
+ NS_ENSURE_ARG_POINTER(_retval);
+
+ bool alwaysSafe = false;
+ Preferences::GetBool(kPrefAlwaysUseSafeMode, &alwaysSafe);
+
+ if (!alwaysSafe) {
+#if DEBUG
+ mIsSafeModeNecessary = false;
+#else
+ mIsSafeModeNecessary &= !PR_GetEnv("MOZ_DISABLE_AUTO_SAFE_MODE");
+#endif
+ }
+
+ *_retval = mIsSafeModeNecessary;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAppStartup::TrackStartupCrashBegin(bool *aIsSafeModeNecessary)
+{
+ const int32_t MAX_TIME_SINCE_STARTUP = 6 * 60 * 60 * 1000;
+ const int32_t MAX_STARTUP_BUFFER = 10;
+ nsresult rv;
+
+ mStartupCrashTrackingEnded = false;
+
+ StartupTimeline::Record(StartupTimeline::STARTUP_CRASH_DETECTION_BEGIN);
+
+ bool hasLastSuccess = Preferences::HasUserValue(kPrefLastSuccess);
+ if (!hasLastSuccess) {
+ // Clear so we don't get stuck with SafeModeNecessary returning true if we
+ // have had too many recent crashes and the last success pref is missing.
+ Preferences::ClearUser(kPrefRecentCrashes);
+ return NS_ERROR_NOT_AVAILABLE;
+ }
+
+ bool inSafeMode = false;
+ nsCOMPtr<nsIXULRuntime> xr = do_GetService(XULRUNTIME_SERVICE_CONTRACTID);
+ NS_ENSURE_TRUE(xr, NS_ERROR_FAILURE);
+
+ xr->GetInSafeMode(&inSafeMode);
+
+ PRTime replacedLockTime;
+ rv = xr->GetReplacedLockTime(&replacedLockTime);
+
+ if (NS_FAILED(rv) || !replacedLockTime) {
+ if (!inSafeMode)
+ Preferences::ClearUser(kPrefRecentCrashes);
+ GetAutomaticSafeModeNecessary(aIsSafeModeNecessary);
+ return NS_OK;
+ }
+
+ // check whether safe mode is necessary
+ int32_t maxResumedCrashes = -1;
+ rv = Preferences::GetInt(kPrefMaxResumedCrashes, &maxResumedCrashes);
+ NS_ENSURE_SUCCESS(rv, NS_OK);
+
+ int32_t recentCrashes = 0;
+ Preferences::GetInt(kPrefRecentCrashes, &recentCrashes);
+ mIsSafeModeNecessary = (recentCrashes > maxResumedCrashes && maxResumedCrashes != -1);
+
+ // Bug 731613 - Don't check if the last startup was a crash if XRE_PROFILE_PATH is set. After
+ // profile manager, the profile lock's mod. time has been changed so can't be used on this startup.
+ // After a restart, it's safe to assume the last startup was successful.
+ char *xreProfilePath = PR_GetEnv("XRE_PROFILE_PATH");
+ if (xreProfilePath) {
+ GetAutomaticSafeModeNecessary(aIsSafeModeNecessary);
+ return NS_ERROR_NOT_AVAILABLE;
+ }
+
+ // time of last successful startup
+ int32_t lastSuccessfulStartup;
+ rv = Preferences::GetInt(kPrefLastSuccess, &lastSuccessfulStartup);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ int32_t lockSeconds = (int32_t)(replacedLockTime / PR_MSEC_PER_SEC);
+
+ // started close enough to good startup so call it good
+ if (lockSeconds <= lastSuccessfulStartup + MAX_STARTUP_BUFFER
+ && lockSeconds >= lastSuccessfulStartup - MAX_STARTUP_BUFFER) {
+ GetAutomaticSafeModeNecessary(aIsSafeModeNecessary);
+ return NS_OK;
+ }
+
+ // sanity check that the pref set at last success is not greater than the current time
+ if (PR_Now() / PR_USEC_PER_SEC <= lastSuccessfulStartup)
+ return NS_ERROR_FAILURE;
+
+ // The last startup was a crash so include it in the count regardless of when it happened.
+ Telemetry::Accumulate(Telemetry::STARTUP_CRASH_DETECTED, true);
+
+ if (inSafeMode) {
+ GetAutomaticSafeModeNecessary(aIsSafeModeNecessary);
+ return NS_OK;
+ }
+
+ PRTime now = (PR_Now() / PR_USEC_PER_MSEC);
+ // if the last startup attempt which crashed was in the last 6 hours
+ if (replacedLockTime >= now - MAX_TIME_SINCE_STARTUP) {
+ NS_WARNING("Last startup was detected as a crash.");
+ recentCrashes++;
+ rv = Preferences::SetInt(kPrefRecentCrashes, recentCrashes);
+ } else {
+ // Otherwise ignore that crash and all previous since it may not be applicable anymore
+ // and we don't want someone to get stuck in safe mode if their prefs are read-only.
+ rv = Preferences::ClearUser(kPrefRecentCrashes);
+ }
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ // recalculate since recent crashes count may have changed above
+ mIsSafeModeNecessary = (recentCrashes > maxResumedCrashes && maxResumedCrashes != -1);
+
+ nsCOMPtr<nsIPrefService> prefs = Preferences::GetService();
+ rv = prefs->SavePrefFile(nullptr); // flush prefs to disk since we are tracking crashes
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ GetAutomaticSafeModeNecessary(aIsSafeModeNecessary);
+ return rv;
+}
+
+NS_IMETHODIMP
+nsAppStartup::TrackStartupCrashEnd()
+{
+ bool inSafeMode = false;
+ nsCOMPtr<nsIXULRuntime> xr = do_GetService(XULRUNTIME_SERVICE_CONTRACTID);
+ if (xr)
+ xr->GetInSafeMode(&inSafeMode);
+
+ // return if we already ended or we're restarting into safe mode
+ if (mStartupCrashTrackingEnded || (mIsSafeModeNecessary && !inSafeMode))
+ return NS_OK;
+ mStartupCrashTrackingEnded = true;
+
+ StartupTimeline::Record(StartupTimeline::STARTUP_CRASH_DETECTION_END);
+
+ // Use the timestamp of XRE_main as an approximation for the lock file timestamp.
+ // See MAX_STARTUP_BUFFER for the buffer time period.
+ TimeStamp mainTime = StartupTimeline::Get(StartupTimeline::MAIN);
+ TimeStamp now = TimeStamp::Now();
+ PRTime prNow = PR_Now();
+ nsresult rv;
+
+ if (mainTime.IsNull()) {
+ NS_WARNING("Could not get StartupTimeline::MAIN time.");
+ } else {
+ uint64_t lockFileTime = ComputeAbsoluteTimestamp(prNow, now, mainTime);
+
+ rv = Preferences::SetInt(kPrefLastSuccess,
+ (int32_t)(lockFileTime / PR_USEC_PER_SEC));
+
+ if (NS_FAILED(rv))
+ NS_WARNING("Could not set startup crash detection pref.");
+ }
+
+ if (inSafeMode && mIsSafeModeNecessary) {
+ // On a successful startup in automatic safe mode, allow the user one more crash
+ // in regular mode before returning to safe mode.
+ int32_t maxResumedCrashes = 0;
+ int32_t prefType;
+ rv = Preferences::GetDefaultRootBranch()->GetPrefType(kPrefMaxResumedCrashes, &prefType);
+ NS_ENSURE_SUCCESS(rv, rv);
+ if (prefType == nsIPrefBranch::PREF_INT) {
+ rv = Preferences::GetInt(kPrefMaxResumedCrashes, &maxResumedCrashes);
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+ rv = Preferences::SetInt(kPrefRecentCrashes, maxResumedCrashes);
+ NS_ENSURE_SUCCESS(rv, rv);
+ } else if (!inSafeMode) {
+ // clear the count of recent crashes after a succesful startup when not in safe mode
+ rv = Preferences::ClearUser(kPrefRecentCrashes);
+ if (NS_FAILED(rv)) NS_WARNING("Could not clear startup crash count.");
+ }
+ nsCOMPtr<nsIPrefService> prefs = Preferences::GetService();
+ rv = prefs->SavePrefFile(nullptr); // flush prefs to disk since we are tracking crashes
+
+ return rv;
+}
+
+NS_IMETHODIMP
+nsAppStartup::RestartInSafeMode(uint32_t aQuitMode)
+{
+ PR_SetEnv("MOZ_SAFE_MODE_RESTART=1");
+ this->Quit(aQuitMode | nsIAppStartup::eRestart);
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAppStartup::CreateInstanceWithProfile(nsIToolkitProfile* aProfile)
+{
+ if (NS_WARN_IF(!aProfile)) {
+ return NS_ERROR_FAILURE;
+ }
+
+ if (NS_WARN_IF(gAbsoluteArgv0Path.IsEmpty())) {
+ return NS_ERROR_FAILURE;
+ }
+
+ nsCOMPtr<nsIFile> execPath;
+ nsresult rv = NS_NewNativeLocalFile(NS_ConvertUTF16toUTF8(gAbsoluteArgv0Path),
+ true, getter_AddRefs(execPath));
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ return rv;
+ }
+
+ nsCOMPtr<nsIProcess> process = do_CreateInstance(NS_PROCESS_CONTRACTID, &rv);
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ return rv;
+ }
+
+ rv = process->Init(execPath);
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ return rv;
+ }
+
+ nsAutoCString profileName;
+ rv = aProfile->GetName(profileName);
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ return rv;
+ }
+
+ const char *args[] = { "-P", profileName.get() };
+ rv = process->Run(false, args, 2);
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ return rv;
+ }
+
+ return NS_OK;
+}
diff --git a/toolkit/components/startup/nsAppStartup.h b/toolkit/components/startup/nsAppStartup.h
new file mode 100644
index 000000000..44c406ee4
--- /dev/null
+++ b/toolkit/components/startup/nsAppStartup.h
@@ -0,0 +1,76 @@
+/* -*- 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/. */
+
+#ifndef nsAppStartup_h__
+#define nsAppStartup_h__
+
+#include "nsIAppStartup.h"
+#include "nsIWindowCreator2.h"
+#include "nsIObserver.h"
+#include "nsWeakReference.h"
+
+#include "nsINativeAppSupport.h"
+#include "nsIAppShell.h"
+#include "mozilla/Attributes.h"
+
+#if defined(XP_WIN)
+//XPerf-backed probes
+#include "mozilla/perfprobe.h"
+#include "nsAutoPtr.h"
+#endif //defined(XP_WIN)
+
+
+// {7DD4D320-C84B-4624-8D45-7BB9B2356977}
+#define NS_TOOLKIT_APPSTARTUP_CID \
+{ 0x7dd4d320, 0xc84b, 0x4624, { 0x8d, 0x45, 0x7b, 0xb9, 0xb2, 0x35, 0x69, 0x77 } }
+
+
+class nsAppStartup final : public nsIAppStartup,
+ public nsIWindowCreator2,
+ public nsIObserver,
+ public nsSupportsWeakReference
+{
+public:
+ NS_DECL_THREADSAFE_ISUPPORTS
+ NS_DECL_NSIAPPSTARTUP
+ NS_DECL_NSIWINDOWCREATOR
+ NS_DECL_NSIWINDOWCREATOR2
+ NS_DECL_NSIOBSERVER
+
+ nsAppStartup();
+ nsresult Init();
+
+private:
+ ~nsAppStartup() { }
+
+ void CloseAllWindows();
+
+ friend class nsAppExitEvent;
+
+ nsCOMPtr<nsIAppShell> mAppShell;
+
+ int32_t mConsiderQuitStopper; // if > 0, Quit(eConsiderQuit) fails
+ bool mRunning; // Have we started the main event loop?
+ bool mShuttingDown; // Quit method reentrancy check
+ bool mStartingUp; // Have we passed final-ui-startup?
+ bool mAttemptingQuit; // Quit(eAttemptQuit) still trying
+ bool mRestart; // Quit(eRestart)
+ bool mInterrupted; // Was startup interrupted by an interactive prompt?
+ bool mIsSafeModeNecessary; // Whether safe mode is necessary
+ bool mStartupCrashTrackingEnded; // Whether startup crash tracking has already ended
+ bool mRestartNotSameProfile; // Quit(eRestartNotSameProfile)
+
+#if defined(XP_WIN)
+ //Interaction with OS-provided profiling probes
+ typedef mozilla::probes::ProbeManager ProbeManager;
+ typedef mozilla::probes::Probe Probe;
+ RefPtr<ProbeManager> mProbesManager;
+ RefPtr<Probe> mPlacesInitCompleteProbe;
+ RefPtr<Probe> mSessionWindowRestoredProbe;
+ RefPtr<Probe> mXPCOMShutdownProbe;
+#endif
+};
+
+#endif // nsAppStartup_h__
diff --git a/toolkit/components/startup/nsUserInfo.h b/toolkit/components/startup/nsUserInfo.h
new file mode 100644
index 000000000..49e86c64a
--- /dev/null
+++ b/toolkit/components/startup/nsUserInfo.h
@@ -0,0 +1,23 @@
+/* -*- 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/. */
+#ifndef __nsUserInfo_h
+#define __nsUserInfo_h
+
+#include "nsIUserInfo.h"
+
+class nsUserInfo: public nsIUserInfo
+
+{
+public:
+ nsUserInfo(void);
+
+ NS_DECL_ISUPPORTS
+ NS_DECL_NSIUSERINFO
+
+protected:
+ virtual ~nsUserInfo();
+};
+
+#endif /* __nsUserInfo_h */
diff --git a/toolkit/components/startup/nsUserInfoMac.h b/toolkit/components/startup/nsUserInfoMac.h
new file mode 100644
index 000000000..822e0edd5
--- /dev/null
+++ b/toolkit/components/startup/nsUserInfoMac.h
@@ -0,0 +1,25 @@
+/* -*- 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/. */
+#ifndef __nsUserInfoMac_h
+#define __nsUserInfoMac_h
+
+#include "nsIUserInfo.h"
+#include "nsReadableUtils.h"
+
+class nsUserInfo: public nsIUserInfo
+{
+public:
+ nsUserInfo();
+
+ NS_DECL_ISUPPORTS
+ NS_DECL_NSIUSERINFO
+
+ nsresult GetPrimaryEmailAddress(nsCString &aEmailAddress);
+
+protected:
+ virtual ~nsUserInfo() {}
+};
+
+#endif /* __nsUserInfo_h */
diff --git a/toolkit/components/startup/nsUserInfoMac.mm b/toolkit/components/startup/nsUserInfoMac.mm
new file mode 100644
index 000000000..1895cf177
--- /dev/null
+++ b/toolkit/components/startup/nsUserInfoMac.mm
@@ -0,0 +1,84 @@
+/* -*- Mode: Objective-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 "nsUserInfoMac.h"
+#include "nsObjCExceptions.h"
+#include "nsString.h"
+
+#import <Cocoa/Cocoa.h>
+#import <AddressBook/AddressBook.h>
+
+NS_IMPL_ISUPPORTS(nsUserInfo, nsIUserInfo)
+
+nsUserInfo::nsUserInfo() {}
+
+NS_IMETHODIMP
+nsUserInfo::GetFullname(char16_t **aFullname)
+{
+ NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NSRESULT
+
+ NS_ConvertUTF8toUTF16 fullName([NSFullUserName() UTF8String]);
+ *aFullname = ToNewUnicode(fullName);
+ return NS_OK;
+
+ NS_OBJC_END_TRY_ABORT_BLOCK_NSRESULT
+}
+
+NS_IMETHODIMP
+nsUserInfo::GetUsername(char **aUsername)
+{
+ NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NSRESULT
+
+ nsAutoCString username([NSUserName() UTF8String]);
+ *aUsername = ToNewCString(username);
+ return NS_OK;
+
+ NS_OBJC_END_TRY_ABORT_BLOCK_NSRESULT
+}
+
+nsresult
+nsUserInfo::GetPrimaryEmailAddress(nsCString &aEmailAddress)
+{
+ NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NSRESULT
+
+ // Try to get this user's primary email from the system addressbook's "me card"
+ // (if they've filled it)
+ ABPerson *me = [[ABAddressBook sharedAddressBook] me];
+ ABMultiValue *emailAddresses = [me valueForProperty:kABEmailProperty];
+ if ([emailAddresses count] > 0) {
+ // get the index of the primary email, in case there are more than one
+ int primaryEmailIndex = [emailAddresses indexForIdentifier:[emailAddresses primaryIdentifier]];
+ aEmailAddress.Assign([[emailAddresses valueAtIndex:primaryEmailIndex] UTF8String]);
+ return NS_OK;
+ }
+
+ return NS_ERROR_FAILURE;
+
+ NS_OBJC_END_TRY_ABORT_BLOCK_NSRESULT
+}
+
+NS_IMETHODIMP
+nsUserInfo::GetEmailAddress(char **aEmailAddress)
+{
+ nsAutoCString email;
+ if (NS_SUCCEEDED(GetPrimaryEmailAddress(email)))
+ *aEmailAddress = ToNewCString(email);
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsUserInfo::GetDomain(char **aDomain)
+{
+ nsAutoCString email;
+ if (NS_SUCCEEDED(GetPrimaryEmailAddress(email))) {
+ int32_t index = email.FindChar('@');
+ if (index != -1) {
+ // chop off everything before, and including the '@'
+ *aDomain = ToNewCString(Substring(email, index + 1));
+ }
+ }
+ return NS_OK;
+}
diff --git a/toolkit/components/startup/nsUserInfoUnix.cpp b/toolkit/components/startup/nsUserInfoUnix.cpp
new file mode 100644
index 000000000..71bc46da2
--- /dev/null
+++ b/toolkit/components/startup/nsUserInfoUnix.cpp
@@ -0,0 +1,167 @@
+/* -*- 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 "nsUserInfo.h"
+#include "nsCRT.h"
+
+#include <pwd.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <sys/utsname.h>
+
+#include "nsString.h"
+#include "nsXPIDLString.h"
+#include "nsReadableUtils.h"
+#include "nsNativeCharsetUtils.h"
+
+/* Some UNIXy platforms don't have pw_gecos. In this case we use pw_name */
+#if defined(NO_PW_GECOS)
+#define PW_GECOS pw_name
+#else
+#define PW_GECOS pw_gecos
+#endif
+
+nsUserInfo::nsUserInfo()
+{
+}
+
+nsUserInfo::~nsUserInfo()
+{
+}
+
+NS_IMPL_ISUPPORTS(nsUserInfo,nsIUserInfo)
+
+NS_IMETHODIMP
+nsUserInfo::GetFullname(char16_t **aFullname)
+{
+ struct passwd *pw = nullptr;
+
+ pw = getpwuid (geteuid());
+
+ if (!pw || !pw->PW_GECOS) return NS_ERROR_FAILURE;
+
+#ifdef DEBUG_sspitzer
+ printf("fullname = %s\n", pw->PW_GECOS);
+#endif
+
+ nsAutoCString fullname(pw->PW_GECOS);
+
+ // now try to parse the GECOS information, which will be in the form
+ // Full Name, <other stuff> - eliminate the ", <other stuff>
+ // also, sometimes GECOS uses "&" to mean "the user name" so do
+ // the appropriate substitution
+
+ // truncate at first comma (field delimiter)
+ int32_t index;
+ if ((index = fullname.Find(",")) != kNotFound)
+ fullname.Truncate(index);
+
+ // replace ampersand with username
+ if (pw->pw_name) {
+ nsAutoCString username(pw->pw_name);
+ if (!username.IsEmpty() && nsCRT::IsLower(username.CharAt(0)))
+ username.SetCharAt(nsCRT::ToUpper(username.CharAt(0)), 0);
+
+ fullname.ReplaceSubstring("&", username.get());
+ }
+
+ nsAutoString unicodeFullname;
+ NS_CopyNativeToUnicode(fullname, unicodeFullname);
+
+ *aFullname = ToNewUnicode(unicodeFullname);
+
+ if (*aFullname)
+ return NS_OK;
+
+ return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP
+nsUserInfo::GetUsername(char * *aUsername)
+{
+ struct passwd *pw = nullptr;
+
+ // is this portable? those are POSIX compliant calls, but I need to check
+ pw = getpwuid(geteuid());
+
+ if (!pw || !pw->pw_name) return NS_ERROR_FAILURE;
+
+#ifdef DEBUG_sspitzer
+ printf("username = %s\n", pw->pw_name);
+#endif
+
+ *aUsername = strdup(pw->pw_name);
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsUserInfo::GetDomain(char * *aDomain)
+{
+ nsresult rv = NS_ERROR_FAILURE;
+
+ struct utsname buf;
+ char *domainname = nullptr;
+
+ if (uname(&buf) < 0) {
+ return rv;
+ }
+
+#if defined(__linux__)
+ domainname = buf.domainname;
+#endif
+
+ if (domainname && domainname[0]) {
+ *aDomain = strdup(domainname);
+ rv = NS_OK;
+ }
+ else {
+ // try to get the hostname from the nodename
+ // on machines that use DHCP, domainname may not be set
+ // but the nodename might.
+ if (buf.nodename[0]) {
+ // if the nodename is foo.bar.org, use bar.org as the domain
+ char *pos = strchr(buf.nodename,'.');
+ if (pos) {
+ *aDomain = strdup(pos+1);
+ rv = NS_OK;
+ }
+ }
+ }
+
+ return rv;
+}
+
+NS_IMETHODIMP
+nsUserInfo::GetEmailAddress(char * *aEmailAddress)
+{
+ // use username + "@" + domain for the email address
+
+ nsresult rv;
+
+ nsAutoCString emailAddress;
+ nsXPIDLCString username;
+ nsXPIDLCString domain;
+
+ rv = GetUsername(getter_Copies(username));
+ if (NS_FAILED(rv)) return rv;
+
+ rv = GetDomain(getter_Copies(domain));
+ if (NS_FAILED(rv)) return rv;
+
+ if (!username.IsEmpty() && !domain.IsEmpty()) {
+ emailAddress = (const char *)username;
+ emailAddress += "@";
+ emailAddress += (const char *)domain;
+ }
+ else {
+ return NS_ERROR_FAILURE;
+ }
+
+ *aEmailAddress = ToNewCString(emailAddress);
+
+ return NS_OK;
+}
+
diff --git a/toolkit/components/startup/nsUserInfoWin.cpp b/toolkit/components/startup/nsUserInfoWin.cpp
new file mode 100644
index 000000000..b27a2c483
--- /dev/null
+++ b/toolkit/components/startup/nsUserInfoWin.cpp
@@ -0,0 +1,133 @@
+/* -*- 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 "nsUserInfo.h"
+
+#include "mozilla/ArrayUtils.h" // ArrayLength
+#include "nsString.h"
+#include "windows.h"
+#include "nsCRT.h"
+#include "nsXPIDLString.h"
+
+#define SECURITY_WIN32
+#include "lm.h"
+#include "security.h"
+
+nsUserInfo::nsUserInfo()
+{
+}
+
+nsUserInfo::~nsUserInfo()
+{
+}
+
+NS_IMPL_ISUPPORTS(nsUserInfo, nsIUserInfo)
+
+NS_IMETHODIMP
+nsUserInfo::GetUsername(char **aUsername)
+{
+ NS_ENSURE_ARG_POINTER(aUsername);
+ *aUsername = nullptr;
+
+ // ULEN is the max username length as defined in lmcons.h
+ wchar_t username[UNLEN +1];
+ DWORD size = mozilla::ArrayLength(username);
+ if (!GetUserNameW(username, &size))
+ return NS_ERROR_FAILURE;
+
+ *aUsername = ToNewUTF8String(nsDependentString(username));
+ return (*aUsername) ? NS_OK : NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP
+nsUserInfo::GetFullname(char16_t **aFullname)
+{
+ NS_ENSURE_ARG_POINTER(aFullname);
+ *aFullname = nullptr;
+
+ wchar_t fullName[512];
+ DWORD size = mozilla::ArrayLength(fullName);
+
+ if (GetUserNameExW(NameDisplay, fullName, &size)) {
+ *aFullname = ToNewUnicode(nsDependentString(fullName));
+ } else {
+ DWORD getUsernameError = GetLastError();
+
+ // Try to use the net APIs regardless of the error because it may be
+ // able to obtain the information.
+ wchar_t username[UNLEN + 1];
+ size = mozilla::ArrayLength(username);
+ if (!GetUserNameW(username, &size)) {
+ // ERROR_NONE_MAPPED means the user info is not filled out on this computer
+ return getUsernameError == ERROR_NONE_MAPPED ?
+ NS_ERROR_NOT_AVAILABLE : NS_ERROR_FAILURE;
+ }
+
+ const DWORD level = 2;
+ LPBYTE info;
+ // If the NetUserGetInfo function has no full name info it will return
+ // success with an empty string.
+ NET_API_STATUS status = NetUserGetInfo(nullptr, username, level, &info);
+ if (status != NERR_Success) {
+ // We have an error with NetUserGetInfo but we know the info is not
+ // filled in because GetUserNameExW returned ERROR_NONE_MAPPED.
+ return getUsernameError == ERROR_NONE_MAPPED ?
+ NS_ERROR_NOT_AVAILABLE : NS_ERROR_FAILURE;
+ }
+
+ nsDependentString fullName =
+ nsDependentString(reinterpret_cast<USER_INFO_2 *>(info)->usri2_full_name);
+
+ // NetUserGetInfo returns an empty string if the full name is not filled out
+ if (fullName.Length() == 0) {
+ NetApiBufferFree(info);
+ return NS_ERROR_NOT_AVAILABLE;
+ }
+
+ *aFullname = ToNewUnicode(fullName);
+ NetApiBufferFree(info);
+ }
+
+ return (*aFullname) ? NS_OK : NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP
+nsUserInfo::GetDomain(char **aDomain)
+{
+ NS_ENSURE_ARG_POINTER(aDomain);
+ *aDomain = nullptr;
+
+ const DWORD level = 100;
+ LPBYTE info;
+ NET_API_STATUS status = NetWkstaGetInfo(nullptr, level, &info);
+ if (status == NERR_Success) {
+ *aDomain =
+ ToNewUTF8String(nsDependentString(reinterpret_cast<WKSTA_INFO_100 *>(info)->
+ wki100_langroup));
+ NetApiBufferFree(info);
+ }
+
+ return (*aDomain) ? NS_OK : NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP
+nsUserInfo::GetEmailAddress(char **aEmailAddress)
+{
+ NS_ENSURE_ARG_POINTER(aEmailAddress);
+ *aEmailAddress = nullptr;
+
+ // RFC3696 says max length of an email address is 254
+ wchar_t emailAddress[255];
+ DWORD size = mozilla::ArrayLength(emailAddress);
+
+ if (!GetUserNameExW(NameUserPrincipal, emailAddress, &size)) {
+ DWORD getUsernameError = GetLastError();
+ return getUsernameError == ERROR_NONE_MAPPED ?
+ NS_ERROR_NOT_AVAILABLE : NS_ERROR_FAILURE;
+ }
+
+ *aEmailAddress = ToNewUTF8String(nsDependentString(emailAddress));
+ return (*aEmailAddress) ? NS_OK : NS_ERROR_FAILURE;
+}
diff --git a/toolkit/components/startup/public/moz.build b/toolkit/components/startup/public/moz.build
new file mode 100644
index 000000000..5894b6c51
--- /dev/null
+++ b/toolkit/components/startup/public/moz.build
@@ -0,0 +1,13 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+XPIDL_SOURCES += [
+ 'nsIAppStartup.idl',
+ 'nsIUserInfo.idl',
+]
+
+XPIDL_MODULE = 'appstartup'
+
diff --git a/toolkit/components/startup/public/nsIAppStartup.idl b/toolkit/components/startup/public/nsIAppStartup.idl
new file mode 100644
index 000000000..34705d39f
--- /dev/null
+++ b/toolkit/components/startup/public/nsIAppStartup.idl
@@ -0,0 +1,195 @@
+/* -*- Mode: IDL; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* 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 "nsISupports.idl"
+
+interface nsICmdLineService;
+interface nsIToolkitProfile;
+
+[scriptable, uuid(6621f6d5-6c04-4a0e-9e74-447db221484e)]
+
+interface nsIAppStartup : nsISupports
+{
+ /**
+ * Create the hidden window.
+ */
+ void createHiddenWindow();
+
+ /**
+ * Destroys the hidden window. This will have no effect if the hidden window
+ * has not yet been created.
+ */
+ void destroyHiddenWindow();
+
+ /**
+ * Runs an application event loop: normally the main event pump which
+ * defines the lifetime of the application. If there are no windows open
+ * and no outstanding calls to enterLastWindowClosingSurvivalArea this
+ * method will exit immediately.
+ *
+ * @returnCode NS_SUCCESS_RESTART_APP
+ * This return code indicates that the application should be
+ * restarted because quit was called with the eRestart flag.
+
+ * @returnCode NS_SUCCESS_RESTART_APP_NOT_SAME_PROFILE
+ * This return code indicates that the application should be
+ * restarted without necessarily using the same profile because
+ * quit was called with the eRestartNotSameProfile flag.
+ */
+ void run();
+
+ /**
+ * There are situations where all application windows will be
+ * closed but we don't want to take this as a signal to quit the
+ * app. Bracket the code where the last window could close with
+ * these.
+ */
+ void enterLastWindowClosingSurvivalArea();
+ void exitLastWindowClosingSurvivalArea();
+
+ /**
+ * Startup Crash Detection
+ *
+ * Keeps track of application startup begining and success using flags to
+ * determine whether the application is crashing on startup.
+ * When the number of crashes crosses the acceptable threshold, safe mode
+ * or other repair procedures are performed.
+ */
+
+ /**
+ * Whether automatic safe mode is necessary at this time. This gets set
+ * in trackStartupCrashBegin.
+ *
+ * @see trackStartupCrashBegin
+ */
+ readonly attribute boolean automaticSafeModeNecessary;
+
+ /**
+ * Restart the application in safe mode
+ * @param aQuitMode
+ * This parameter modifies how the app is shutdown.
+ * @see nsIAppStartup::quit
+ */
+ void restartInSafeMode(in uint32_t aQuitMode);
+
+ /**
+ * Run a new instance of this app with a specified profile
+ * @param aProfile
+ * The profile we want to use.
+ * @see nsIAppStartup::quit
+ */
+ void createInstanceWithProfile(in nsIToolkitProfile aProfile);
+
+ /**
+ * If the last startup crashed then increment a counter.
+ * Set a flag so on next startup we can detect whether TrackStartupCrashEnd
+ * was called (and therefore the application crashed).
+ * @return whether safe mode is necessary
+ */
+ bool trackStartupCrashBegin();
+
+ /**
+ * We have succesfully started without crashing. Clear flags that were
+ * tracking past crashes.
+ */
+ void trackStartupCrashEnd();
+
+ /**
+ * The following flags may be passed as the aMode parameter to the quit
+ * method. One and only one of the "Quit" flags must be specified. The
+ * eRestart flag may be bit-wise combined with one of the "Quit" flags to
+ * cause the application to restart after it quits.
+ */
+
+ /**
+ * Attempt to quit if all windows are closed.
+ */
+ const uint32_t eConsiderQuit = 0x01;
+
+ /**
+ * Try to close all windows, then quit if successful.
+ */
+ const uint32_t eAttemptQuit = 0x02;
+
+ /**
+ * Quit, damnit!
+ */
+ const uint32_t eForceQuit = 0x03;
+
+ /**
+ * Restart the application after quitting. The application will be
+ * restarted with the same profile and an empty command line.
+ */
+ const uint32_t eRestart = 0x10;
+
+ /**
+ * When restarting attempt to start in the i386 architecture. Only supported
+ * on OSX.
+ */
+ const uint32_t eRestarti386 = 0x20;
+
+ /**
+ * When restarting attempt to start in the x86_64 architecture. Only
+ * supported on OSX.
+ */
+ const uint32_t eRestartx86_64 = 0x40;
+
+ /**
+ * Restart the application after quitting. The application will be
+ * restarted with an empty command line and the normal profile selection
+ * process will take place on startup.
+ */
+ const uint32_t eRestartNotSameProfile = 0x100;
+
+ /**
+ * Exit the event loop, and shut down the app.
+ *
+ * @param aMode
+ * This parameter modifies how the app is shutdown, and it is
+ * constructed from the constants defined above.
+ */
+ void quit(in uint32_t aMode);
+
+ /**
+ * True if the application is in the process of shutting down.
+ */
+ readonly attribute boolean shuttingDown;
+
+ /**
+ * True if the application is in the process of starting up.
+ *
+ * Startup is complete once all observers of final-ui-startup have returned.
+ */
+ readonly attribute boolean startingUp;
+
+ /**
+ * Mark the startup as completed.
+ *
+ * Called at the end of startup by nsAppRunner.
+ */
+ [noscript] void doneStartingUp();
+
+ /**
+ * True if the application is being restarted
+ */
+ readonly attribute boolean restarting;
+
+ /**
+ * True if this is the startup following restart, i.e. if the application
+ * was restarted using quit(eRestart*).
+ */
+ readonly attribute boolean wasRestarted;
+
+ /**
+ * Returns an object with main, process, firstPaint, sessionRestored properties.
+ * Properties may not be available depending on platform or application
+ */
+ [implicit_jscontext] jsval getStartupInfo();
+
+ /**
+ * True if startup was interrupted by an interactive prompt.
+ */
+ attribute boolean interrupted;
+};
diff --git a/toolkit/components/startup/public/nsIUserInfo.idl b/toolkit/components/startup/public/nsIUserInfo.idl
new file mode 100644
index 000000000..1838cc69c
--- /dev/null
+++ b/toolkit/components/startup/public/nsIUserInfo.idl
@@ -0,0 +1,32 @@
+/* -*- 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 "nsISupports.idl"
+
+[scriptable, uuid(6c1034f0-1dd2-11b2-aa14-e6657ed7bb0b)]
+interface nsIUserInfo : nsISupports
+{
+ /* these are things the system may know about the current user */
+
+ readonly attribute wstring fullname;
+
+ readonly attribute string emailAddress;
+
+ /* should this be a wstring? */
+ readonly attribute string username;
+
+ readonly attribute string domain;
+};
+
+%{C++
+
+// 14c13684-1dd2-11b2-9463-bb10ba742554
+#define NS_USERINFO_CID \
+{ 0x14c13684, 0x1dd2, 0x11b2, \
+ {0x94, 0x63, 0xbb, 0x10, 0xba, 0x74, 0x25, 0x54}}
+
+#define NS_USERINFO_CONTRACTID "@mozilla.org/userinfo;1"
+
+%}
diff --git a/toolkit/components/startup/tests/browser/.eslintrc.js b/toolkit/components/startup/tests/browser/.eslintrc.js
new file mode 100644
index 000000000..7c8021192
--- /dev/null
+++ b/toolkit/components/startup/tests/browser/.eslintrc.js
@@ -0,0 +1,7 @@
+"use strict";
+
+module.exports = {
+ "extends": [
+ "../../../../../testing/mochitest/browser.eslintrc.js"
+ ]
+};
diff --git a/toolkit/components/startup/tests/browser/beforeunload.html b/toolkit/components/startup/tests/browser/beforeunload.html
new file mode 100644
index 000000000..93ddd5f14
--- /dev/null
+++ b/toolkit/components/startup/tests/browser/beforeunload.html
@@ -0,0 +1,10 @@
+<html>
+ <script>
+ window.onbeforeunload = function(event) {
+ event.returnValue = 'Test beforeunload handler';
+ }
+ </script>
+ <body>
+ Test page
+ </body>
+</html>
diff --git a/toolkit/components/startup/tests/browser/browser.ini b/toolkit/components/startup/tests/browser/browser.ini
new file mode 100644
index 000000000..0c02f73b6
--- /dev/null
+++ b/toolkit/components/startup/tests/browser/browser.ini
@@ -0,0 +1,8 @@
+[DEFAULT]
+support-files =
+ head.js
+ beforeunload.html
+
+[browser_bug511456.js]
+[browser_bug537449.js]
+[browser_crash_detection.js]
diff --git a/toolkit/components/startup/tests/browser/browser_bug511456.js b/toolkit/components/startup/tests/browser/browser_bug511456.js
new file mode 100644
index 000000000..652a34ea2
--- /dev/null
+++ b/toolkit/components/startup/tests/browser/browser_bug511456.js
@@ -0,0 +1,47 @@
+/* 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/. */
+
+"use strict";
+
+const TEST_URL = "http://example.com/browser/toolkit/components/startup/tests/browser/beforeunload.html";
+
+SpecialPowers.pushPrefEnv({"set": [["dom.require_user_interaction_for_beforeunload", false]]});
+
+function test() {
+ waitForExplicitFinish();
+ ignoreAllUncaughtExceptions();
+
+ let win2 = window.openDialog(location, "", "chrome,all,dialog=no", "about:blank");
+ win2.addEventListener("load", function onLoad() {
+ win2.removeEventListener("load", onLoad);
+
+ gBrowser.selectedTab = gBrowser.addTab(TEST_URL);
+ let browser = gBrowser.selectedBrowser;
+
+ whenBrowserLoaded(browser, function () {
+ let seenDialog = false;
+
+ // Cancel the prompt the first time.
+ waitForOnBeforeUnloadDialog(browser, (btnLeave, btnStay) => {
+ seenDialog = true;
+ btnStay.click();
+ });
+
+ let appStartup = Cc['@mozilla.org/toolkit/app-startup;1'].
+ getService(Ci.nsIAppStartup);
+ appStartup.quit(Ci.nsIAppStartup.eAttemptQuit);
+ ok(seenDialog, "Should have seen a prompt dialog");
+ ok(!win2.closed, "Shouldn't have closed the additional window");
+ win2.close();
+
+ // Leave the page the second time.
+ waitForOnBeforeUnloadDialog(browser, (btnLeave, btnStay) => {
+ btnLeave.click();
+ });
+
+ gBrowser.removeTab(gBrowser.selectedTab);
+ executeSoon(finish);
+ });
+ });
+}
diff --git a/toolkit/components/startup/tests/browser/browser_bug537449.js b/toolkit/components/startup/tests/browser/browser_bug537449.js
new file mode 100644
index 000000000..ed3446f8d
--- /dev/null
+++ b/toolkit/components/startup/tests/browser/browser_bug537449.js
@@ -0,0 +1,53 @@
+/* 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/. */
+
+"use strict";
+
+//
+// Whitelisting this test.
+// As part of bug 1077403, the leaking uncaught rejection should be fixed.
+//
+thisTestLeaksUncaughtRejectionsAndShouldBeFixed("TypeError: this.docShell is null");
+
+SpecialPowers.pushPrefEnv({"set": [["dom.require_user_interaction_for_beforeunload", false]]});
+
+const TEST_URL = "http://example.com/browser/toolkit/components/startup/tests/browser/beforeunload.html";
+
+function test() {
+ waitForExplicitFinish();
+
+ gBrowser.selectedTab = gBrowser.addTab(TEST_URL);
+ let browser = gBrowser.selectedBrowser;
+
+ whenBrowserLoaded(browser, function () {
+ let seenDialog = false;
+
+ // Cancel the prompt the first time.
+ waitForOnBeforeUnloadDialog(browser, (btnLeave, btnStay) => {
+ seenDialog = true;
+ btnStay.click();
+ });
+
+ let appStartup = Cc['@mozilla.org/toolkit/app-startup;1'].
+ getService(Ci.nsIAppStartup);
+ appStartup.quit(Ci.nsIAppStartup.eAttemptQuit);
+ ok(seenDialog, "Should have seen a prompt dialog");
+ ok(!window.closed, "Shouldn't have closed the window");
+
+ let win2 = window.openDialog(location, "", "chrome,all,dialog=no", "about:blank");
+ ok(win2 != null, "Should have been able to open a new window");
+ win2.addEventListener("load", function onLoad() {
+ win2.removeEventListener("load", onLoad);
+ win2.close();
+
+ // Leave the page the second time.
+ waitForOnBeforeUnloadDialog(browser, (btnLeave, btnStay) => {
+ btnLeave.click();
+ });
+
+ gBrowser.removeTab(gBrowser.selectedTab);
+ executeSoon(finish);
+ });
+ });
+}
diff --git a/toolkit/components/startup/tests/browser/browser_crash_detection.js b/toolkit/components/startup/tests/browser/browser_crash_detection.js
new file mode 100644
index 000000000..039f80dde
--- /dev/null
+++ b/toolkit/components/startup/tests/browser/browser_crash_detection.js
@@ -0,0 +1,23 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/
+ */
+
+function test() {
+ function checkLastSuccess() {
+ let lastSuccess = Services.prefs.getIntPref("toolkit.startup.last_success");
+ let si = Services.startup.getStartupInfo();
+ is(lastSuccess, parseInt(si["main"].getTime() / 1000, 10),
+ "Startup tracking pref should be set after a delay at the end of startup");
+ finish();
+ }
+
+ if (Services.prefs.getPrefType("toolkit.startup.max_resumed_crashes") == Services.prefs.PREF_INVALID) {
+ info("Skipping this test since startup crash detection is disabled");
+ return;
+ }
+
+ const startupCrashEndDelay = 35 * 1000;
+ waitForExplicitFinish();
+ requestLongerTimeout(2);
+ setTimeout(checkLastSuccess, startupCrashEndDelay);
+}
diff --git a/toolkit/components/startup/tests/browser/head.js b/toolkit/components/startup/tests/browser/head.js
new file mode 100644
index 000000000..c17da2ff7
--- /dev/null
+++ b/toolkit/components/startup/tests/browser/head.js
@@ -0,0 +1,29 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+const XUL_NS = "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul";
+
+function whenBrowserLoaded(browser, callback) {
+ return BrowserTestUtils.browserLoaded(browser).then(callback);
+}
+
+function waitForOnBeforeUnloadDialog(browser, callback) {
+ browser.addEventListener("DOMWillOpenModalDialog", function onModalDialog(event) {
+ if (Cu.isCrossProcessWrapper(event.target)) {
+ // This event fires in both the content and chrome processes. We
+ // want to ignore the one in the content process.
+ return;
+ }
+
+ browser.removeEventListener("DOMWillOpenModalDialog", onModalDialog, true);
+
+ executeSoon(() => {
+ let stack = browser.parentNode;
+ let dialogs = stack.getElementsByTagNameNS(XUL_NS, "tabmodalprompt");
+ let {button0, button1} = dialogs[0].ui;
+ callback(button0, button1);
+ });
+ }, true);
+}
diff --git a/toolkit/components/startup/tests/unit/.eslintrc.js b/toolkit/components/startup/tests/unit/.eslintrc.js
new file mode 100644
index 000000000..d35787cd2
--- /dev/null
+++ b/toolkit/components/startup/tests/unit/.eslintrc.js
@@ -0,0 +1,7 @@
+"use strict";
+
+module.exports = {
+ "extends": [
+ "../../../../../testing/xpcshell/xpcshell.eslintrc.js"
+ ]
+};
diff --git a/toolkit/components/startup/tests/unit/head_startup.js b/toolkit/components/startup/tests/unit/head_startup.js
new file mode 100644
index 000000000..2466f70ee
--- /dev/null
+++ b/toolkit/components/startup/tests/unit/head_startup.js
@@ -0,0 +1,30 @@
+/* Any copyright is dedicated to the Public Domain.
+ http://creativecommons.org/publicdomain/zero/1.0/ */
+
+const XULRUNTIME_CONTRACTID = "@mozilla.org/xre/runtime;1";
+const XULRUNTIME_CID = Components.ID("7685dac8-3637-4660-a544-928c5ec0e714}");
+
+Components.utils.import("resource://gre/modules/XPCOMUtils.jsm");
+
+var gAppInfo = null;
+
+function createAppInfo(ID, name, version, platformVersion="1.0") {
+ let tmp = {};
+ Components.utils.import("resource://testing-common/AppInfo.jsm", tmp);
+ gAppInfo = tmp.newAppInfo({
+ ID, name, version, platformVersion,
+ crashReporter: true,
+ replacedLockTime: 0,
+ });
+
+ let XULAppInfoFactory = {
+ createInstance: function (outer, iid) {
+ if (outer != null)
+ throw Components.results.NS_ERROR_NO_AGGREGATION;
+ return gAppInfo.QueryInterface(iid);
+ }
+ };
+ let registrar = Components.manager.QueryInterface(Ci.nsIComponentRegistrar);
+ registrar.registerFactory(XULRUNTIME_CID, "XULRuntime",
+ XULRUNTIME_CONTRACTID, XULAppInfoFactory);
+}
diff --git a/toolkit/components/startup/tests/unit/test_startup_crash.js b/toolkit/components/startup/tests/unit/test_startup_crash.js
new file mode 100644
index 000000000..283633086
--- /dev/null
+++ b/toolkit/components/startup/tests/unit/test_startup_crash.js
@@ -0,0 +1,300 @@
+/* Any copyright is dedicated to the Public Domain.
+ http://creativecommons.org/publicdomain/zero/1.0/ */
+
+Components.utils.import("resource://gre/modules/Services.jsm");
+
+var Cc = Components.classes;
+var Ci = Components.interfaces;
+
+createAppInfo("xpcshell@tests.mozilla.org", "XPCShell", "1", "10.0");
+
+var prefService = Services.prefs;
+var appStartup = Cc["@mozilla.org/toolkit/app-startup;1"].
+ getService(Ci.nsIAppStartup);
+
+const pref_last_success = "toolkit.startup.last_success";
+const pref_recent_crashes = "toolkit.startup.recent_crashes";
+const pref_max_resumed_crashes = "toolkit.startup.max_resumed_crashes";
+const pref_always_use_safe_mode = "toolkit.startup.always_use_safe_mode";
+
+function run_test() {
+ prefService.setBoolPref(pref_always_use_safe_mode, true);
+
+ resetTestEnv(0);
+
+ test_trackStartupCrashBegin();
+ test_trackStartupCrashEnd();
+ test_trackStartupCrashBegin_safeMode();
+ test_trackStartupCrashEnd_safeMode();
+ test_maxResumed();
+ resetTestEnv(0);
+
+ prefService.clearUserPref(pref_always_use_safe_mode);
+}
+
+// reset prefs to default
+function resetTestEnv(replacedLockTime) {
+ try {
+ // call begin to reset mStartupCrashTrackingEnded
+ appStartup.trackStartupCrashBegin();
+ } catch (x) { }
+ prefService.setIntPref(pref_max_resumed_crashes, 2);
+ prefService.clearUserPref(pref_recent_crashes);
+ gAppInfo.replacedLockTime = replacedLockTime;
+ prefService.clearUserPref(pref_last_success);
+}
+
+function now_seconds() {
+ return ms_to_s(Date.now());
+}
+
+function ms_to_s(ms) {
+ return Math.floor(ms / 1000);
+}
+
+function test_trackStartupCrashBegin() {
+ let max_resumed = prefService.getIntPref(pref_max_resumed_crashes);
+ do_check_false(gAppInfo.inSafeMode);
+
+ // first run with startup crash tracking - existing profile lock
+ let replacedLockTime = Date.now();
+ resetTestEnv(replacedLockTime);
+ do_check_false(prefService.prefHasUserValue(pref_recent_crashes));
+ do_check_false(prefService.prefHasUserValue(pref_last_success));
+ do_check_eq(replacedLockTime, gAppInfo.replacedLockTime);
+ try {
+ do_check_false(appStartup.trackStartupCrashBegin());
+ do_throw("Should have thrown since last_success is not set");
+ } catch (x) { }
+
+ do_check_false(prefService.prefHasUserValue(pref_last_success));
+ do_check_false(prefService.prefHasUserValue(pref_recent_crashes));
+ do_check_false(appStartup.automaticSafeModeNecessary);
+
+ // first run with startup crash tracking - no existing profile lock
+ replacedLockTime = 0;
+ resetTestEnv(replacedLockTime);
+ do_check_false(prefService.prefHasUserValue(pref_recent_crashes));
+ do_check_false(prefService.prefHasUserValue(pref_last_success));
+ do_check_eq(replacedLockTime, gAppInfo.replacedLockTime);
+ try {
+ do_check_false(appStartup.trackStartupCrashBegin());
+ do_throw("Should have thrown since last_success is not set");
+ } catch (x) { }
+
+ do_check_false(prefService.prefHasUserValue(pref_last_success));
+ do_check_false(prefService.prefHasUserValue(pref_recent_crashes));
+ do_check_false(appStartup.automaticSafeModeNecessary);
+
+ // normal startup - last startup was success
+ replacedLockTime = Date.now();
+ resetTestEnv(replacedLockTime);
+ do_check_false(prefService.prefHasUserValue(pref_recent_crashes));
+ prefService.setIntPref(pref_last_success, ms_to_s(replacedLockTime));
+ do_check_eq(ms_to_s(replacedLockTime), prefService.getIntPref(pref_last_success));
+ do_check_false(appStartup.trackStartupCrashBegin());
+ do_check_eq(ms_to_s(replacedLockTime), prefService.getIntPref(pref_last_success));
+ do_check_false(prefService.prefHasUserValue(pref_recent_crashes));
+ do_check_false(appStartup.automaticSafeModeNecessary);
+
+ // normal startup with 1 recent crash
+ resetTestEnv(replacedLockTime);
+ prefService.setIntPref(pref_recent_crashes, 1);
+ prefService.setIntPref(pref_last_success, ms_to_s(replacedLockTime));
+ do_check_false(appStartup.trackStartupCrashBegin());
+ do_check_eq(ms_to_s(replacedLockTime), prefService.getIntPref(pref_last_success));
+ do_check_eq(1, prefService.getIntPref(pref_recent_crashes));
+ do_check_false(appStartup.automaticSafeModeNecessary);
+
+ // normal startup with max_resumed_crashes crash
+ resetTestEnv(replacedLockTime);
+ prefService.setIntPref(pref_recent_crashes, max_resumed);
+ prefService.setIntPref(pref_last_success, ms_to_s(replacedLockTime));
+ do_check_false(appStartup.trackStartupCrashBegin());
+ do_check_eq(ms_to_s(replacedLockTime), prefService.getIntPref(pref_last_success));
+ do_check_eq(max_resumed, prefService.getIntPref(pref_recent_crashes));
+ do_check_false(appStartup.automaticSafeModeNecessary);
+
+ // normal startup with too many recent crashes
+ resetTestEnv(replacedLockTime);
+ prefService.setIntPref(pref_recent_crashes, max_resumed + 1);
+ prefService.setIntPref(pref_last_success, ms_to_s(replacedLockTime));
+ do_check_true(appStartup.trackStartupCrashBegin());
+ // should remain the same since the last startup was not a crash
+ do_check_eq(max_resumed + 1, prefService.getIntPref(pref_recent_crashes));
+ do_check_true(appStartup.automaticSafeModeNecessary);
+
+ // normal startup with too many recent crashes and startup crash tracking disabled
+ resetTestEnv(replacedLockTime);
+ prefService.setIntPref(pref_max_resumed_crashes, -1);
+ prefService.setIntPref(pref_recent_crashes, max_resumed + 1);
+ prefService.setIntPref(pref_last_success, ms_to_s(replacedLockTime));
+ do_check_false(appStartup.trackStartupCrashBegin());
+ // should remain the same since the last startup was not a crash
+ do_check_eq(max_resumed + 1, prefService.getIntPref(pref_recent_crashes));
+ // returns false when disabled
+ do_check_false(appStartup.automaticSafeModeNecessary);
+ do_check_eq(-1, prefService.getIntPref(pref_max_resumed_crashes));
+
+ // normal startup after 1 non-recent crash (1 year ago), no other recent
+ replacedLockTime = Date.now() - 365 * 24 * 60 * 60 * 1000;
+ resetTestEnv(replacedLockTime);
+ prefService.setIntPref(pref_last_success, ms_to_s(replacedLockTime) - 365 * 24 * 60 * 60);
+ do_check_false(appStartup.trackStartupCrashBegin());
+ // recent crash count pref should be unset since the last crash was not recent
+ do_check_false(prefService.prefHasUserValue(pref_recent_crashes));
+ do_check_false(appStartup.automaticSafeModeNecessary);
+
+ // normal startup after 1 crash (1 minute ago), no other recent
+ replacedLockTime = Date.now() - 60 * 1000;
+ resetTestEnv(replacedLockTime);
+ prefService.setIntPref(pref_last_success, ms_to_s(replacedLockTime) - 60 * 60); // last success - 1 hour ago
+ do_check_false(appStartup.trackStartupCrashBegin());
+ // recent crash count pref should be created with value 1
+ do_check_eq(1, prefService.getIntPref(pref_recent_crashes));
+ do_check_false(appStartup.automaticSafeModeNecessary);
+
+ // normal startup after another crash (1 minute ago), 1 already
+ prefService.setIntPref(pref_last_success, ms_to_s(replacedLockTime) - 60 * 60); // last success - 1 hour ago
+ replacedLockTime = Date.now() - 60 * 1000;
+ gAppInfo.replacedLockTime = replacedLockTime;
+ do_check_false(appStartup.trackStartupCrashBegin());
+ // recent crash count pref should be incremented by 1
+ do_check_eq(2, prefService.getIntPref(pref_recent_crashes));
+ do_check_false(appStartup.automaticSafeModeNecessary);
+
+ // normal startup after another crash (1 minute ago), 2 already
+ prefService.setIntPref(pref_last_success, ms_to_s(replacedLockTime) - 60 * 60); // last success - 1 hour ago
+ do_check_true(appStartup.trackStartupCrashBegin());
+ // recent crash count pref should be incremented by 1
+ do_check_eq(3, prefService.getIntPref(pref_recent_crashes));
+ do_check_true(appStartup.automaticSafeModeNecessary);
+
+ // normal startup after 1 non-recent crash (1 year ago), 3 crashes already
+ replacedLockTime = Date.now() - 365 * 24 * 60 * 60 * 1000;
+ resetTestEnv(replacedLockTime);
+ prefService.setIntPref(pref_last_success, ms_to_s(replacedLockTime) - 60 * 60); // last success - 1 hour ago
+ do_check_false(appStartup.trackStartupCrashBegin());
+ // recent crash count should be unset since the last crash was not recent
+ do_check_false(prefService.prefHasUserValue(pref_recent_crashes));
+ do_check_false(appStartup.automaticSafeModeNecessary);
+}
+
+function test_trackStartupCrashEnd() {
+ // successful startup with no last_success (upgrade test)
+ let replacedLockTime = Date.now() - 10 * 1000; // 10s ago
+ resetTestEnv(replacedLockTime);
+ try {
+ appStartup.trackStartupCrashBegin(); // required to be called before end
+ do_throw("Should have thrown since last_success is not set");
+ } catch (x) { }
+ appStartup.trackStartupCrashEnd();
+ do_check_false(prefService.prefHasUserValue(pref_recent_crashes));
+ do_check_false(prefService.prefHasUserValue(pref_last_success));
+
+ // successful startup - should set last_success
+ replacedLockTime = Date.now() - 10 * 1000; // 10s ago
+ resetTestEnv(replacedLockTime);
+ prefService.setIntPref(pref_last_success, ms_to_s(replacedLockTime));
+ appStartup.trackStartupCrashBegin(); // required to be called before end
+ appStartup.trackStartupCrashEnd();
+ // ensure last_success was set since we have declared a succesful startup
+ // main timestamp doesn't get set in XPCShell so approximate with now
+ do_check_true(prefService.getIntPref(pref_last_success) <= now_seconds());
+ do_check_true(prefService.getIntPref(pref_last_success) >= now_seconds() - 4 * 60 * 60);
+ do_check_false(prefService.prefHasUserValue(pref_recent_crashes));
+
+ // successful startup with 1 recent crash
+ resetTestEnv(replacedLockTime);
+ prefService.setIntPref(pref_last_success, ms_to_s(replacedLockTime));
+ prefService.setIntPref(pref_recent_crashes, 1);
+ appStartup.trackStartupCrashBegin(); // required to be called before end
+ appStartup.trackStartupCrashEnd();
+ // ensure recent_crashes was cleared since we have declared a succesful startup
+ do_check_false(prefService.prefHasUserValue(pref_recent_crashes));
+}
+
+function test_trackStartupCrashBegin_safeMode() {
+ gAppInfo.inSafeMode = true;
+ resetTestEnv(0);
+ let max_resumed = prefService.getIntPref(pref_max_resumed_crashes);
+
+ // check manual safe mode doesn't change prefs without crash
+ let replacedLockTime = Date.now() - 10 * 1000; // 10s ago
+ resetTestEnv(replacedLockTime);
+ prefService.setIntPref(pref_last_success, ms_to_s(replacedLockTime));
+
+ do_check_false(prefService.prefHasUserValue(pref_recent_crashes));
+ do_check_true(prefService.prefHasUserValue(pref_last_success));
+ do_check_false(appStartup.automaticSafeModeNecessary);
+ do_check_false(appStartup.trackStartupCrashBegin());
+ do_check_false(prefService.prefHasUserValue(pref_recent_crashes));
+ do_check_true(prefService.prefHasUserValue(pref_last_success));
+ do_check_false(appStartup.automaticSafeModeNecessary);
+
+ // check forced safe mode doesn't change prefs without crash
+ replacedLockTime = Date.now() - 10 * 1000; // 10s ago
+ resetTestEnv(replacedLockTime);
+ prefService.setIntPref(pref_last_success, ms_to_s(replacedLockTime));
+ prefService.setIntPref(pref_recent_crashes, max_resumed + 1);
+
+ do_check_eq(max_resumed + 1, prefService.getIntPref(pref_recent_crashes));
+ do_check_true(prefService.prefHasUserValue(pref_last_success));
+ do_check_false(appStartup.automaticSafeModeNecessary);
+ do_check_true(appStartup.trackStartupCrashBegin());
+ do_check_eq(max_resumed + 1, prefService.getIntPref(pref_recent_crashes));
+ do_check_true(prefService.prefHasUserValue(pref_last_success));
+ do_check_true(appStartup.automaticSafeModeNecessary);
+
+ // check forced safe mode after old crash
+ replacedLockTime = Date.now() - 365 * 24 * 60 * 60 * 1000;
+ resetTestEnv(replacedLockTime);
+ // one year ago
+ let last_success = ms_to_s(replacedLockTime) - 365 * 24 * 60 * 60;
+ prefService.setIntPref(pref_last_success, last_success);
+ prefService.setIntPref(pref_recent_crashes, max_resumed + 1);
+ do_check_eq(max_resumed + 1, prefService.getIntPref(pref_recent_crashes));
+ do_check_true(prefService.prefHasUserValue(pref_last_success));
+ do_check_true(appStartup.automaticSafeModeNecessary);
+ do_check_true(appStartup.trackStartupCrashBegin());
+ do_check_eq(max_resumed + 1, prefService.getIntPref(pref_recent_crashes));
+ do_check_eq(last_success, prefService.getIntPref(pref_last_success));
+ do_check_true(appStartup.automaticSafeModeNecessary);
+}
+
+function test_trackStartupCrashEnd_safeMode() {
+ gAppInfo.inSafeMode = true;
+ let replacedLockTime = Date.now();
+ resetTestEnv(replacedLockTime);
+ let max_resumed = prefService.getIntPref(pref_max_resumed_crashes);
+ prefService.setIntPref(pref_last_success, ms_to_s(replacedLockTime) - 24 * 60 * 60);
+
+ // ensure recent_crashes were not cleared in manual safe mode
+ prefService.setIntPref(pref_recent_crashes, 1);
+ appStartup.trackStartupCrashBegin(); // required to be called before end
+ appStartup.trackStartupCrashEnd();
+ do_check_eq(1, prefService.getIntPref(pref_recent_crashes));
+
+ // recent_crashes should be set to max_resumed in forced safe mode to allow the user
+ // to try and start in regular mode after making changes.
+ prefService.setIntPref(pref_recent_crashes, max_resumed + 1);
+ appStartup.trackStartupCrashBegin(); // required to be called before end
+ appStartup.trackStartupCrashEnd();
+ do_check_eq(max_resumed, prefService.getIntPref(pref_recent_crashes));
+}
+
+function test_maxResumed() {
+ resetTestEnv(0);
+ gAppInfo.inSafeMode = false;
+ let max_resumed = prefService.getIntPref(pref_max_resumed_crashes);
+ let replacedLockTime = Date.now();
+ resetTestEnv(replacedLockTime);
+ prefService.setIntPref(pref_max_resumed_crashes, -1);
+
+ prefService.setIntPref(pref_recent_crashes, max_resumed + 1);
+ prefService.setIntPref(pref_last_success, ms_to_s(replacedLockTime) - 24 * 60 * 60);
+ appStartup.trackStartupCrashBegin();
+ // should remain the same since the last startup was not a crash
+ do_check_eq(max_resumed + 2, prefService.getIntPref(pref_recent_crashes));
+ do_check_false(appStartup.automaticSafeModeNecessary);
+}
diff --git a/toolkit/components/startup/tests/unit/xpcshell.ini b/toolkit/components/startup/tests/unit/xpcshell.ini
new file mode 100644
index 000000000..294800ee3
--- /dev/null
+++ b/toolkit/components/startup/tests/unit/xpcshell.ini
@@ -0,0 +1,6 @@
+[DEFAULT]
+head = head_startup.js
+tail =
+skip-if = toolkit == 'android'
+
+[test_startup_crash.js]