diff options
Diffstat (limited to 'toolkit/components/startup')
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] |