The Tor Browser: comparison toolkit/components/crashmonitor/CrashMonitor.jsm

--1:000000000000
+:1329015c0677
+/* -*- Mode: js; 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/. */
+/**
+* Crash Monitor
+*
+* Monitors execution of a program to detect possible crashes. After
+* program termination, the monitor can be queried during the next run
+* to determine whether the last run exited cleanly or not.
+*
+* The monitoring is done by registering and listening for special
+* notifications, or checkpoints, known to be sent by the monitored
+* program as different stages in the execution are reached. As they
+* are observed, these notifications are written asynchronously to a
+* checkpoint file.
+*
+* During next program startup the crash monitor reads the checkpoint
+* file from the last session. If notifications are missing, a crash
+* has likely happened. By inspecting the notifications present, it is
+* possible to determine what stages were reached in the program
+* before the crash.
+*
+* Note that since the file is written asynchronously it is possible
+* that a received notification is lost if the program crashes right
+* after a checkpoint, but before crash monitor has been able to write
+* it to disk. Thus, while the presence of a notification in the
+* checkpoint file tells us that the corresponding stage was reached
+* during the last run, the absence of a notification after a crash
+* does not necessarily tell us that the checkpoint wasn't reached.
+*/
+this.EXPORTED_SYMBOLS = [ "CrashMonitor" ];
+const Cu = Components.utils;
+const Cr = Components.results;
+Cu.import("resource://gre/modules/Services.jsm");
+Cu.import("resource://gre/modules/osfile.jsm");
+Cu.import("resource://gre/modules/Promise.jsm");
+Cu.import("resource://gre/modules/Task.jsm");
+Cu.import("resource://gre/modules/AsyncShutdown.jsm");
+const NOTIFICATIONS = [
+"final-ui-startup",
+"sessionstore-windows-restored",
+"quit-application-granted",
+"quit-application",
+"profile-change-net-teardown",
+"profile-change-teardown",
+"profile-before-change",
+"sessionstore-final-state-write-complete"
+];
+let CrashMonitorInternal = {
+/**
+* Notifications received during the current session.
+*
+* Object where a property with a value of |true| means that the
+* notification of the same name has been received at least once by
+* the CrashMonitor during this session. Notifications that have not
+* yet been received are not present as properties. |NOTIFICATIONS|
+* lists the notifications tracked by the CrashMonitor.
+*/
+checkpoints: {},
+/**
+* Notifications received during previous session.
+*
+* Available after |loadPreviousCheckpoints|. Promise which resolves
+* to an object containing a set of properties, where a property
+* with a value of |true| means that the notification with the same
+* name as the property name was received at least once last
+* session.
+*/
+previousCheckpoints: null,
+/* Deferred for AsyncShutdown blocker */
+profileBeforeChangeDeferred: Promise.defer(),
+/**
+* Path to checkpoint file.
+*
+* Each time a new notification is received, this file is written to
+* disc to reflect the information in |checkpoints|. Although Firefox for
+* Desktop and Metro share the same profile, they need to keep record of
+* crashes separately.
+*/
+path: (Services.metro && Services.metro.immersive) ?
+OS.Path.join(OS.Constants.Path.profileDir, "metro", "sessionCheckpoints.json"):
+OS.Path.join(OS.Constants.Path.profileDir, "sessionCheckpoints.json"),
+/**
+* Load checkpoints from previous session asynchronously.
+*
+* @return {Promise} A promise that resolves/rejects once loading is complete
+*/
+loadPreviousCheckpoints: function () {
+this.previousCheckpoints = Task.spawn(function*() {
+let data;
+try {
+data = yield OS.File.read(CrashMonitorInternal.path, { encoding: "utf-8" });
+} catch (ex if ex instanceof OS.File.Error) {
+if (!ex.becauseNoSuchFile) {
+Cu.reportError("Error while loading crash monitor data: " + ex.toString());
+}
+return null;
+}
+let notifications;
+try {
+notifications = JSON.parse(data);
+} catch (ex) {
+Cu.reportError("Error while parsing crash monitor data: " + ex);
+return null;
+}
+return Object.freeze(notifications);
+});
+return this.previousCheckpoints;
+}
+};
+this.CrashMonitor = {
+/**
+* Notifications received during previous session.
+*
+* Return object containing the set of notifications received last
+* session as keys with values set to |true|.
+*
+* @return {Promise} A promise resolving to previous checkpoints
+*/
+get previousCheckpoints() {
+if (!CrashMonitorInternal.initialized) {
+throw new Error("CrashMonitor must be initialized before getting previous checkpoints");
+}
+return CrashMonitorInternal.previousCheckpoints
+},
+/**
+* Initialize CrashMonitor.
+*
+* Should only be called from the CrashMonitor XPCOM component.
+*
+* @return {Promise}
+*/
+init: function () {
+if (CrashMonitorInternal.initialized) {
+throw new Error("CrashMonitor.init() must only be called once!");
+}
+let promise = CrashMonitorInternal.loadPreviousCheckpoints();
+// Add "profile-after-change" to checkpoint as this method is
+// called after receiving it
+CrashMonitorInternal.checkpoints["profile-after-change"] = true;
+NOTIFICATIONS.forEach(function (aTopic) {
+Services.obs.addObserver(this, aTopic, false);
+}, this);
+// Add shutdown blocker for profile-before-change
+AsyncShutdown.profileBeforeChange.addBlocker(
+"CrashMonitor: Writing notifications to file after receiving profile-before-change",
+CrashMonitorInternal.profileBeforeChangeDeferred.promise
+);
+CrashMonitorInternal.initialized = true;
+if (Services.metro && Services.metro.immersive) {
+OS.File.makeDir(OS.Path.join(OS.Constants.Path.profileDir, "metro"));
+}
+return promise;
+},
+/**
+* Handle registered notifications.
+*
+* Update checkpoint file for every new notification received.
+*/
+observe: function (aSubject, aTopic, aData) {
+if (!(aTopic in CrashMonitorInternal.checkpoints)) {
+// If this is the first time this notification is received,
+// remember it and write it to file
+CrashMonitorInternal.checkpoints[aTopic] = true;
+Task.spawn(function() {
+try {
+let data = JSON.stringify(CrashMonitorInternal.checkpoints);
+/* Write to the checkpoint file asynchronously, off the main
+* thread, for performance reasons. Note that this means
+* that there's not a 100% guarantee that the file will be
+* written by the time the notification completes. The
+* exception is profile-before-change which has a shutdown
+* blocker. */
+yield OS.File.writeAtomic(
+CrashMonitorInternal.path,
+data, {tmpPath: CrashMonitorInternal.path + ".tmp"});
+} finally {
+// Resolve promise for blocker
+if (aTopic == "profile-before-change") {
+CrashMonitorInternal.profileBeforeChangeDeferred.resolve();
+}
+}
+});
+}
+if (NOTIFICATIONS.every(elem => elem in CrashMonitorInternal.checkpoints)) {
+// All notifications received, unregister observers
+NOTIFICATIONS.forEach(function (aTopic) {
+Services.obs.removeObserver(this, aTopic);
+}, this);
+}
+}
+};
+Object.freeze(this.CrashMonitor);

The Tor Browser / file comparison

comparison: toolkit/components/crashmonitor/CrashMonitor.jsm

toolkit/components/crashmonitor/CrashMonitor.jsm