The Tor Browser: services/healthreport/profile.jsm@97036ab72558 (annotated)

services/healthreport/profile.jsm@97036ab72558 (annotated)

services/healthreport/profile.jsm

Tue, 06 Jan 2015 21:39:09 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Tue, 06 Jan 2015 21:39:09 +0100
branch: TOR_BUG_9701
changeset 8: 97036ab72558
permissions: -rw-r--r--

Conditionally force memory storage according to privacy.thirdparty.isolate;
This solves Tor bug #9701, complying with disk avoidance documented in
https://www.torproject.org/projects/torbrowser/design/#disk-avoidance.

 /* 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";
 #ifndef MERGED_COMPARTMENT
 this.EXPORTED_SYMBOLS = [
   "ProfileCreationTimeAccessor",
   "ProfileMetadataProvider",
 ];
 const {utils: Cu, classes: Cc, interfaces: Ci} = Components;
 const MILLISECONDS_PER_DAY = 24 * 60 * 60 * 1000;
 Cu.import("resource://gre/modules/Metrics.jsm");
 #endif
 const DEFAULT_PROFILE_MEASUREMENT_NAME = "age";
 const REQUIRED_UINT32_TYPE = {type: "TYPE_UINT32"};
 Cu.import("resource://gre/modules/Promise.jsm");
 Cu.import("resource://gre/modules/osfile.jsm")
 Cu.import("resource://gre/modules/Task.jsm");
 Cu.import("resource://gre/modules/Log.jsm");
 Cu.import("resource://services-common/utils.js");
 // Profile creation time access.
 // This is separate from the provider to simplify testing and enable extraction
 // to a shared location in the future.
 this.ProfileCreationTimeAccessor = function(profile, log) {
   this.profilePath = profile || OS.Constants.Path.profileDir;
   if (!this.profilePath) {
     throw new Error("No profile directory.");
   }
   this._log = log || {"debug": function (s) { dump(s + "\n"); }};
 }
 this.ProfileCreationTimeAccessor.prototype = {
   /**
    * There are three ways we can get our creation time:
    *
    * 1. From our own saved value (to avoid redundant work).
    * 2. From the on-disk JSON file.
    * 3. By calculating it from the filesystem.
    *
    * If we have to calculate, we write out the file; if we have
    * to touch the file, we persist in-memory.
    *
    * @return a promise that resolves to the profile's creation time.
    */
   get created() {
     if (this._created) {
       return Promise.resolve(this._created);
     }
     function onSuccess(times) {
       if (times && times.created) {
         return this._created = times.created;
       }
       return onFailure.call(this, null, times);
     }
     function onFailure(err, times) {
       return this.computeAndPersistTimes(times)
                  .then(function onSuccess(created) {
                          return this._created = created;
                        }.bind(this));
     }
     return this.readTimes()
                .then(onSuccess.bind(this),
                      onFailure.bind(this));
   },
   /**
    * Explicitly make `file`, a filename, a full path
    * relative to our profile path.
    */
   getPath: function (file) {
     return OS.Path.join(this.profilePath, file);
   },
   /**
    * Return a promise which resolves to the JSON contents
    * of the time file in this accessor's profile.
    */
   readTimes: function (file="times.json") {
     return CommonUtils.readJSON(this.getPath(file));
   },
   /**
    * Return a promise representing the writing of `contents`
    * to `file` in the specified profile.
    */
   writeTimes: function (contents, file="times.json") {
     return CommonUtils.writeJSON(contents, this.getPath(file));
   },
   /**
    * Merge existing contents with a 'created' field, writing them
    * to the specified file. Promise, naturally.
    */
   computeAndPersistTimes: function (existingContents, file="times.json") {
     let path = this.getPath(file);
     function onOldest(oldest) {
       let contents = existingContents || {};
       contents.created = oldest;
       return this.writeTimes(contents, path)
                  .then(function onSuccess() {
                    return oldest;
                  });
     }
     return this.getOldestProfileTimestamp()
                .then(onOldest.bind(this));
   },
   /**
    * Traverse the contents of the profile directory, finding the oldest file
    * and returning its creation timestamp.
    */
   getOldestProfileTimestamp: function () {
     let self = this;
     let oldest = Date.now() + 1000;
     let iterator = new OS.File.DirectoryIterator(this.profilePath);
     self._log.debug("Iterating over profile " + this.profilePath);
     if (!iterator) {
       throw new Error("Unable to fetch oldest profile entry: no profile iterator.");
     }
     function onEntry(entry) {
       function onStatSuccess(info) {
         // OS.File doesn't seem to be behaving. See Bug 827148.
         // Let's do the best we can. This whole function is defensive.
         let date = info.winBirthDate || info.macBirthDate;
         if (!date || !date.getTime()) {
           // OS.File will only return file creation times of any kind on Mac
           // and Windows, where birthTime is defined.
           // That means we're unable to function on Linux, so we use mtime
           // instead.
           self._log.debug("No birth date. Using mtime.");
           date = info.lastModificationDate;
         }
         if (date) {
           let timestamp = date.getTime();
           self._log.debug("Using date: " + entry.path + " = " + date);
           if (timestamp < oldest) {
             oldest = timestamp;
           }
         }
       }
       function onStatFailure(e) {
         // Never mind.
         self._log.debug("Stat failure: " + CommonUtils.exceptionStr(e));
       }
       return OS.File.stat(entry.path)
                     .then(onStatSuccess, onStatFailure);
     }
     let promise = iterator.forEach(onEntry);
     function onSuccess() {
       iterator.close();
       return oldest;
     }
     function onFailure(reason) {
       iterator.close();
       throw new Error("Unable to fetch oldest profile entry: " + reason);
     }
     return promise.then(onSuccess, onFailure);
   },
 }
 /**
  * Measurements pertaining to the user's profile.
  */
 function ProfileMetadataMeasurement() {
   Metrics.Measurement.call(this);
 }
 ProfileMetadataMeasurement.prototype = {
   __proto__: Metrics.Measurement.prototype,
   name: DEFAULT_PROFILE_MEASUREMENT_NAME,
   version: 1,
   fields: {
     // Profile creation date. Number of days since Unix epoch.
     profileCreation: {type: Metrics.Storage.FIELD_LAST_NUMERIC},
   },
 };
 /**
  * Turn a millisecond timestamp into a day timestamp.
  *
  * @param msec a number of milliseconds since epoch.
  * @return the number of whole days denoted by the input.
  */
 function truncate(msec) {
   return Math.floor(msec / MILLISECONDS_PER_DAY);
 }
 /**
  * A Metrics.Provider for profile metadata, such as profile creation time.
  */
 this.ProfileMetadataProvider = function() {
   Metrics.Provider.call(this);
 }
 this.ProfileMetadataProvider.prototype = {
   __proto__: Metrics.Provider.prototype,
   name: "org.mozilla.profile",
   measurementTypes: [ProfileMetadataMeasurement],
   pullOnly: true,
   getProfileCreationDays: function () {
     let accessor = new ProfileCreationTimeAccessor(null, this._log);
     return accessor.created
                    .then(truncate);
   },
   collectConstantData: function () {
     let m = this.getMeasurement(DEFAULT_PROFILE_MEASUREMENT_NAME, 1);
     return Task.spawn(function collectConstant() {
       let createdDays = yield this.getProfileCreationDays();
       yield this.enqueueStorageOperation(function storeDays() {
         return m.setLastNumeric("profileCreation", createdDays);
       });
     }.bind(this));
   },
 };

The Tor Browser / annotate

services/healthreport/profile.jsm@97036ab72558 (annotated)

services/healthreport/profile.jsm