The Tor Browser / file revision

 /* 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";

 this.EXPORTED_SYMBOLS = [

   "Experiments",

   "ExperimentsProvider",

 ];

 const {classes: Cc, interfaces: Ci, utils: Cu} = Components;

 Cu.import("resource://gre/modules/XPCOMUtils.jsm");

 Cu.import("resource://gre/modules/Services.jsm");

 Cu.import("resource://gre/modules/Task.jsm");

 Cu.import("resource://gre/modules/Promise.jsm");

 Cu.import("resource://gre/modules/osfile.jsm");

 Cu.import("resource://gre/modules/Log.jsm");

 Cu.import("resource://gre/modules/Preferences.jsm");

 Cu.import("resource://gre/modules/AsyncShutdown.jsm");

 XPCOMUtils.defineLazyModuleGetter(this, "UpdateChannel",

                                   "resource://gre/modules/UpdateChannel.jsm");

 XPCOMUtils.defineLazyModuleGetter(this, "AddonManager",

                                   "resource://gre/modules/AddonManager.jsm");

 XPCOMUtils.defineLazyModuleGetter(this, "AddonManagerPrivate",

                                   "resource://gre/modules/AddonManager.jsm");

 XPCOMUtils.defineLazyModuleGetter(this, "TelemetryPing",

                                   "resource://gre/modules/TelemetryPing.jsm");

 XPCOMUtils.defineLazyModuleGetter(this, "TelemetryLog",

                                   "resource://gre/modules/TelemetryLog.jsm");

 XPCOMUtils.defineLazyModuleGetter(this, "CommonUtils",

                                   "resource://services-common/utils.js");

 XPCOMUtils.defineLazyModuleGetter(this, "Metrics",

                                   "resource://gre/modules/Metrics.jsm");

 // CertUtils.jsm doesn't expose a single "CertUtils" object like a normal .jsm

 // would.

 XPCOMUtils.defineLazyGetter(this, "CertUtils",

   function() {

     var mod = {};

     Cu.import("resource://gre/modules/CertUtils.jsm", mod);

     return mod;

   });

 XPCOMUtils.defineLazyServiceGetter(this, "gCrashReporter",

                                    "@mozilla.org/xre/app-info;1",

                                    "nsICrashReporter");

 const FILE_CACHE                = "experiments.json";

 const EXPERIMENTS_CHANGED_TOPIC = "experiments-changed";

 const MANIFEST_VERSION          = 1;

 const CACHE_VERSION             = 1;

 const KEEP_HISTORY_N_DAYS       = 180;

 const MIN_EXPERIMENT_ACTIVE_SECONDS = 60;

 const PREF_BRANCH               = "experiments.";

 const PREF_ENABLED              = "enabled"; // experiments.enabled

 const PREF_ACTIVE_EXPERIMENT    = "activeExperiment"; // whether we have an active experiment

 const PREF_LOGGING              = "logging";

 const PREF_LOGGING_LEVEL        = PREF_LOGGING + ".level"; // experiments.logging.level

 const PREF_LOGGING_DUMP         = PREF_LOGGING + ".dump"; // experiments.logging.dump

 const PREF_MANIFEST_URI         = "manifest.uri"; // experiments.logging.manifest.uri

 const PREF_MANIFEST_CHECKCERT   = "manifest.cert.checkAttributes"; // experiments.manifest.cert.checkAttributes

 const PREF_MANIFEST_REQUIREBUILTIN = "manifest.cert.requireBuiltin"; // experiments.manifest.cert.requireBuiltin

 const PREF_FORCE_SAMPLE = "force-sample-value"; // experiments.force-sample-value

 const PREF_HEALTHREPORT_ENABLED = "datareporting.healthreport.service.enabled";

 const PREF_BRANCH_TELEMETRY     = "toolkit.telemetry.";

 const PREF_TELEMETRY_ENABLED    = "enabled";

 const URI_EXTENSION_STRINGS     = "chrome://mozapps/locale/extensions/extensions.properties";

 const STRING_TYPE_NAME          = "type.%ID%.name";

 const TELEMETRY_LOG = {

   // log(key, [kind, experimentId, details])

   ACTIVATION_KEY: "EXPERIMENT_ACTIVATION",

   ACTIVATION: {

     // Successfully activated.

     ACTIVATED: "ACTIVATED",

     // Failed to install the add-on.

     INSTALL_FAILURE: "INSTALL_FAILURE",

     // Experiment does not meet activation requirements. Details will

     // be provided.

     REJECTED: "REJECTED",

   },

   // log(key, [kind, experimentId, optionalDetails...])

   TERMINATION_KEY: "EXPERIMENT_TERMINATION",

   TERMINATION: {

     // The Experiments service was disabled.

     SERVICE_DISABLED: "SERVICE_DISABLED",

     // Add-on uninstalled.

     ADDON_UNINSTALLED: "ADDON_UNINSTALLED",

     // The experiment disabled itself.

     FROM_API: "FROM_API",

     // The experiment expired (e.g. by exceeding the end date).

     EXPIRED: "EXPIRED",

     // Disabled after re-evaluating conditions. If this is specified,

     // details will be provided.

     RECHECK: "RECHECK",

   },

 };

 const gPrefs = new Preferences(PREF_BRANCH);

 const gPrefsTelemetry = new Preferences(PREF_BRANCH_TELEMETRY);

 let gExperimentsEnabled = false;

 let gAddonProvider = null;

 let gExperiments = null;

 let gLogAppenderDump = null;

 let gPolicyCounter = 0;

 let gExperimentsCounter = 0;

 let gExperimentEntryCounter = 0;

 let gPreviousProviderCounter = 0;

 // Tracks active AddonInstall we know about so we can deny external

 // installs.

 let gActiveInstallURLs = new Set();

 // Tracks add-on IDs that are being uninstalled by us. This allows us

 // to differentiate between expected uninstalled and user-driven uninstalls.

 let gActiveUninstallAddonIDs = new Set();

 let gLogger;

 let gLogDumping = false;

 function configureLogging() {

   if (!gLogger) {

     gLogger = Log.repository.getLogger("Browser.Experiments");

     gLogger.addAppender(new Log.ConsoleAppender(new Log.BasicFormatter()));

   }

   gLogger.level = gPrefs.get(PREF_LOGGING_LEVEL, Log.Level.Warn);

   let logDumping = gPrefs.get(PREF_LOGGING_DUMP, false);

   if (logDumping != gLogDumping) {

     if (logDumping) {

       gLogAppenderDump = new Log.DumpAppender(new Log.BasicFormatter());

       gLogger.addAppender(gLogAppenderDump);

     } else {

       gLogger.removeAppender(gLogAppenderDump);

       gLogAppenderDump = null;

     }

     gLogDumping = logDumping;

   }

 }

 // Takes an array of promises and returns a promise that is resolved once all of

 // them are rejected or resolved.

 function allResolvedOrRejected(promises) {

   if (!promises.length) {

     return Promise.resolve([]);

   }

   let countdown = promises.length;

   let deferred = Promise.defer();

   for (let p of promises) {

     let helper = () => {

       if (--countdown == 0) {

         deferred.resolve();

       }

     };

     Promise.resolve(p).then(helper, helper);

   }

   return deferred.promise;

 }

 // Loads a JSON file using OS.file. file is a string representing the path

 // of the file to be read, options contains additional options to pass to

 // OS.File.read.

 // Returns a Promise resolved with the json payload or rejected with

 // OS.File.Error or JSON.parse() errors.

 function loadJSONAsync(file, options) {

   return Task.spawn(function() {

     let rawData = yield OS.File.read(file, options);

     // Read json file into a string

     let data;

     try {

       // Obtain a converter to read from a UTF-8 encoded input stream.

       let converter = new TextDecoder();

       data = JSON.parse(converter.decode(rawData));

     } catch (ex) {

       gLogger.error("Experiments: Could not parse JSON: " + file + " " + ex);

       throw ex;

     }

     throw new Task.Result(data);

   });

 }

 function telemetryEnabled() {

   return gPrefsTelemetry.get(PREF_TELEMETRY_ENABLED, false);

 }

 // Returns a promise that is resolved with the AddonInstall for that URL.

 function addonInstallForURL(url, hash) {

   let deferred = Promise.defer();

   AddonManager.getInstallForURL(url, install => deferred.resolve(install),

                                 "application/x-xpinstall", hash);

   return deferred.promise;

 }

 // Returns a promise that is resolved with an Array<Addon> of the installed

 // experiment addons.

 function installedExperimentAddons() {

   let deferred = Promise.defer();

   AddonManager.getAddonsByTypes(["experiment"], (addons) => {

     deferred.resolve([a for (a of addons) if (!a.appDisabled)]);

   });

   return deferred.promise;

 }

 // Takes an Array<Addon> and returns a promise that is resolved when the

 // addons are uninstalled.

 function uninstallAddons(addons) {

   let ids = new Set([a.id for (a of addons)]);

   let deferred = Promise.defer();

   let listener = {};

   listener.onUninstalled = addon => {

     if (!ids.has(addon.id)) {

       return;

     }

     ids.delete(addon.id);

     if (ids.size == 0) {

       AddonManager.removeAddonListener(listener);

       deferred.resolve();

     }

   };

   AddonManager.addAddonListener(listener);

   for (let addon of addons) {

     // Disabling the add-on before uninstalling is necessary to cause tests to

     // pass. This might be indicative of a bug in XPIProvider.

     // TODO follow up in bug 992396.

     addon.userDisabled = true;

     addon.uninstall();

   }

   return deferred.promise;

 }

 /**

  * The experiments module.

  */

 let Experiments = {

   /**

    * Provides access to the global `Experiments.Experiments` instance.

    */

   instance: function () {

     if (!gExperiments) {

       gExperiments = new Experiments.Experiments();

     }

     return gExperiments;

   },

 };

 /*

  * The policy object allows us to inject fake enviroment data from the

  * outside by monkey-patching.

  */

 Experiments.Policy = function () {

   this._log = Log.repository.getLoggerWithMessagePrefix(

     "Browser.Experiments.Policy",

     "Policy #" + gPolicyCounter++ + "::");

   // Set to true to ignore hash verification on downloaded XPIs. This should

   // not be used outside of testing.

   this.ignoreHashes = false;

 };

 Experiments.Policy.prototype = {

   now: function () {

     return new Date();

   },

   random: function () {

     let pref = gPrefs.get(PREF_FORCE_SAMPLE);

     if (pref !== undefined) {

       let val = Number.parseFloat(pref);

       this._log.debug("random sample forced: " + val);

       if (isNaN(val) || val < 0) {

         return 0;

       }

       if (val > 1) {

         return 1;

       }

       return val;

     }

     return Math.random();

   },

   futureDate: function (offset) {

     return new Date(this.now().getTime() + offset);

   },

   oneshotTimer: function (callback, timeout, thisObj, name) {

     return CommonUtils.namedTimer(callback, timeout, thisObj, name);

   },

   updatechannel: function () {

     return UpdateChannel.get();

   },

   locale: function () {

     let chrome = Cc["@mozilla.org/chrome/chrome-registry;1"].getService(Ci.nsIXULChromeRegistry);

     return chrome.getSelectedLocale("global");

   },

   /*

    * @return Promise<> Resolved with the payload data.

    */

   healthReportPayload: function () {

     return Task.spawn(function*() {

       let reporter = Cc["@mozilla.org/datareporting/service;1"]

             .getService(Ci.nsISupports)

             .wrappedJSObject

             .healthReporter;

       yield reporter.onInit();

       let payload = yield reporter.collectAndObtainJSONPayload();

       throw new Task.Result(payload);

     });

   },

   telemetryPayload: function () {

     return TelemetryPing.getPayload();

   },

 };

 function AlreadyShutdownError(message="already shut down") {

   this.name = "AlreadyShutdownError";

   this.message = message;

 }

 AlreadyShutdownError.prototype = new Error();

 AlreadyShutdownError.prototype.constructor = AlreadyShutdownError;

 /**

  * Manages the experiments and provides an interface to control them.

  */

 Experiments.Experiments = function (policy=new Experiments.Policy()) {

   this._log = Log.repository.getLoggerWithMessagePrefix(

     "Browser.Experiments.Experiments",

     "Experiments #" + gExperimentsCounter++ + "::");

   this._log.trace("constructor");

   this._policy = policy;

   // This is a Map of (string -> ExperimentEntry), keyed with the experiment id.

   // It holds both the current experiments and history.

   // Map() preserves insertion order, which means we preserve the manifest order.

   // This is null until we've successfully completed loading the cache from

   // disk the first time.

   this._experiments = null;

   this._refresh = false;

   this._terminateReason = null; // or TELEMETRY_LOG.TERMINATION....

   this._dirty = false;

   // Loading the cache happens once asynchronously on startup

   this._loadTask = null;

   // The _main task handles all other actions:

   // * refreshing the manifest off the network (if _refresh)

   // * disabling/enabling experiments

   // * saving the cache (if _dirty)

   this._mainTask = null;

   // Timer for re-evaluating experiment status.

   this._timer = null;

   this._shutdown = false;

   // We need to tell when we first evaluated the experiments to fire an

   // experiments-changed notification when we only loaded completed experiments.

   this._firstEvaluate = true;

   this.init();

 };

 Experiments.Experiments.prototype = {

   QueryInterface: XPCOMUtils.generateQI([Ci.nsITimerCallback, Ci.nsIObserver]),

   init: function () {

     this._shutdown = false;

     configureLogging();

     gExperimentsEnabled = gPrefs.get(PREF_ENABLED, false);

     this._log.trace("enabled=" + gExperimentsEnabled + ", " + this.enabled);

     gPrefs.observe(PREF_LOGGING, configureLogging);

     gPrefs.observe(PREF_MANIFEST_URI, this.updateManifest, this);

     gPrefs.observe(PREF_ENABLED, this._toggleExperimentsEnabled, this);

     gPrefsTelemetry.observe(PREF_TELEMETRY_ENABLED, this._telemetryStatusChanged, this);

     AsyncShutdown.profileBeforeChange.addBlocker("Experiments.jsm shutdown",

       this.uninit.bind(this));

     this._registerWithAddonManager();

     let deferred = Promise.defer();

     this._loadTask = this._loadFromCache();

     this._loadTask.then(

       () => {

         this._log.trace("_loadTask finished ok");

         this._loadTask = null;

         this._run().then(deferred.resolve, deferred.reject);

       },

       (e) => {

         this._log.error("_loadFromCache caught error: " + e);

         deferred.reject(e);

       }

     );

     return deferred.promise;

   },

   /**

    * Uninitialize this instance.

    *

    * This function is susceptible to race conditions. If it is called multiple

    * times before the previous uninit() has completed or if it is called while

    * an init() operation is being performed, the object may get in bad state

    * and/or deadlock could occur.

    *

    * @return Promise<>

    *         The promise is fulfilled when all pending tasks are finished.

    */

   uninit: Task.async(function* () {

     this._log.trace("uninit: started");

     yield this._loadTask;

     this._log.trace("uninit: finished with _loadTask");

     if (!this._shutdown) {

       this._log.trace("uninit: no previous shutdown");

       this._unregisterWithAddonManager();

       gPrefs.ignore(PREF_LOGGING, configureLogging);

       gPrefs.ignore(PREF_MANIFEST_URI, this.updateManifest, this);

       gPrefs.ignore(PREF_ENABLED, this._toggleExperimentsEnabled, this);

       gPrefsTelemetry.ignore(PREF_TELEMETRY_ENABLED, this._telemetryStatusChanged, this);

       if (this._timer) {

         this._timer.clear();

       }

     }

     this._shutdown = true;

     if (this._mainTask) {

       try {

         this._log.trace("uninit: waiting on _mainTask");

         yield this._mainTask;

       } catch (e if e instanceof AlreadyShutdownError) {

         // We error out of tasks after shutdown via that exception.

       }

     }

     this._log.info("Completed uninitialization.");

   }),

   _registerWithAddonManager: function (previousExperimentsProvider) {

     this._log.trace("Registering instance with Addon Manager.");

     AddonManager.addAddonListener(this);

     AddonManager.addInstallListener(this);

     if (!gAddonProvider) {

       // The properties of this AddonType should be kept in sync with the

       // experiment AddonType registered in XPIProvider.

       this._log.trace("Registering previous experiment add-on provider.");

       gAddonProvider = previousExperimentsProvider || new Experiments.PreviousExperimentProvider(this);

       AddonManagerPrivate.registerProvider(gAddonProvider, [

           new AddonManagerPrivate.AddonType("experiment",

                                             URI_EXTENSION_STRINGS,

                                             STRING_TYPE_NAME,

                                             AddonManager.VIEW_TYPE_LIST,

                                             11000,

                                             AddonManager.TYPE_UI_HIDE_EMPTY),

       ]);

     }

   },

   _unregisterWithAddonManager: function () {

     this._log.trace("Unregistering instance with Addon Manager.");

     if (gAddonProvider) {

       this._log.trace("Unregistering previous experiment add-on provider.");

       AddonManagerPrivate.unregisterProvider(gAddonProvider);

       gAddonProvider = null;

     }

     AddonManager.removeInstallListener(this);

     AddonManager.removeAddonListener(this);

   },

   /*

    * Change the PreviousExperimentsProvider that this instance uses.

    * For testing only.

    */

   _setPreviousExperimentsProvider: function (provider) {

     this._unregisterWithAddonManager();

     this._registerWithAddonManager(provider);

   },

   /**

    * Throws an exception if we've already shut down.

    */

   _checkForShutdown: function() {

     if (this._shutdown) {

       throw new AlreadyShutdownError("uninit() already called");

     }

   },

   /**

    * Whether the experiments feature is enabled.

    */

   get enabled() {

     return gExperimentsEnabled;

   },

   /**

    * Toggle whether the experiments feature is enabled or not.

    */

   set enabled(enabled) {

     this._log.trace("set enabled(" + enabled + ")");

     gPrefs.set(PREF_ENABLED, enabled);

   },

   _toggleExperimentsEnabled: Task.async(function* (enabled) {

     this._log.trace("_toggleExperimentsEnabled(" + enabled + ")");

     let wasEnabled = gExperimentsEnabled;

     gExperimentsEnabled = enabled && telemetryEnabled();

     if (wasEnabled == gExperimentsEnabled) {

       return;

     }

     if (gExperimentsEnabled) {

       yield this.updateManifest();

     } else {

       yield this.disableExperiment(TELEMETRY_LOG.TERMINATION.SERVICE_DISABLED);

       if (this._timer) {

         this._timer.clear();

       }

     }

   }),

   _telemetryStatusChanged: function () {

     this._toggleExperimentsEnabled(gExperimentsEnabled);

   },

   /**

    * Returns a promise that is resolved with an array of `ExperimentInfo` objects,

    * which provide info on the currently and recently active experiments.

    * The array is in chronological order.

    *

    * The experiment info is of the form:

    * {

    *   id: <string>,

    *   name: <string>,

    *   description: <string>,

    *   active: <boolean>,

    *   endDate: <integer>, // epoch ms

    *   detailURL: <string>,

    *   ... // possibly extended later

    * }

    *

    * @return Promise<Array<ExperimentInfo>> Array of experiment info objects.

    */

   getExperiments: function () {

     return Task.spawn(function*() {

       yield this._loadTask;

       let list = [];

       for (let [id, experiment] of this._experiments) {

         if (!experiment.startDate) {

           // We only collect experiments that are or were active.

           continue;

         }

         list.push({

           id: id,

           name: experiment._name,

           description: experiment._description,

           active: experiment.enabled,

           endDate: experiment.endDate.getTime(),

           detailURL: experiment._homepageURL,

 	  branch: experiment.branch,

         });

       }

       // Sort chronologically, descending.

       list.sort((a, b) => b.endDate - a.endDate);

       return list;

     }.bind(this));

   },

   /**

    * Returns the ExperimentInfo for the active experiment, or null

    * if there is none.

    */

   getActiveExperiment: function () {

     let experiment = this._getActiveExperiment();

     if (!experiment) {

       return null;

     }

     let info = {

       id: experiment.id,

       name: experiment._name,

       description: experiment._description,

       active: experiment.enabled,

       endDate: experiment.endDate.getTime(),

       detailURL: experiment._homepageURL,

     };

     return info;

   },

   /**

    * Experiment "branch" support. If an experiment has multiple branches, it

    * can record the branch with the experiment system and it will

    * automatically be included in data reporting (FHR/telemetry payloads).

    */

   /**

    * Set the experiment branch for the specified experiment ID.

    * @returns Promise<>

    */

   setExperimentBranch: Task.async(function*(id, branchstr) {

     yield this._loadTask;

     let e = this._experiments.get(id);

     if (!e) {

       throw new Error("Experiment not found");

     }

     e.branch = String(branchstr);

     this._dirty = true;

     Services.obs.notifyObservers(null, EXPERIMENTS_CHANGED_TOPIC, null);

     yield this._run();

   }),

   /**

    * Get the branch of the specified experiment. If the experiment is unknown,

    * throws an error.

    *

    * @param id The ID of the experiment. Pass null for the currently running

    *           experiment.

    * @returns Promise<string|null>

    * @throws Error if the specified experiment ID is unknown, or if there is no

    *         current experiment.

    */

   getExperimentBranch: Task.async(function*(id=null) {

     yield this._loadTask;

     let e;

     if (id) {

       e = this._experiments.get(id);

       if (!e) {

         throw new Error("Experiment not found");

       }

     } else {

       e = this._getActiveExperiment();

       if (e === null) {

 	throw new Error("No active experiment");

       }

     }

     return e.branch;

   }),

   /**

    * Determine whether another date has the same UTC day as now().

    */

   _dateIsTodayUTC: function (d) {

     let now = this._policy.now();

     return stripDateToMidnight(now).getTime() == stripDateToMidnight(d).getTime();

   },

   /**

    * Obtain the entry of the most recent active experiment that was active

    * today.

    *

    * If no experiment was active today, this resolves to nothing.

    *

    * Assumption: Only a single experiment can be active at a time.

    *

    * @return Promise<object>

    */

   lastActiveToday: function () {

     return Task.spawn(function* getMostRecentActiveExperimentTask() {

       let experiments = yield this.getExperiments();

       // Assumption: Ordered chronologically, descending, with active always

       // first.

       for (let experiment of experiments) {

         if (experiment.active) {

           return experiment;

         }

         if (experiment.endDate && this._dateIsTodayUTC(experiment.endDate)) {

           return experiment;

         }

       }

       return null;

     }.bind(this));

   },

   _run: function() {

     this._log.trace("_run");

     this._checkForShutdown();

     if (!this._mainTask) {

       this._mainTask = Task.spawn(this._main.bind(this));

       this._mainTask.then(

         () => {

           this._log.trace("_main finished, scheduling next run");

           this._mainTask = null;

           this._scheduleNextRun();

         },

         (e) => {

           this._log.error("_main caught error: " + e);

           this._mainTask = null;

         }

       );

     }

     return this._mainTask;

   },

   _main: function*() {

     do {

       this._log.trace("_main iteration");

       yield this._loadTask;

       if (!gExperimentsEnabled) {

         this._refresh = false;

       }

       if (this._refresh) {

         yield this._loadManifest();

       }

       yield this._evaluateExperiments();

       if (this._dirty) {

         yield this._saveToCache();

       }

       // If somebody called .updateManifest() or disableExperiment()

       // while we were running, go again right now.

     }

     while (this._refresh || this._terminateReason);

   },

   _loadManifest: function*() {

     this._log.trace("_loadManifest");

     let uri = Services.urlFormatter.formatURLPref(PREF_BRANCH + PREF_MANIFEST_URI);

     this._checkForShutdown();

     this._refresh = false;

     try {

       let responseText = yield this._httpGetRequest(uri);

       this._log.trace("_loadManifest() - responseText=\"" + responseText + "\"");

       if (this._shutdown) {

         return;

       }

       let data = JSON.parse(responseText);

       this._updateExperiments(data);

     } catch (e) {

       this._log.error("_loadManifest - failure to fetch/parse manifest (continuing anyway): " + e);

     }

   },

   /**

    * Fetch an updated list of experiments and trigger experiment updates.

    * Do only use when experiments are enabled.

    *

    * @return Promise<>

    *         The promise is resolved when the manifest and experiment list is updated.

    */

   updateManifest: function () {

     this._log.trace("updateManifest()");

     if (!gExperimentsEnabled) {

       return Promise.reject(new Error("experiments are disabled"));

     }

     if (this._shutdown) {

       return Promise.reject(Error("uninit() alrady called"));

     }

     this._refresh = true;

     return this._run();

   },

   notify: function (timer) {

     this._log.trace("notify()");

     this._checkForShutdown();

     return this._run();

   },

   // START OF ADD-ON LISTENERS

   onUninstalled: function (addon) {

     this._log.trace("onUninstalled() - addon id: " + addon.id);

     if (gActiveUninstallAddonIDs.has(addon.id)) {

       this._log.trace("matches pending uninstall");

       return;

     }

     let activeExperiment = this._getActiveExperiment();

     if (!activeExperiment || activeExperiment._addonId != addon.id) {

       return;

     }

     this.disableExperiment(TELEMETRY_LOG.TERMINATION.ADDON_UNINSTALLED);

   },

   onInstallStarted: function (install) {

     if (install.addon.type != "experiment") {

       return;

     }

     this._log.trace("onInstallStarted() - " + install.addon.id);

     if (install.addon.appDisabled) {

       // This is a PreviousExperiment

       return;

     }

     // We want to be in control of all experiment add-ons: reject installs

     // for add-ons that we don't know about.

     // We have a race condition of sorts to worry about here. We have 2

     // onInstallStarted listeners. This one (the global one) and the one

     // created as part of ExperimentEntry._installAddon. Because of the order

     // they are registered in, this one likely executes first. Unfortunately,

     // this means that the add-on ID is not yet set on the ExperimentEntry.

     // So, we can't just look at this._trackedAddonIds because the new experiment

     // will have its add-on ID set to null. We work around this by storing a

     // identifying field - the source URL of the install - in a module-level

     // variable (so multiple Experiments instances doesn't cancel each other

     // out).

     if (this._trackedAddonIds.has(install.addon.id)) {

       this._log.info("onInstallStarted allowing install because add-on ID " +

                      "tracked by us.");

       return;

     }

     if (gActiveInstallURLs.has(install.sourceURI.spec)) {

       this._log.info("onInstallStarted allowing install because install " +

                      "tracked by us.");

       return;

     }

     this._log.warn("onInstallStarted cancelling install of unknown " +

                    "experiment add-on: " + install.addon.id);

     return false;

   },

   // END OF ADD-ON LISTENERS.

   _getExperimentByAddonId: function (addonId) {

     for (let [, entry] of this._experiments) {

       if (entry._addonId === addonId) {

         return entry;

       }

     }

     return null;

   },

   /*

    * Helper function to make HTTP GET requests. Returns a promise that is resolved with

    * the responseText when the request is complete.

    */

   _httpGetRequest: function (url) {

     this._log.trace("httpGetRequest(" + url + ")");

     let xhr = Cc["@mozilla.org/xmlextras/xmlhttprequest;1"].createInstance(Ci.nsIXMLHttpRequest);

     try {

       xhr.open("GET", url);

     } catch (e) {

       this._log.error("httpGetRequest() - Error opening request to " + url + ": " + e);

       return Promise.reject(new Error("Experiments - Error opening XHR for " + url));

     }

     let deferred = Promise.defer();

     let log = this._log;

     xhr.onerror = function (e) {

       log.error("httpGetRequest::onError() - Error making request to " + url + ": " + e.error);

       deferred.reject(new Error("Experiments - XHR error for " + url + " - " + e.error));

     };

     xhr.onload = function (event) {

       if (xhr.status !== 200 && xhr.state !== 0) {

         log.error("httpGetRequest::onLoad() - Request to " + url + " returned status " + xhr.status);

         deferred.reject(new Error("Experiments - XHR status for " + url + " is " + xhr.status));

         return;

       }

       let certs = null;

       if (gPrefs.get(PREF_MANIFEST_CHECKCERT, true)) {

         certs = CertUtils.readCertPrefs(PREF_BRANCH + "manifest.certs.");

       }

       try {

         let allowNonBuiltin = !gPrefs.get(PREF_MANIFEST_REQUIREBUILTIN, true);

         CertUtils.checkCert(xhr.channel, allowNonBuiltin, certs);

       }

       catch (e) {

         log.error("manifest fetch failed certificate checks", [e]);

         deferred.reject(new Error("Experiments - manifest fetch failed certificate checks: " + e));

         return;

       }

       deferred.resolve(xhr.responseText);

     };

     if (xhr.channel instanceof Ci.nsISupportsPriority) {

       xhr.channel.priority = Ci.nsISupportsPriority.PRIORITY_LOWEST;

     }

     xhr.send(null);

     return deferred.promise;

   },

   /*

    * Path of the cache file we use in the profile.

    */

   get _cacheFilePath() {

     return OS.Path.join(OS.Constants.Path.profileDir, FILE_CACHE);

   },

   /*

    * Part of the main task to save the cache to disk, called from _main.

    */

   _saveToCache: function* () {

     this._log.trace("_saveToCache");

     let path = this._cacheFilePath;

     let textData = JSON.stringify({

       version: CACHE_VERSION,

       data: [e[1].toJSON() for (e of this._experiments.entries())],

     });

     let encoder = new TextEncoder();

     let data = encoder.encode(textData);

     let options = { tmpPath: path + ".tmp", compression: "lz4" };

     yield OS.File.writeAtomic(path, data, options);

     this._dirty = false;

     this._log.debug("_saveToCache saved to " + path);

   },

   /*

    * Task function, load the cached experiments manifest file from disk.

    */

   _loadFromCache: Task.async(function* () {

     this._log.trace("_loadFromCache");

     let path = this._cacheFilePath;

     try {

       let result = yield loadJSONAsync(path, { compression: "lz4" });

       this._populateFromCache(result);

     } catch (e if e instanceof OS.File.Error && e.becauseNoSuchFile) {

       // No cached manifest yet.

       this._experiments = new Map();

     }

   }),

   _populateFromCache: function (data) {

     this._log.trace("populateFromCache() - data: " + JSON.stringify(data));

     // If the user has a newer cache version than we can understand, we fail

     // hard; no experiments should be active in this older client.

     if (CACHE_VERSION !== data.version) {

       throw new Error("Experiments::_populateFromCache() - invalid cache version");

     }

     let experiments = new Map();

     for (let item of data.data) {

       let entry = new Experiments.ExperimentEntry(this._policy);

       if (!entry.initFromCacheData(item)) {

         continue;

       }

       experiments.set(entry.id, entry);

     }

     this._experiments = experiments;

   },

   /*

    * Update the experiment entries from the experiments

    * array in the manifest

    */

   _updateExperiments: function (manifestObject) {

     this._log.trace("_updateExperiments() - experiments: " + JSON.stringify(manifestObject));

     if (manifestObject.version !== MANIFEST_VERSION) {

       this._log.warning("updateExperiments() - unsupported version " + manifestObject.version);

     }

     let experiments = new Map(); // The new experiments map

     // Collect new and updated experiments.

     for (let data of manifestObject.experiments) {

       let entry = this._experiments.get(data.id);

       if (entry) {

         if (!entry.updateFromManifestData(data)) {

           this._log.error("updateExperiments() - Invalid manifest data for " + data.id);

           continue;

         }

       } else {

         entry = new Experiments.ExperimentEntry(this._policy);

         if (!entry.initFromManifestData(data)) {

           continue;

         }

       }

       if (entry.shouldDiscard()) {

         continue;

       }

       experiments.set(entry.id, entry);

     }

     // Make sure we keep experiments that are or were running.

     // We remove them after KEEP_HISTORY_N_DAYS.

     for (let [id, entry] of this._experiments) {

       if (experiments.has(id)) {

         continue;

       }

       if (!entry.startDate || entry.shouldDiscard()) {

         this._log.trace("updateExperiments() - discarding entry for " + id);

         continue;

       }

       experiments.set(id, entry);

     }

     this._experiments = experiments;

     this._dirty = true;

   },

   getActiveExperimentID: function() {

     if (!this._experiments) {

       return null;

     }

     let e = this._getActiveExperiment();

     if (!e) {

       return null;

     }

     return e.id;

   },

   getActiveExperimentBranch: function() {

     if (!this._experiments) {

       return null;

     }

     let e = this._getActiveExperiment();

     if (!e) {

       return null;

     }

     return e.branch;

   },

   _getActiveExperiment: function () {

     let enabled = [experiment for ([,experiment] of this._experiments) if (experiment._enabled)];

     if (enabled.length == 1) {

       return enabled[0];

     }

     if (enabled.length > 1) {

       this._log.error("getActiveExperimentId() - should not have more than 1 active experiment");

       throw new Error("have more than 1 active experiment");

     }

     return null;

   },

   /**

    * Disables all active experiments.

    *

    * @return Promise<> Promise that will get resolved once the task is done or failed.

    */

   disableExperiment: function (reason) {

     if (!reason) {

       throw new Error("Must specify a termination reason.");

     }

     this._log.trace("disableExperiment()");

     this._terminateReason = reason;

     return this._run();

   },

   /**

    * The Set of add-on IDs that we know about from manifests.

    */

   get _trackedAddonIds() {

     if (!this._experiments) {

       return new Set();

     }

     return new Set([e._addonId for ([,e] of this._experiments) if (e._addonId)]);

   },

   /*

    * Task function to check applicability of experiments, disable the active

    * experiment if needed and activate the first applicable candidate.

    */

   _evaluateExperiments: function*() {

     this._log.trace("_evaluateExperiments");

     this._checkForShutdown();

     // The first thing we do is reconcile our state against what's in the

     // Addon Manager. It's possible that the Addon Manager knows of experiment

     // add-ons that we don't. This could happen if an experiment gets installed

     // when we're not listening or if there is a bug in our synchronization

     // code.

     //

     // We have a few options of what to do with unknown experiment add-ons

     // coming from the Addon Manager. Ideally, we'd convert these to

     // ExperimentEntry instances and stuff them inside this._experiments.

     // However, since ExperimentEntry contain lots of metadata from the

     // manifest and trying to make up data could be error prone, it's safer

     // to not try. Furthermore, if an experiment really did come from us, we

     // should have some record of it. In the end, we decide to discard all

     // knowledge for these unknown experiment add-ons.

     let installedExperiments = yield installedExperimentAddons();

     let expectedAddonIds = this._trackedAddonIds;

     let unknownAddons = [a for (a of installedExperiments) if (!expectedAddonIds.has(a.id))];

     if (unknownAddons.length) {

       this._log.warn("_evaluateExperiments() - unknown add-ons in AddonManager: " +

                      [a.id for (a of unknownAddons)].join(", "));

       yield uninstallAddons(unknownAddons);

     }

     let activeExperiment = this._getActiveExperiment();

     let activeChanged = false;

     let now = this._policy.now();

     if (!activeExperiment) {

       // Avoid this pref staying out of sync if there were e.g. crashes.

       gPrefs.set(PREF_ACTIVE_EXPERIMENT, false);

     }

     // Ensure the active experiment is in the proper state. This may install,

     // uninstall, upgrade, or enable the experiment add-on. What exactly is

     // abstracted away from us by design.

     if (activeExperiment) {

       let changes;

       let shouldStopResult = yield activeExperiment.shouldStop();

       if (shouldStopResult.shouldStop) {

         let expireReasons = ["endTime", "maxActiveSeconds"];

         let kind, reason;

         if (expireReasons.indexOf(shouldStopResult.reason[0]) != -1) {

           kind = TELEMETRY_LOG.TERMINATION.EXPIRED;

           reason = null;

         } else {

           kind = TELEMETRY_LOG.TERMINATION.RECHECK;

           reason = shouldStopResult.reason;

         }

         changes = yield activeExperiment.stop(kind, reason);

       }

       else if (this._terminateReason) {

         changes = yield activeExperiment.stop(this._terminateReason);

       }

       else {

         changes = yield activeExperiment.reconcileAddonState();

       }

       if (changes) {

         this._dirty = true;

         activeChanged = true;

       }

       if (!activeExperiment._enabled) {

         activeExperiment = null;

         activeChanged = true;

       }

     }

     this._terminateReason = null;

     if (!activeExperiment && gExperimentsEnabled) {

       for (let [id, experiment] of this._experiments) {

         let applicable;

         let reason = null;

         try {

           applicable = yield experiment.isApplicable();

         }

         catch (e) {

           applicable = false;

           reason = e;

         }

         if (!applicable && reason && reason[0] != "was-active") {

           // Report this from here to avoid over-reporting.

           let desc = TELEMETRY_LOG.ACTIVATION;

           let data = [TELEMETRY_LOG.ACTIVATION.REJECTED, id];

           data = data.concat(reason);

           TelemetryLog.log(TELEMETRY_LOG.ACTIVATION_KEY, data);

         }

         if (!applicable) {

           continue;

         }

         this._log.debug("evaluateExperiments() - activating experiment " + id);

         try {

           yield experiment.start();

           activeChanged = true;

           activeExperiment = experiment;

           this._dirty = true;

           break;

         } catch (e) {

           // On failure, clean up the best we can and try the next experiment.

           this._log.error("evaluateExperiments() - Unable to start experiment: " + e.message);

           experiment._enabled = false;

           yield experiment.reconcileAddonState();

         }

       }

     }

     gPrefs.set(PREF_ACTIVE_EXPERIMENT, activeExperiment != null);

     if (activeChanged || this._firstEvaluate) {

       Services.obs.notifyObservers(null, EXPERIMENTS_CHANGED_TOPIC, null);

       this._firstEvaluate = false;

     }

     if ("@mozilla.org/toolkit/crash-reporter;1" in Cc && activeExperiment) {

       try {

         gCrashReporter.annotateCrashReport("ActiveExperiment", activeExperiment.id);

       } catch (e) {

         // It's ok if crash reporting is disabled.

       }

     }

   },

   /*

    * Schedule the soonest re-check of experiment applicability that is needed.

    */

   _scheduleNextRun: function () {

     this._checkForShutdown();

     if (this._timer) {

       this._timer.clear();

     }

     if (!gExperimentsEnabled || this._experiments.length == 0) {

       return;

     }

     let time = null;

     let now = this._policy.now().getTime();

     for (let [id, experiment] of this._experiments) {

       let scheduleTime = experiment.getScheduleTime();

       if (scheduleTime > now) {

         if (time !== null) {

           time = Math.min(time, scheduleTime);

         } else {

           time = scheduleTime;

         }

       }

     }

     if (time === null) {

       // No schedule time found.

       return;

     }

     this._log.trace("scheduleExperimentEvaluation() - scheduling for "+time+", now: "+now);

     this._policy.oneshotTimer(this.notify, time - now, this, "_timer");

   },

 };

 /*

  * Represents a single experiment.

  */

 Experiments.ExperimentEntry = function (policy) {

   this._policy = policy || new Experiments.Policy();

   this._log = Log.repository.getLoggerWithMessagePrefix(

     "Browser.Experiments.Experiments",

     "ExperimentEntry #" + gExperimentEntryCounter++ + "::");

   // Is the experiment supposed to be running.

   this._enabled = false;

   // When this experiment was started, if ever.

   this._startDate = null;

   // When this experiment was ended, if ever.

   this._endDate = null;

   // The condition data from the manifest.

   this._manifestData = null;

   // For an active experiment, signifies whether we need to update the xpi.

   this._needsUpdate = false;

   // A random sample value for comparison against the manifest conditions.

   this._randomValue = null;

   // When this entry was last changed for respecting history retention duration.

   this._lastChangedDate = null;

   // Has this experiment failed to activate before?

   this._failedStart = false;

   // The experiment branch

   this._branch = null;

   // We grab these from the addon after download.

   this._name = null;

   this._description = null;

   this._homepageURL = null;

   this._addonId = null;

 };

 Experiments.ExperimentEntry.prototype = {

   MANIFEST_REQUIRED_FIELDS: new Set([

     "id",

     "xpiURL",

     "xpiHash",

     "startTime",

     "endTime",

     "maxActiveSeconds",

     "appName",

     "channel",

   ]),

   MANIFEST_OPTIONAL_FIELDS: new Set([

     "maxStartTime",

     "minVersion",

     "maxVersion",

     "version",

     "minBuildID",

     "maxBuildID",

     "buildIDs",

     "os",

     "locale",

     "sample",

     "disabled",

     "frozen",

     "jsfilter",

   ]),

   SERIALIZE_KEYS: new Set([

     "_enabled",

     "_manifestData",

     "_needsUpdate",

     "_randomValue",

     "_failedStart",

     "_name",

     "_description",

     "_homepageURL",

     "_addonId",

     "_startDate",

     "_endDate",

     "_branch",

   ]),

   DATE_KEYS: new Set([

     "_startDate",

     "_endDate",

   ]),

   UPGRADE_KEYS: new Map([

     ["_branch", null],

   ]),

   ADDON_CHANGE_NONE: 0,

   ADDON_CHANGE_INSTALL: 1,

   ADDON_CHANGE_UNINSTALL: 2,

   ADDON_CHANGE_ENABLE: 4,

   /*

    * Initialize entry from the manifest.

    * @param data The experiment data from the manifest.

    * @return boolean Whether initialization succeeded.

    */

   initFromManifestData: function (data) {

     if (!this._isManifestDataValid(data)) {

       return false;

     }

     this._manifestData = data;

     this._randomValue = this._policy.random();

     this._lastChangedDate = this._policy.now();

     return true;

   },

   get enabled() {

     return this._enabled;

   },

   get id() {

     return this._manifestData.id;

   },

   get branch() {

     return this._branch;

   },

   set branch(v) {

     this._branch = v;

   },

   get startDate() {

     return this._startDate;

   },

   get endDate() {

     if (!this._startDate) {

       return null;

     }

     let endTime = 0;

     if (!this._enabled) {

       return this._endDate;

     }

     let maxActiveMs = 1000 * this._manifestData.maxActiveSeconds;

     endTime = Math.min(1000 * this._manifestData.endTime,

                        this._startDate.getTime() + maxActiveMs);

     return new Date(endTime);

   },

   get needsUpdate() {

     return this._needsUpdate;

   },

   /*

    * Initialize entry from the cache.

    * @param data The entry data from the cache.

    * @return boolean Whether initialization succeeded.

    */

   initFromCacheData: function (data) {

     for (let [key, dval] of this.UPGRADE_KEYS) {

       if (!(key in data)) {

         data[key] = dval;

       }

     }

     for (let key of this.SERIALIZE_KEYS) {

       if (!(key in data) && !this.DATE_KEYS.has(key)) {

         this._log.error("initFromCacheData() - missing required key " + key);

         return false;

       }

     };

     if (!this._isManifestDataValid(data._manifestData)) {

       return false;

     }

     // Dates are restored separately from epoch ms, everything else is just

     // copied in.

     this.SERIALIZE_KEYS.forEach(key => {

       if (!this.DATE_KEYS.has(key)) {

         this[key] = data[key];

       }

     });

     this.DATE_KEYS.forEach(key => {

       if (key in data) {

         let date = new Date();

         date.setTime(data[key]);

         this[key] = date;

       }

     });

     this._lastChangedDate = this._policy.now();

     return true;

   },

   /*

    * Returns a JSON representation of this object.

    */

   toJSON: function () {

     let obj = {};

     // Dates are serialized separately as epoch ms.

     this.SERIALIZE_KEYS.forEach(key => {

       if (!this.DATE_KEYS.has(key)) {

         obj[key] = this[key];

       }

     });

     this.DATE_KEYS.forEach(key => {

       if (this[key]) {

         obj[key] = this[key].getTime();

       }

     });

     return obj;

   },

   /*

    * Update from the experiment data from the manifest.

    * @param data The experiment data from the manifest.

    * @return boolean Whether updating succeeded.

    */

   updateFromManifestData: function (data) {

     let old = this._manifestData;

     if (!this._isManifestDataValid(data)) {

       return false;

     }

     if (this._enabled) {

       if (old.xpiHash !== data.xpiHash) {

         // A changed hash means we need to update active experiments.

         this._needsUpdate = true;

       }

     } else if (this._failedStart &&

                (old.xpiHash !== data.xpiHash) ||

                (old.xpiURL !== data.xpiURL)) {

       // Retry installation of previously invalid experiments

       // if hash or url changed.

       this._failedStart = false;

     }

     this._manifestData = data;

     this._lastChangedDate = this._policy.now();

     return true;

   },

   /*

    * Is this experiment applicable?

    * @return Promise<> Resolved if the experiment is applicable.

    *                   If it is not applicable it is rejected with

    *                   a Promise<string> which contains the reason.

    */

   isApplicable: function () {

     let versionCmp = Cc["@mozilla.org/xpcom/version-comparator;1"]

                               .getService(Ci.nsIVersionComparator);

     let app = Cc["@mozilla.org/xre/app-info;1"].getService(Ci.nsIXULAppInfo);

     let runtime = Cc["@mozilla.org/xre/app-info;1"]

                     .getService(Ci.nsIXULRuntime);

     let locale = this._policy.locale();

     let channel = this._policy.updatechannel();

     let data = this._manifestData;

     let now = this._policy.now() / 1000; // The manifest times are in seconds.

     let minActive = MIN_EXPERIMENT_ACTIVE_SECONDS;

     let maxActive = data.maxActiveSeconds || 0;

     let startSec = (this.startDate || 0) / 1000;

     this._log.trace("isApplicable() - now=" + now

                     + ", randomValue=" + this._randomValue

                     + ", data=" + JSON.stringify(this._manifestData));

     // Not applicable if it already ran.

     if (!this.enabled && this._endDate) {

       return Promise.reject(["was-active"]);

     }

     // Define and run the condition checks.

     let simpleChecks = [

       { name: "failedStart",

         condition: () => !this._failedStart },

       { name: "disabled",

         condition: () => !data.disabled },

       { name: "frozen",

         condition: () => !data.frozen || this._enabled },

       { name: "startTime",

         condition: () => now >= data.startTime },

       { name: "endTime",

         condition: () => now < data.endTime },

       { name: "maxStartTime",

         condition: () => !data.maxStartTime || now <= data.maxStartTime },

       { name: "maxActiveSeconds",

         condition: () => !this._startDate || now <= (startSec + maxActive) },

       { name: "appName",

         condition: () => !data.appName || data.appName.indexOf(app.name) != -1 },

       { name: "minBuildID",

         condition: () => !data.minBuildID || app.platformBuildID >= data.minBuildID },

       { name: "maxBuildID",

         condition: () => !data.maxBuildID || app.platformBuildID <= data.maxBuildID },

       { name: "buildIDs",

         condition: () => !data.buildIDs || data.buildIDs.indexOf(app.platformBuildID) != -1 },

       { name: "os",

         condition: () => !data.os || data.os.indexOf(runtime.OS) != -1 },

       { name: "channel",

         condition: () => !data.channel || data.channel.indexOf(channel) != -1 },

       { name: "locale",

         condition: () => !data.locale || data.locale.indexOf(locale) != -1 },

       { name: "sample",

         condition: () => data.sample === undefined || this._randomValue <= data.sample },

       { name: "version",

         condition: () => !data.version || data.version.indexOf(app.version) != -1 },

       { name: "minVersion",

         condition: () => !data.minVersion || versionCmp.compare(app.version, data.minVersion) >= 0 },

       { name: "maxVersion",

         condition: () => !data.maxVersion || versionCmp.compare(app.version, data.maxVersion) <= 0 },

     ];

     for (let check of simpleChecks) {

       let result = check.condition();

       if (!result) {

         this._log.debug("isApplicable() - id="

                         + data.id + " - test '" + check.name + "' failed");

         return Promise.reject([check.name]);

       }

     }

     if (data.jsfilter) {

       return this._runFilterFunction(data.jsfilter);

     }

     return Promise.resolve(true);

   },

   /*

    * Run the jsfilter function from the manifest in a sandbox and return the

    * result (forced to boolean).

    */

   _runFilterFunction: function (jsfilter) {

     this._log.trace("runFilterFunction() - filter: " + jsfilter);

     return Task.spawn(function ExperimentEntry_runFilterFunction_task() {

       const nullprincipal = Cc["@mozilla.org/nullprincipal;1"].createInstance(Ci.nsIPrincipal);

       let options = {

         sandboxName: "telemetry experiments jsfilter sandbox",

         wantComponents: false,

       };

       let sandbox = Cu.Sandbox(nullprincipal);

       let context = {};

       context.healthReportPayload = yield this._policy.healthReportPayload();

       context.telemetryPayload    = yield this._policy.telemetryPayload();

       try {

         Cu.evalInSandbox(jsfilter, sandbox);

       } catch (e) {

         this._log.error("runFilterFunction() - failed to eval jsfilter: " + e.message);

         throw ["jsfilter-evalfailed"];

       }

       // You can't insert arbitrarily complex objects into a sandbox, so

       // we serialize everything through JSON.

       sandbox._hr = JSON.stringify(yield this._policy.healthReportPayload());

       Object.defineProperty(sandbox, "_t",

         { get: () => JSON.stringify(this._policy.telemetryPayload()) });

       let result = false;

       try {

         result = !!Cu.evalInSandbox("filter({healthReportPayload: JSON.parse(_hr), telemetryPayload: JSON.parse(_t)})", sandbox);

       }

       catch (e) {

         this._log.debug("runFilterFunction() - filter function failed: "

                       + e.message + ", " + e.stack);

         throw ["jsfilter-threw", e.message];

       }

       finally {

         Cu.nukeSandbox(sandbox);

       }

       if (!result) {

         throw ["jsfilter-false"];

       }

       throw new Task.Result(true);

     }.bind(this));

   },

   /*

    * Start running the experiment.

    *

    * @return Promise<> Resolved when the operation is complete.

    */

   start: Task.async(function* () {

     this._log.trace("start() for " + this.id);

     this._enabled = true;

     return yield this.reconcileAddonState();

   }),

   // Async install of the addon for this experiment, part of the start task above.

   _installAddon: Task.async(function* () {

     let deferred = Promise.defer();

     let hash = this._policy.ignoreHashes ? null : this._manifestData.xpiHash;

     let install = yield addonInstallForURL(this._manifestData.xpiURL, hash);

     gActiveInstallURLs.add(install.sourceURI.spec);

     let failureHandler = (install, handler) => {

       let message = "AddonInstall " + handler + " for " + this.id + ", state=" +

                    (install.state || "?") + ", error=" + install.error;

       this._log.error("_installAddon() - " + message);

       this._failedStart = true;

       gActiveInstallURLs.delete(install.sourceURI.spec);

       TelemetryLog.log(TELEMETRY_LOG.ACTIVATION_KEY,

                       [TELEMETRY_LOG.ACTIVATION.INSTALL_FAILURE, this.id]);

       deferred.reject(new Error(message));

     };

     let listener = {

       _expectedID: null,

       onDownloadEnded: install => {

         this._log.trace("_installAddon() - onDownloadEnded for " + this.id);

         if (install.existingAddon) {

           this._log.warn("_installAddon() - onDownloadEnded, addon already installed");

         }

         if (install.addon.type !== "experiment") {

           this._log.error("_installAddon() - onDownloadEnded, wrong addon type");

           install.cancel();

         }

       },

       onInstallStarted: install => {

         this._log.trace("_installAddon() - onInstallStarted for " + this.id);

         if (install.existingAddon) {

           this._log.warn("_installAddon() - onInstallStarted, addon already installed");

         }

         if (install.addon.type !== "experiment") {

           this._log.error("_installAddon() - onInstallStarted, wrong addon type");

           return false;

         }

       },

       onInstallEnded: install => {

         this._log.trace("_installAddon() - install ended for " + this.id);

         gActiveInstallURLs.delete(install.sourceURI.spec);

         this._lastChangedDate = this._policy.now();

         this._startDate = this._policy.now();

         this._enabled = true;

         TelemetryLog.log(TELEMETRY_LOG.ACTIVATION_KEY,

                        [TELEMETRY_LOG.ACTIVATION.ACTIVATED, this.id]);

         let addon = install.addon;

         this._name = addon.name;

         this._addonId = addon.id;

         this._description = addon.description || "";

         this._homepageURL = addon.homepageURL || "";

         // Experiment add-ons default to userDisabled=true. Enable if needed.

         if (addon.userDisabled) {

           this._log.trace("Add-on is disabled. Enabling.");

           listener._expectedID = addon.id;

           AddonManager.addAddonListener(listener);

           addon.userDisabled = false;

         } else {

           this._log.trace("Add-on is enabled. start() completed.");

           deferred.resolve();

         }

       },

       onEnabled: addon => {

         this._log.info("onEnabled() for " + addon.id);

         if (addon.id != listener._expectedID) {

           return;

         }

         AddonManager.removeAddonListener(listener);

         deferred.resolve();

       },

     };

     ["onDownloadCancelled", "onDownloadFailed", "onInstallCancelled", "onInstallFailed"]

       .forEach(what => {

         listener[what] = install => failureHandler(install, what)

       });

     install.addListener(listener);

     install.install();

     return yield deferred.promise;

   }),

   /**

    * Stop running the experiment if it is active.

    *

    * @param terminationKind (optional)

    *        The termination kind, e.g. ADDON_UNINSTALLED or EXPIRED.

    * @param terminationReason (optional)

    *        The termination reason details for termination kind RECHECK.

    * @return Promise<> Resolved when the operation is complete.

    */

   stop: Task.async(function* (terminationKind, terminationReason) {

     this._log.trace("stop() - id=" + this.id + ", terminationKind=" + terminationKind);

     if (!this._enabled) {

       throw new Error("Must not call stop() on an inactive experiment.");

     }

     this._enabled = false;

     let now = this._policy.now();

     this._lastChangedDate = now;

     this._endDate = now;

     let changes = yield this.reconcileAddonState();

     this._logTermination(terminationKind, terminationReason);

     if (terminationKind == TELEMETRY_LOG.TERMINATION.ADDON_UNINSTALLED) {

       changes |= this.ADDON_CHANGE_UNINSTALL;

     }

     return changes;

   }),

   /**

    * Reconcile the state of the add-on against what it's supposed to be.

    *

    * If we are active, ensure the add-on is enabled and up to date.

    *

    * If we are inactive, ensure the add-on is not installed.

    */

   reconcileAddonState: Task.async(function* () {

     this._log.trace("reconcileAddonState()");

     if (!this._enabled) {

       if (!this._addonId) {

         this._log.trace("reconcileAddonState() - Experiment is not enabled and " +

                         "has no add-on. Doing nothing.");

         return this.ADDON_CHANGE_NONE;

       }

       let addon = yield this._getAddon();

       if (!addon) {

         this._log.trace("reconcileAddonState() - Inactive experiment has no " +

                         "add-on. Doing nothing.");

         return this.ADDON_CHANGE_NONE;

       }

       this._log.info("reconcileAddonState() - Uninstalling add-on for inactive " +

                      "experiment: " + addon.id);

       gActiveUninstallAddonIDs.add(addon.id);

       yield uninstallAddons([addon]);

       gActiveUninstallAddonIDs.delete(addon.id);

       return this.ADDON_CHANGE_UNINSTALL;

     }

     // If we get here, we're supposed to be active.

     let changes = 0;

     // That requires an add-on.

     let currentAddon = yield this._getAddon();

     // If we have an add-on but it isn't up to date, uninstall it

     // (to prepare for reinstall).

     if (currentAddon && this._needsUpdate) {

       this._log.info("reconcileAddonState() - Uninstalling add-on because update " +

                      "needed: " + currentAddon.id);

       gActiveUninstallAddonIDs.add(currentAddon.id);

       yield uninstallAddons([currentAddon]);

       gActiveUninstallAddonIDs.delete(currentAddon.id);

       changes |= this.ADDON_CHANGE_UNINSTALL;

     }

     if (!currentAddon || this._needsUpdate) {

       this._log.info("reconcileAddonState() - Installing add-on.");

       yield this._installAddon();

       changes |= this.ADDON_CHANGE_INSTALL;

     }

     let addon = yield this._getAddon();

     if (!addon) {

       throw new Error("Could not obtain add-on for experiment that should be " +

                       "enabled.");

     }

     // If we have the add-on and it is enabled, we are done.

     if (!addon.userDisabled) {

       return changes;

     }

     let deferred = Promise.defer();

     // Else we need to enable it.

     let listener = {

       onEnabled: enabledAddon => {

         if (enabledAddon.id != addon.id) {

           return;

         }

         AddonManager.removeAddonListener(listener);

         deferred.resolve();

       },

     };

     this._log.info("Activating add-on: " + addon.id);

     AddonManager.addAddonListener(listener);

     addon.userDisabled = false;

     yield deferred.promise;

     changes |= this.ADDON_CHANGE_ENABLE;

     this._log.info("Add-on has been enabled: " + addon.id);

     return changes;

    }),

   /**

    * Obtain the underlying Addon from the Addon Manager.

    *

    * @return Promise<Addon|null>

    */

   _getAddon: function () {

     if (!this._addonId) {

       return Promise.resolve(null);

     }

     let deferred = Promise.defer();

     AddonManager.getAddonByID(this._addonId, (addon) => {

       if (addon && addon.appDisabled) {

         // Don't return PreviousExperiments.

         addon = null;

       }

       deferred.resolve(addon);

     });

     return deferred.promise;

   },

   _logTermination: function (terminationKind, terminationReason) {

     if (terminationKind === undefined) {

       return;

     }

     if (!(terminationKind in TELEMETRY_LOG.TERMINATION)) {

       this._log.warn("stop() - unknown terminationKind " + terminationKind);

       return;

     }

     let data = [terminationKind, this.id];

     if (terminationReason) {

       data = data.concat(terminationReason);

     }

     TelemetryLog.log(TELEMETRY_LOG.TERMINATION_KEY, data);

   },

   /**

    * Determine whether an active experiment should be stopped.

    */

   shouldStop: function () {

     if (!this._enabled) {

       throw new Error("shouldStop must not be called on disabled experiments.");

     }

     let data = this._manifestData;

     let now = this._policy.now() / 1000; // The manifest times are in seconds.

     let maxActiveSec = data.maxActiveSeconds || 0;

     let deferred = Promise.defer();

     this.isApplicable().then(

       () => deferred.resolve({shouldStop: false}),

       reason => deferred.resolve({shouldStop: true, reason: reason})

     );

     return deferred.promise;

   },

   /*

    * Should this be discarded from the cache due to age?

    */

   shouldDiscard: function () {

     let limit = this._policy.now();

     limit.setDate(limit.getDate() - KEEP_HISTORY_N_DAYS);

     return (this._lastChangedDate < limit);

   },

   /*

    * Get next date (in epoch-ms) to schedule a re-evaluation for this.

    * Returns 0 if it doesn't need one.

    */

   getScheduleTime: function () {

     if (this._enabled) {

       let now = this._policy.now();

       let startTime = this._startDate.getTime();

       let maxActiveTime = startTime + 1000 * this._manifestData.maxActiveSeconds;

       return Math.min(1000 * this._manifestData.endTime,  maxActiveTime);

     }

     if (this._endDate) {

       return this._endDate.getTime();

     }

     return 1000 * this._manifestData.startTime;

   },

   /*

    * Perform sanity checks on the experiment data.

    */

   _isManifestDataValid: function (data) {

     this._log.trace("isManifestDataValid() - data: " + JSON.stringify(data));

     for (let key of this.MANIFEST_REQUIRED_FIELDS) {

       if (!(key in data)) {

         this._log.error("isManifestDataValid() - missing required key: " + key);

         return false;

       }

     }

     for (let key in data) {

       if (!this.MANIFEST_OPTIONAL_FIELDS.has(key) &&

           !this.MANIFEST_REQUIRED_FIELDS.has(key)) {

         this._log.error("isManifestDataValid() - unknown key: " + key);

         return false;

       }

     }

     return true;

   },

 };

 /**

  * Strip a Date down to its UTC midnight.

  *

  * This will return a cloned Date object. The original is unchanged.

  */

 let stripDateToMidnight = function (d) {

   let m = new Date(d);

   m.setUTCHours(0, 0, 0, 0);

   return m;

 };

 function ExperimentsLastActiveMeasurement1() {

   Metrics.Measurement.call(this);

 }

 function ExperimentsLastActiveMeasurement2() {

   Metrics.Measurement.call(this);

 }

 const FIELD_DAILY_LAST_TEXT = {type: Metrics.Storage.FIELD_DAILY_LAST_TEXT};

 ExperimentsLastActiveMeasurement1.prototype = Object.freeze({

   __proto__: Metrics.Measurement.prototype,

   name: "info",

   version: 1,

   fields: {

     lastActive: FIELD_DAILY_LAST_TEXT,

   }

 });

 ExperimentsLastActiveMeasurement2.prototype = Object.freeze({

   __proto__: Metrics.Measurement.prototype,

   name: "info",

   version: 2,

   fields: {

     lastActive: FIELD_DAILY_LAST_TEXT,

     lastActiveBranch: FIELD_DAILY_LAST_TEXT,

   }

 });

 this.ExperimentsProvider = function () {

   Metrics.Provider.call(this);

   this._experiments = null;

 };

 ExperimentsProvider.prototype = Object.freeze({

   __proto__: Metrics.Provider.prototype,

   name: "org.mozilla.experiments",

   measurementTypes: [

     ExperimentsLastActiveMeasurement1,

     ExperimentsLastActiveMeasurement2,

   ],

   _OBSERVERS: [

     EXPERIMENTS_CHANGED_TOPIC,

   ],

   postInit: function () {

     for (let o of this._OBSERVERS) {

       Services.obs.addObserver(this, o, false);

     }

     return Promise.resolve();

   },

   onShutdown: function () {

     for (let o of this._OBSERVERS) {

       Services.obs.removeObserver(this, o);

     }

     return Promise.resolve();

   },

   observe: function (subject, topic, data) {

     switch (topic) {

       case EXPERIMENTS_CHANGED_TOPIC:

         this.recordLastActiveExperiment();

         break;

     }

   },

   collectDailyData: function () {

     return this.recordLastActiveExperiment();

   },

   recordLastActiveExperiment: function () {

     if (!gExperimentsEnabled) {

       return Promise.resolve();

     }

     if (!this._experiments) {

       this._experiments = Experiments.instance();

     }

     let m = this.getMeasurement(ExperimentsLastActiveMeasurement2.prototype.name,

                                 ExperimentsLastActiveMeasurement2.prototype.version);

     return this.enqueueStorageOperation(() => {

       return Task.spawn(function* recordTask() {

         let todayActive = yield this._experiments.lastActiveToday();

         if (!todayActive) {

           this._log.info("No active experiment on this day: " +

                          this._experiments._policy.now());

           return;

         }

         this._log.info("Recording last active experiment: " + todayActive.id);

         yield m.setDailyLastText("lastActive", todayActive.id,

                                  this._experiments._policy.now());

         let branch = todayActive.branch;

         if (branch) {

           yield m.setDailyLastText("lastActiveBranch", branch,

                                    this._experiments._policy.now());

         }

       }.bind(this));

     });

   },

 });

 /**

  * An Add-ons Manager provider that knows about old experiments.

  *

  * This provider exposes read-only add-ons corresponding to previously-active

  * experiments. The existence of this provider (and the add-ons it knows about)

  * facilitates the display of old experiments in the Add-ons Manager UI with

  * very little custom code in that component.

  */

 this.Experiments.PreviousExperimentProvider = function (experiments) {

   this._experiments = experiments;

   this._experimentList = [];

   this._log = Log.repository.getLoggerWithMessagePrefix(

     "Browser.Experiments.Experiments",

     "PreviousExperimentProvider #" + gPreviousProviderCounter++ + "::");

 }

 this.Experiments.PreviousExperimentProvider.prototype = Object.freeze({

   startup: function () {

     this._log.trace("startup()");

     Services.obs.addObserver(this, EXPERIMENTS_CHANGED_TOPIC, false);

   },

   shutdown: function () {

     this._log.trace("shutdown()");

     Services.obs.removeObserver(this, EXPERIMENTS_CHANGED_TOPIC);

   },

   observe: function (subject, topic, data) {

     switch (topic) {

       case EXPERIMENTS_CHANGED_TOPIC:

         this._updateExperimentList();

         break;

     }

   },

   getAddonByID: function (id, cb) {

     for (let experiment of this._experimentList) {

       if (experiment.id == id) {

         cb(new PreviousExperimentAddon(experiment));

         return;

       }

     }

     cb(null);

   },

   getAddonsByTypes: function (types, cb) {

     if (types && types.length > 0 && types.indexOf("experiment") == -1) {

       cb([]);

       return;

     }

     cb([new PreviousExperimentAddon(e) for (e of this._experimentList)]);

   },

   _updateExperimentList: function () {

     return this._experiments.getExperiments().then((experiments) => {

       let list = [e for (e of experiments) if (!e.active)];

       let newMap = new Map([[e.id, e] for (e of list)]);

       let oldMap = new Map([[e.id, e] for (e of this._experimentList)]);

       let added = [e.id for (e of list) if (!oldMap.has(e.id))];

       let removed = [e.id for (e of this._experimentList) if (!newMap.has(e.id))];

       for (let id of added) {

         this._log.trace("updateExperimentList() - adding " + id);

         let wrapper = new PreviousExperimentAddon(newMap.get(id));

         AddonManagerPrivate.callInstallListeners("onExternalInstall", null, wrapper, null, false);

         AddonManagerPrivate.callAddonListeners("onInstalling", wrapper, false);

       }

       for (let id of removed) {

         this._log.trace("updateExperimentList() - removing " + id);

         let wrapper = new PreviousExperimentAddon(oldMap.get(id));

         AddonManagerPrivate.callAddonListeners("onUninstalling", plugin, false);

       }

       this._experimentList = list;

       for (let id of added) {

         let wrapper = new PreviousExperimentAddon(newMap.get(id));

         AddonManagerPrivate.callAddonListeners("onInstalled", wrapper);

       }

       for (let id of removed) {

         let wrapper = new PreviousExperimentAddon(oldMap.get(id));

         AddonManagerPrivate.callAddonListeners("onUninstalled", wrapper);

       }

       return this._experimentList;

     });

   },

 });

 /**

  * An add-on that represents a previously-installed experiment.

  */

 function PreviousExperimentAddon(experiment) {

   this._id = experiment.id;

   this._name = experiment.name;

   this._endDate = experiment.endDate;

   this._description = experiment.description;

 }

 PreviousExperimentAddon.prototype = Object.freeze({

   // BEGIN REQUIRED ADDON PROPERTIES

   get appDisabled() {

     return true;

   },

   get blocklistState() {

     Ci.nsIBlocklistService.STATE_NOT_BLOCKED

   },

   get creator() {

     return new AddonManagerPrivate.AddonAuthor("");

   },

   get foreignInstall() {

     return false;

   },

   get id() {

     return this._id;

   },

   get isActive() {

     return false;

   },

   get isCompatible() {

     return true;

   },

   get isPlatformCompatible() {

     return true;

   },

   get name() {

     return this._name;

   },

   get pendingOperations() {

     return AddonManager.PENDING_NONE;

   },

   get permissions() {

     return 0;

   },

   get providesUpdatesSecurely() {

     return true;

   },

   get scope() {

     return AddonManager.SCOPE_PROFILE;

   },

   get type() {

     return "experiment";

   },

   get userDisabled() {

     return true;

   },

   get version() {

     return null;

   },

   // END REQUIRED PROPERTIES

   // BEGIN OPTIONAL PROPERTIES

   get description() {

     return this._description;

   },

   get updateDate() {

     return new Date(this._endDate);

   },

   // END OPTIONAL PROPERTIES

   // BEGIN REQUIRED METHODS

   isCompatibleWith: function (appVersion, platformVersion) {

     return true;

   },

   findUpdates: function (listener, reason, appVersion, platformVersion) {

     AddonManagerPrivate.callNoUpdateListeners(this, listener, reason,

                                               appVersion, platformVersion);

   },

   // END REQUIRED METHODS

   /**

    * The end-date of the experiment, required for the Addon Manager UI.

    */

    get endDate() {

      return this._endDate;

    },

 });