--- a/browser/base/content/test/static/browser_all_files_referenced.js
+++ b/browser/base/content/test/static/browser_all_files_referenced.js
@@ -113,18 +113,19 @@ var whitelist = [
   {file: "resource://gre/chrome/en-US/locale/en-US/global-platform/win/intl.properties",
    platforms: ["linux", "macosx"]},
   {file: "resource://gre/chrome/en-US/locale/en-US/global-platform/win/platformKeys.properties",
    platforms: ["linux", "macosx"]},
 
   // browser/extensions/pdfjs/content/web/viewer.js#7450
   {file: "resource://pdf.js/web/debugger.js"},
 
-  // Needed by Normandy
-  {file: "resource://gre/modules/IndexedDB.jsm"},
+  // These are used in content processes. They are actually referenced.
+  {file: "resource://shield-recipe-client-content/shield-content-frame.js"},
+  {file: "resource://shield-recipe-client-content/shield-content-process.js"},
 
   // New L10n API that is not yet used in production
   {file: "resource://gre/modules/Localization.jsm"},
 
   // Starting from here, files in the whitelist are bugs that need fixing.
   // Bug 1339420
   {file: "chrome://branding/content/icon128.png"},
   // Bug 1339424 (wontfix?)

--- a/browser/extensions/shield-recipe-client/bootstrap.js
+++ b/browser/extensions/shield-recipe-client/bootstrap.js
@@ -1,50 +1,97 @@
 /* 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 {utils: Cu} = Components;
+Cu.import("resource://gre/modules/AppConstants.jsm");
+Cu.import("resource://gre/modules/Log.jsm");
+Cu.import("resource://gre/modules/Services.jsm");
 Cu.import("resource://gre/modules/XPCOMUtils.jsm");
 
 XPCOMUtils.defineLazyModuleGetter(this, "LogManager",
   "resource://shield-recipe-client/lib/LogManager.jsm");
 XPCOMUtils.defineLazyModuleGetter(this, "ShieldRecipeClient",
   "resource://shield-recipe-client/lib/ShieldRecipeClient.jsm");
 
+const DEFAULT_PREFS = {
+  "extensions.shield-recipe-client.api_url": "https://normandy.cdn.mozilla.net/api/v1",
+  "extensions.shield-recipe-client.dev_mode": false,
+  "extensions.shield-recipe-client.enabled": true,
+  "extensions.shield-recipe-client.startup_delay_seconds": 300,
+  "extensions.shield-recipe-client.logging.level": Log.Level.Warn,
+  "extensions.shield-recipe-client.user_id": "",
+  "extensions.shield-recipe-client.run_interval_seconds": 86400, // 24 hours
+  "extensions.shield-recipe-client.first_run": true,
+  "extensions.shield-recipe-client.shieldLearnMoreUrl": (
+    "https://support.mozilla.org/1/firefox/%VERSION%/%OS%/%LOCALE%/shield"
+  ),
+  "app.shield.optoutstudies.enabled": AppConstants.MOZ_DATA_REPORTING,
+};
+
 this.install = function() {};
 
-this.startup = async function() {
-  await ShieldRecipeClient.startup();
+this.startup = function() {
+  // Initialize preference defaults before anything else happens.
+  const prefBranch = Services.prefs.getDefaultBranch("");
+  for (const [name, value] of Object.entries(DEFAULT_PREFS)) {
+    switch (typeof value) {
+      case "string":
+        prefBranch.setCharPref(name, value);
+        break;
+      case "number":
+        prefBranch.setIntPref(name, value);
+        break;
+      case "boolean":
+        prefBranch.setBoolPref(name, value);
+        break;
+      default:
+        throw new Error(`Invalid default preference type ${typeof value}`);
+    }
+  }
+
+  ShieldRecipeClient.startup();
 };
 
 this.shutdown = function(data, reason) {
   ShieldRecipeClient.shutdown(reason);
 
   // Unload add-on modules. We don't do this in ShieldRecipeClient so that
   // modules are not unloaded accidentally during tests.
   const log = LogManager.getLogger("bootstrap");
-  const modules = [
+  let modules = [
     "lib/ActionSandboxManager.jsm",
+    "lib/Addons.jsm",
+    "lib/AddonStudies.jsm",
     "lib/CleanupManager.jsm",
     "lib/ClientEnvironment.jsm",
     "lib/FilterExpressions.jsm",
     "lib/EventEmitter.jsm",
     "lib/Heartbeat.jsm",
     "lib/LogManager.jsm",
     "lib/NormandyApi.jsm",
     "lib/NormandyDriver.jsm",
     "lib/PreferenceExperiments.jsm",
     "lib/RecipeRunner.jsm",
     "lib/Sampling.jsm",
     "lib/SandboxManager.jsm",
+    "lib/ShieldPreferences.jsm",
     "lib/ShieldRecipeClient.jsm",
     "lib/Storage.jsm",
+    "lib/Uptake.jsm",
     "lib/Utils.jsm",
-  ];
+  ].map(m => `resource://shield-recipe-client/${m}`);
+  modules = modules.concat([
+    "AboutPages.jsm",
+  ].map(m => `resource://shield-recipe-client-content/${m}`));
+  modules = modules.concat([
+    "mozjexl.js",
+  ].map(m => `resource://shield-recipe-client-vendor/${m}`));
+
   for (const module of modules) {
     log.debug(`Unloading ${module}`);
-    Cu.unload(`resource://shield-recipe-client/${module}`);
+    Cu.unload(module);
   }
 };
 
 this.uninstall = function() {};

new file mode 100644
--- /dev/null
+++ b/browser/extensions/shield-recipe-client/content/AboutPages.jsm
@@ -0,0 +1,213 @@
+/* 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 { interfaces: Ci, results: Cr, manager: Cm, utils: Cu } = Components;
+Cu.import("resource://gre/modules/Services.jsm");
+Cu.import("resource://gre/modules/XPCOMUtils.jsm");
+
+XPCOMUtils.defineLazyModuleGetter(
+  this, "CleanupManager", "resource://shield-recipe-client/lib/CleanupManager.jsm",
+);
+XPCOMUtils.defineLazyModuleGetter(
+  this, "AddonStudies", "resource://shield-recipe-client/lib/AddonStudies.jsm",
+);
+
+this.EXPORTED_SYMBOLS = ["AboutPages"];
+
+const SHIELD_LEARN_MORE_URL_PREF = "extensions.shield-recipe-client.shieldLearnMoreUrl";
+
+// Due to bug 1051238 frame scripts are cached forever, so we can't update them
+// as a restartless add-on. The Math.random() is the work around for this.
+const PROCESS_SCRIPT = (
+  `resource://shield-recipe-client-content/shield-content-process.js?${Math.random()}`
+);
+const FRAME_SCRIPT = (
+  `resource://shield-recipe-client-content/shield-content-frame.js?${Math.random()}`
+);
+
+/**
+ * Class for managing an about: page that Shield provides. Adapted from
+ * browser/extensions/pocket/content/AboutPocket.jsm.
+ *
+ * @implements nsIFactory
+ * @implements nsIAboutModule
+ */
+class AboutPage {
+  constructor({chromeUrl, aboutHost, classId, description, uriFlags}) {
+    this.chromeUrl = chromeUrl;
+    this.aboutHost = aboutHost;
+    this.classId = Components.ID(classId);
+    this.description = description;
+    this.uriFlags = uriFlags;
+  }
+
+  getURIFlags() {
+    return this.uriFlags;
+  }
+
+  newChannel(uri, loadInfo) {
+    const newURI = Services.io.newURI(this.chromeUrl);
+    const channel = Services.io.newChannelFromURIWithLoadInfo(newURI, loadInfo);
+    channel.originalURI = uri;
+
+    if (this.uriFlags & Ci.nsIAboutModule.URI_SAFE_FOR_UNTRUSTED_CONTENT) {
+      const principal = Services.scriptSecurityManager.createCodebasePrincipal(uri, {});
+      channel.owner = principal;
+    }
+    return channel;
+  }
+
+  createInstance(outer, iid) {
+    if (outer !== null) {
+      throw Cr.NS_ERROR_NO_AGGREGATION;
+    }
+    return this.QueryInterface(iid);
+  }
+
+  /**
+   * Register this about: page with XPCOM. This must be called once in each
+   * process (parent and content) to correctly initialize the page.
+   */
+  register() {
+    Cm.QueryInterface(Ci.nsIComponentRegistrar).registerFactory(
+      this.classId,
+      this.description,
+      `@mozilla.org/network/protocol/about;1?what=${this.aboutHost}`,
+      this,
+    );
+  }
+
+  /**
+   * Unregister this about: page with XPCOM. This must be called before the
+   * add-on is cleaned up if the page has been registered.
+   */
+  unregister() {
+    Cm.QueryInterface(Ci.nsIComponentRegistrar).unregisterFactory(this.classId, this);
+  }
+}
+AboutPage.prototype.QueryInterface = XPCOMUtils.generateQI([Ci.nsIAboutModule]);
+
+/**
+ * The module exported by this file.
+ */
+this.AboutPages = {
+  async init() {
+    // Load scripts in content processes and tabs
+    Services.ppmm.loadProcessScript(PROCESS_SCRIPT, true);
+    Services.mm.loadFrameScript(FRAME_SCRIPT, true);
+
+    // Register about: pages and their listeners
+    this.aboutStudies.register();
+    this.aboutStudies.registerParentListeners();
+
+    CleanupManager.addCleanupHandler(() => {
+      // Stop loading processs scripts and notify existing scripts to clean up.
+      Services.ppmm.removeDelayedProcessScript(PROCESS_SCRIPT);
+      Services.ppmm.broadcastAsyncMessage("Shield:ShuttingDown");
+      Services.mm.removeDelayedFrameScript(FRAME_SCRIPT);
+      Services.mm.broadcastAsyncMessage("Shield:ShuttingDown");
+
+      // Clean up about pages
+      this.aboutStudies.unregisterParentListeners();
+      this.aboutStudies.unregister();
+    });
+  },
+};
+
+/**
+ * about:studies page for displaying in-progress and past Shield studies.
+ * @type {AboutPage}
+ * @implements {nsIMessageListener}
+ */
+XPCOMUtils.defineLazyGetter(this.AboutPages, "aboutStudies", () => {
+  const aboutStudies = new AboutPage({
+    chromeUrl: "resource://shield-recipe-client-content/about-studies/about-studies.html",
+    aboutHost: "studies",
+    classId: "{6ab96943-a163-482c-9622-4faedc0e827f}",
+    description: "Shield Study Listing",
+    uriFlags: (
+      Ci.nsIAboutModule.ALLOW_SCRIPT
+      | Ci.nsIAboutModule.URI_SAFE_FOR_UNTRUSTED_CONTENT
+      | Ci.nsIAboutModule.URI_MUST_LOAD_IN_CHILD
+    ),
+  });
+
+  // Extra methods for about:study-specific behavior.
+  Object.assign(aboutStudies, {
+    /**
+     * Register listeners for messages from the content processes.
+     */
+    registerParentListeners() {
+      Services.mm.addMessageListener("Shield:GetStudyList", this);
+      Services.mm.addMessageListener("Shield:RemoveStudy", this);
+      Services.mm.addMessageListener("Shield:OpenOldDataPreferences", this);
+    },
+
+    /**
+     * Unregister listeners for messages from the content process.
+     */
+    unregisterParentListeners() {
+      Services.mm.removeMessageListener("Shield:GetStudyList", this);
+      Services.mm.removeMessageListener("Shield:RemoveStudy", this);
+      Services.mm.removeMessageListener("Shield:OpenOldDataPreferences", this);
+    },
+
+    /**
+     * Dispatch messages from the content process to the appropriate handler.
+     * @param {Object} message
+     *   See the nsIMessageListener documentation for details about this object.
+     */
+    receiveMessage(message) {
+      switch (message.name) {
+        case "Shield:GetStudyList":
+          this.sendStudyList(message.target);
+          break;
+        case "Shield:RemoveStudy":
+          this.removeStudy(message.data);
+          break;
+        case "Shield:OpenOldDataPreferences":
+          this.openOldDataPreferences();
+          break;
+      }
+    },
+
+    /**
+     * Fetch a list of studies from storage and send it to the process that
+     * requested them.
+     * @param {<browser>} target
+     *   XUL <browser> element for the tab containing the about:studies page
+     *   that requested a study list.
+     */
+    async sendStudyList(target) {
+      target.messageManager.sendAsyncMessage("Shield:ReceiveStudyList", {
+        studies: await AddonStudies.getAll(),
+      });
+    },
+
+    /**
+     * Disable an active study and remove its add-on.
+     * @param {String} studyName
+     */
+    async removeStudy(recipeId) {
+      await AddonStudies.stop(recipeId);
+
+      // Update any open tabs with the new study list now that it has changed.
+      Services.mm.broadcastAsyncMessage("Shield:ReceiveStudyList", {
+        studies: await AddonStudies.getAll(),
+      });
+    },
+
+    openOldDataPreferences() {
+      const browserWindow = Services.wm.getMostRecentWindow("navigator:browser");
+      browserWindow.openAdvancedPreferences("dataChoicesTab", {origin: "aboutStudies"});
+    },
+
+    getShieldLearnMoreHref() {
+      return Services.urlFormatter.formatURLPref(SHIELD_LEARN_MORE_URL_PREF);
+    },
+  });
+
+  return aboutStudies;
+});

new file mode 100644
--- /dev/null
+++ b/browser/extensions/shield-recipe-client/content/about-studies/about-studies.css
@@ -0,0 +1,182 @@
+/* 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/. */
+
+:root {
+  --icon-background-color-1: #0A84FF;
+  --icon-background-color-2: #008EA4;
+  --icon-background-color-3: #ED00B5;
+  --icon-background-color-4: #058B00;
+  --icon-background-color-5: #A47F00;
+  --icon-background-color-6: #FF0039;
+  --icon-background-disabled-color: #737373;
+  --body-text-disabled-color: #737373;
+  --info-box-background-color: #D7D7DB;
+  --info-box-border-color: #98979C;
+  --study-status-active-color: #058B00;
+  --study-status-disabled-color: #737373;
+}
+
+html,
+body,
+#app {
+  height: 100%;
+  width: 100%;
+}
+
+button > .button-box {
+  padding-left: 10px;
+  padding-right: 10px;
+}
+
+.about-studies-container {
+  display: flex;
+  flex-direction: row;
+  font-size: 1.25rem;
+  min-height: 100%;
+  width: 100%;
+}
+
+#categories {
+  flex: 0 0;
+  margin: 0;
+  min-width: 200px;
+  padding: 40px 0 0;
+}
+
+#categories .category {
+  align-items: center;
+  display: flex;
+  flex-direction: row;
+}
+
+.main-content {
+  flex: 1;
+}
+
+.info-box {
+  margin-bottom: 10px;
+  text-align: center;
+}
+
+.info-box-content {
+  align-items: center;
+  background: var(--info-box-background-color);
+  border: 1px solid var(--info-box-border-color);
+  display: inline-flex;
+  padding: 10px 15px;
+}
+
+.info-box-content > * {
+  margin-right: 10px;
+}
+
+.info-box-content > *:last-child {
+  margin-right: 0;
+}
+
+.study-list {
+  list-style-type: none;
+  margin: 0;
+  padding: 0;
+}
+
+.study {
+  align-items: center;
+  border-bottom: 1px solid var(--in-content-border-color);
+  display: flex;
+  flex-direction: row;
+  padding: 10px;
+}
+
+.study.disabled {
+  color: var(--body-text-disabled-color);
+}
+
+.study .study-status {
+  color: var(--study-status-active-color);
+  font-weight: bold;
+}
+
+.study.disabled .study-status {
+  color: var(--study-status-disabled-color);
+}
+
+.study:last-child {
+  border-bottom: none;
+}
+
+.study > * {
+  margin-right: 15px;
+}
+
+.study > *:last-child {
+  margin-right: 0;
+}
+
+.study-icon {
+  color: #FFF;
+  flex: 0 0 40px;
+  font-size: 26px;
+  height: 40px;
+  line-height: 40px;
+  text-align: center;
+  text-transform: capitalize;
+}
+
+.study:nth-child(6n+0) .study-icon {
+  background: var(--icon-background-color-1);
+}
+
+.study:nth-child(6n+1) .study-icon {
+  background: var(--icon-background-color-2);
+}
+
+.study:nth-child(6n+2) .study-icon {
+  background: var(--icon-background-color-3);
+}
+
+.study:nth-child(6n+3) .study-icon {
+  background: var(--icon-background-color-4);
+}
+
+.study:nth-child(6n+4) .study-icon {
+  background: var(--icon-background-color-5);
+}
+
+.study:nth-child(6n+5) .study-icon {
+  background: var(--icon-background-color-6);
+}
+
+.study.disabled .study-icon {
+  background: var(--icon-background-disabled-color);
+}
+
+.study-details {
+  flex: 1;
+  overflow: hidden;
+}
+
+.study-name {
+  font-weight: bold;
+  margin-bottom: 0.3em;
+}
+
+.study-description {
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  width: 100%;
+}
+
+.study-description > * {
+  margin-right: 5px;
+}
+
+.study-description > *:last-child {
+  margin-right: 0;
+}
+
+.study-actions {
+  flex: 0 0;
+}

new file mode 100644
--- /dev/null
+++ b/browser/extensions/shield-recipe-client/content/about-studies/about-studies.html
@@ -0,0 +1,23 @@
+<!-- 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/. -->
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <title>about:studies</title>
+    <link rel="stylesheet" href="chrome://global/skin/global.css">
+    <link rel="stylesheet" href="chrome://global/skin/in-content/common.css">
+    <link rel="stylesheet" href="resource://shield-recipe-client-content/about-studies/about-studies.css">
+  </head>
+  <body>
+    <div id="app"></div>
+    <script src="resource://shield-recipe-client-vendor/React.js"></script>
+    <script src="resource://shield-recipe-client-vendor/ReactDOM.js"></script>
+    <script src="resource://shield-recipe-client-vendor/PropTypes.js"></script>
+    <script src="resource://shield-recipe-client-vendor/classnames.js"></script>
+    <script src="resource://shield-recipe-client-content/about-studies/common.js"></script>
+    <script src="resource://shield-recipe-client-content/about-studies/shield-studies.js"></script>
+    <script src="resource://shield-recipe-client-content/about-studies/about-studies.js"></script>
+  </body>
+</html>

new file mode 100644
--- /dev/null
+++ b/browser/extensions/shield-recipe-client/content/about-studies/about-studies.js
@@ -0,0 +1,140 @@
+/* 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";
+/* global classnames PropTypes r React ReactDOM ShieldStudies */
+
+/**
+ * Mapping of pages displayed on the sidebar. Keys are the value used in the
+ * URL hash to identify the current page.
+ *
+ * Pages will appear in the sidebar in the order they are defined here. If the
+ * URL doesn't contain a hash, the first page will be displayed in the content area.
+ */
+const PAGES = new Map([
+  ["shieldStudies", {
+    name: "Shield Studies",
+    component: ShieldStudies,
+    icon: "resource://shield-recipe-client-content/about-studies/img/shield-logo.png",
+  }],
+]);
+
+/**
+ * Handle basic layout and routing within about:studies.
+ */
+class AboutStudies extends React.Component {
+  constructor(props) {
+    super(props);
+
+    let hash = new URL(window.location).hash.slice(1);
+    if (!PAGES.has(hash)) {
+      hash = "shieldStudies";
+    }
+
+    this.state = {
+      currentPageId: hash,
+    };
+
+    this.handleEvent = this.handleEvent.bind(this);
+  }
+
+  componentDidMount() {
+    window.addEventListener("hashchange", this);
+  }
+
+  componentWillUnmount() {
+    window.removeEventListener("hashchange", this);
+  }
+
+  handleEvent(event) {
+    const newHash = new URL(event.newURL).hash.slice(1);
+    if (PAGES.has(newHash)) {
+      this.setState({currentPageId: newHash});
+    }
+  }
+
+  render() {
+    const currentPageId = this.state.currentPageId;
+    const pageEntries = Array.from(PAGES.entries());
+    const currentPage = PAGES.get(currentPageId);
+
+    return (
+      r("div", {className: "about-studies-container"},
+        r(Sidebar, {},
+          pageEntries.map(([id, page]) => (
+            r(SidebarItem, {
+              key: id,
+              pageId: id,
+              selected: id === currentPageId,
+              page,
+            })
+          )),
+        ),
+        r(Content, {},
+          currentPage && r(currentPage.component)
+        ),
+      )
+    );
+  }
+}
+
+class Sidebar extends React.Component {
+  render() {
+    return r("ul", {id: "categories"}, this.props.children);
+  }
+}
+Sidebar.propTypes = {
+  children: PropTypes.node,
+};
+
+class SidebarItem extends React.Component {
+  constructor(props) {
+    super(props);
+    this.handleClick = this.handleClick.bind(this);
+  }
+
+  handleClick() {
+    window.location = `#${this.props.pageId}`;
+  }
+
+  render() {
+    const { page, selected } = this.props;
+    return (
+      r("li", {
+        className: classnames("category", {selected}),
+        onClick: this.handleClick,
+      },
+        page.icon && r("img", {className: "category-icon", src: page.icon}),
+        r("span", {className: "category-name"}, page.name),
+      )
+    );
+  }
+}
+SidebarItem.propTypes = {
+  pageId: PropTypes.string.isRequired,
+  page: PropTypes.shape({
+    icon: PropTypes.string,
+    name: PropTypes.string.isRequired,
+  }).isRequired,
+  selected: PropTypes.bool,
+};
+
+class Content extends React.Component {
+  render() {
+    return (
+      r("div", {className: "main-content"},
+        r("div", {className: "content-box"},
+          this.props.children,
+        ),
+      )
+    );
+  }
+}
+Content.propTypes = {
+  children: PropTypes.node,
+};
+
+ReactDOM.render(
+  r(AboutStudies),
+  document.getElementById("app"),
+);

new file mode 100644
--- /dev/null
+++ b/browser/extensions/shield-recipe-client/content/about-studies/common.js
@@ -0,0 +1,137 @@
+/* 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";
+/* eslint-disable no-unused-vars */
+/* global PropTypes React */
+
+/**
+ * Shorthand for creating elements (to avoid using a JSX preprocessor)
+ */
+const r = React.createElement;
+
+/**
+ * Information box used at the top of listings.
+ */
+window.InfoBox = class InfoBox extends React.Component {
+  render() {
+    return (
+      r("div", {className: "info-box"},
+        r("div", {className: "info-box-content"},
+          this.props.children,
+        ),
+      )
+    );
+  }
+};
+window.InfoBox.propTypes = {
+  children: PropTypes.node,
+};
+
+/**
+ * Button using in-product styling.
+ */
+window.FxButton = class FxButton extends React.Component {
+  render() {
+    return (
+      r("button", Object.assign({}, this.props, {children: undefined}),
+        r("div", {className: "button-box"},
+          this.props.children,
+        ),
+      )
+    );
+  }
+};
+window.FxButton.propTypes = {
+  children: PropTypes.node,
+};
+
+/**
+ * Wrapper class for a value that is provided by the frame script.
+ *
+ * Emits a "GetRemoteValue:{name}" page event on load to fetch the initial
+ * value, and listens for "ReceiveRemoveValue:{name}" page callbacks to receive
+ * the value when it updates.
+ *
+ * @example
+ * const myRemoteValue = new RemoteValue("MyValue", 5);
+ * class MyComponent extends React.Component {
+ *   constructor(props) {
+ *     super(props);
+ *     this.state = {
+ *       myValue: null,
+ *     };
+ *   }
+ *
+ *   componentWillMount() {
+ *     myRemoteValue.subscribe(this);
+ *   }
+ *
+ *   componentWillUnmount() {
+ *     myRemoteValue.unsubscribe(this);
+ *   }
+ *
+ *   receiveRemoteValue(name, value) {
+ *     this.setState({myValue: value});
+ *   }
+ *
+ *   render() {
+ *     return r("div", {}, this.state.myValue);
+ *   }
+ * }
+ */
+class RemoteValue {
+  constructor(name, defaultValue = null) {
+    this.name = name;
+    this.handlers = [];
+    this.value = defaultValue;
+
+    document.addEventListener(`ReceiveRemoteValue:${this.name}`, this);
+    sendPageEvent(`GetRemoteValue:${this.name}`);
+  }
+
+  /**
+   * Subscribe to this value as it updates. Handlers are called with the current
+   * value immediately after subscribing.
+   * @param {Object} handler
+   *   Object with a receiveRemoteValue(name, value) method that is called with
+   *   the name and value of this RemoteValue when it is updated.
+   */
+  subscribe(handler) {
+    this.handlers.push(handler);
+    handler.receiveRemoteValue(this.name, this.value);
+  }
+
+  /**
+   * Remove a previously-registered handler.
+   * @param {Object} handler
+   */
+  unsubscribe(handler) {
+    this.handlers = this.handlers.filter(h => h !== handler);
+  }
+
+  handleEvent(event) {
+    this.value = event.detail;
+    for (const handler of this.handlers) {
+      handler.receiveRemoteValue(this.name, this.value);
+    }
+  }
+}
+
+/**
+ * Collection of RemoteValue instances used within the page.
+ */
+const remoteValues = {
+  StudyList: new RemoteValue("StudyList", []),
+  ShieldLearnMoreHref: new RemoteValue("ShieldLearnMoreHref", ""),
+};
+
+/**
+ * Dispatches a page event to the privileged frame script for this tab.
+ * @param {String} action
+ * @param {Object} data
+ */
+function sendPageEvent(action, data) {
+  const event = new CustomEvent("ShieldPageEvent", {bubbles: true, detail: {action, data}});
+  document.dispatchEvent(event);
+}

new file mode 100644
index 0000000000000000000000000000000000000000..e8539268cedca719b8f694b5ba7845cd27c1974c
GIT binary patch
literal 5426
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

new file mode 100644
--- /dev/null
+++ b/browser/extensions/shield-recipe-client/content/about-studies/shield-studies.js
@@ -0,0 +1,148 @@
+/* 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";
+/* global classnames FxButton InfoBox PropTypes r React remoteValues sendPageEvent */
+
+window.ShieldStudies = class ShieldStudies extends React.Component {
+  constructor(props) {
+    super(props);
+    this.state = {
+      learnMoreHref: null,
+    };
+  }
+
+  componentDidMount() {
+    remoteValues.ShieldLearnMoreHref.subscribe(this);
+  }
+
+  componentWillUnmount() {
+    remoteValues.ShieldLearnMoreHref.unsubscribe(this);
+  }
+
+  receiveRemoteValue(name, value) {
+    this.setState({
+      learnMoreHref: value,
+    });
+  }
+
+  render() {
+    return (
+      r("div", {},
+        r(InfoBox, {},
+          r("span", {}, "What's this? Firefox may install and run studies from time to time."),
+          r("a", {id: "shield-studies-learn-more", href: this.state.learnMoreHref}, "Learn more"),
+          r(UpdatePreferencesButton, {}, "Update Preferences"),
+        ),
+        r(StudyList),
+      )
+    );
+  }
+};
+
+class UpdatePreferencesButton extends React.Component {
+  constructor(props) {
+    super(props);
+    this.handleClick = this.handleClick.bind(this);
+  }
+
+  handleClick() {
+    sendPageEvent("NavigateToDataPreferences");
+  }
+
+  render() {
+    return r(
+      FxButton,
+      Object.assign({
+        id: "shield-studies-update-preferences",
+        onClick: this.handleClick,
+      }, this.props),
+    );
+  }
+}
+
+class StudyList extends React.Component {
+  constructor(props) {
+    super(props);
+    this.state = {
+      studies: [],
+    };
+  }
+
+  componentDidMount() {
+    remoteValues.StudyList.subscribe(this);
+  }
+
+  componentWillUnmount() {
+    remoteValues.StudyList.unsubscribe(this);
+  }
+
+  receiveRemoteValue(name, value) {
+    const studies = value.slice();
+
+    // Sort by active status, then by start date descending.
+    studies.sort((a, b) => {
+      if (a.active !== b.active) {
+        return a.active ? -1 : 1;
+      }
+      return b.studyStartDate - a.studyStartDate;
+    });
+
+    this.setState({studies});
+  }
+
+  render() {
+    return (
+      r("ul", {className: "study-list"},
+        this.state.studies.map(study => (
+          r(StudyListItem, {key: study.name, study})
+        ))
+      )
+    );
+  }
+}
+
+class StudyListItem extends React.Component {
+  constructor(props) {
+    super(props);
+    this.handleClickRemove = this.handleClickRemove.bind(this);
+  }
+
+  handleClickRemove() {
+    sendPageEvent("RemoveStudy", this.props.study.recipeId);
+  }
+
+  render() {
+    const study = this.props.study;
+    return (
+      r("li", {
+        className: classnames("study", {disabled: !study.active}),
+        "data-study-name": study.name,
+      },
+        r("div", {className: "study-icon"},
+          study.name.slice(0, 1)
+        ),
+        r("div", {className: "study-details"},
+          r("div", {className: "study-name"}, study.name),
+          r("div", {className: "study-description", title: study.description},
+            r("span", {className: "study-status"}, study.active ? "Active" : "Complete"),
+            r("span", {}, "\u2022"), // •
+            r("span", {}, study.description),
+          ),
+        ),
+        r("div", {className: "study-actions"},
+          study.active &&
+            r(FxButton, {className: "remove-button", onClick: this.handleClickRemove}, "Remove"),
+        ),
+      )
+    );
+  }
+}
+StudyListItem.propTypes = {
+  study: PropTypes.shape({
+    recipeId: PropTypes.number.isRequired,
+    name: PropTypes.string.isRequired,
+    active: PropTypes.boolean,
+    description: PropTypes.string.isRequired,
+  }).isRequired,
+};

new file mode 100644
--- /dev/null
+++ b/browser/extensions/shield-recipe-client/content/shield-content-frame.js
@@ -0,0 +1,125 @@
+/* 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";
+
+/**
+ * Listen for DOM events bubbling up from the about:studies page, and perform
+ * privileged actions in response to them. If we need to do anything that the
+ * content process can't handle (such as reading IndexedDB), we send a message
+ * to the parent process and handle it there.
+ *
+ * This file is loaded as a frame script. It will be loaded once per tab that
+ * is opened.
+ */
+
+/* global content addMessageListener removeMessageListener sendAsyncMessage */
+
+const { utils: Cu } = Components;
+Cu.import("resource://gre/modules/Services.jsm");
+Cu.import("resource://gre/modules/XPCOMUtils.jsm");
+
+const frameGlobal = {};
+XPCOMUtils.defineLazyModuleGetter(
+  frameGlobal, "AboutPages", "resource://shield-recipe-client-content/AboutPages.jsm",
+);
+
+const USE_OLD_PREF_ORGANIZATION_PREF = "browser.preferences.useOldOrganization";
+
+/**
+ * Handles incoming events from the parent process and about:studies.
+ * @implements nsIMessageListener
+ * @implements EventListener
+ */
+class ShieldFrameListener {
+  handleEvent(event) {
+    // Abort if the current page isn't about:studies.
+    if (!this.ensureTrustedOrigin()) {
+      return;
+    }
+
+    // We waited until after we received an event to register message listeners
+    // in order to save resources for tabs that don't ever load about:studies.
+    addMessageListener("Shield:ShuttingDown", this);
+    addMessageListener("Shield:ReceiveStudyList", this);
+
+    switch (event.detail.action) {
+      // Actions that require the parent process
+      case "GetRemoteValue:StudyList":
+        sendAsyncMessage("Shield:GetStudyList");
+        break;
+      case "RemoveStudy":
+        sendAsyncMessage("Shield:RemoveStudy", event.detail.data);
+        break;
+      // Actions that can be performed in the content process
+      case "GetRemoteValue:ShieldLearnMoreHref":
+        this.triggerPageCallback(
+          "ReceiveRemoteValue:ShieldLearnMoreHref",
+          frameGlobal.AboutPages.aboutStudies.getShieldLearnMoreHref()
+        );
+        break;
+      case "NavigateToDataPreferences":
+        this.navigateToDataPreferences();
+        break;
+    }
+  }
+
+  /**
+   * Check that the current webpage's origin is about:studies.
+   * @return {Boolean}
+   */
+  ensureTrustedOrigin() {
+    return content.document.documentURI.startsWith("about:studies");
+  }
+
+  /**
+   * Handle messages from the parent process.
+   * @param {Object} message
+   *   See the nsIMessageListener docs.
+   */
+  receiveMessage(message) {
+    switch (message.name) {
+      case "Shield:ReceiveStudyList":
+        this.triggerPageCallback("ReceiveRemoteValue:StudyList", message.data.studies);
+        break;
+      case "Shield:ShuttingDown":
+        this.onShutdown();
+        break;
+    }
+  }
+
+  /**
+   * Trigger an event to communicate with the unprivileged about: page.
+   * @param {String} type
+   * @param {Object} detail
+   */
+  triggerPageCallback(type, detail) {
+    // Do not communicate with untrusted pages.
+    if (!this.ensureTrustedOrigin()) {
+      return;
+    }
+
+    // Clone details and use the event class from the unprivileged context.
+    const event = new content.document.defaultView.CustomEvent(type, {
+      bubbles: true,
+      detail: Cu.cloneInto(detail, content.document.defaultView),
+    });
+    content.document.dispatchEvent(event);
+  }
+
+  onShutdown() {
+    removeMessageListener("Shield:SendStudyList", this);
+    removeMessageListener("Shield:ShuttingDown", this);
+    removeEventListener("Shield", this);
+  }
+
+  navigateToDataPreferences() {
+    if (Services.prefs.getBoolPref(USE_OLD_PREF_ORGANIZATION_PREF)) {
+      sendAsyncMessage("Shield:OpenOldDataPreferences");
+    } else {
+      content.location = "about:preferences#privacy-reports";
+    }
+  }
+}
+
+addEventListener("ShieldPageEvent", new ShieldFrameListener(), false, true);

new file mode 100644
--- /dev/null
+++ b/browser/extensions/shield-recipe-client/content/shield-content-process.js
@@ -0,0 +1,48 @@
+/* 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";
+
+/**
+ * Registers about: pages provided by Shield, and listens for a shutdown event
+ * from the add-on before un-registering them.
+ *
+ * This file is loaded as a process script. It is executed once for each
+ * process, including the parent one.
+ */
+
+const { utils: Cu } = Components;
+Cu.import("resource://gre/modules/XPCOMUtils.jsm");
+Cu.import("resource://gre/modules/Services.jsm");
+Cu.import("resource://shield-recipe-client-content/AboutPages.jsm");
+
+class ShieldChildListener {
+  onStartup() {
+    Services.cpmm.addMessageListener("Shield:ShuttingDown", this, true);
+    AboutPages.aboutStudies.register();
+  }
+
+  onShutdown() {
+    AboutPages.aboutStudies.unregister();
+    Services.cpmm.removeMessageListener("Shield:ShuttingDown", this);
+
+    // Unload AboutPages.jsm in case the add-on is reinstalled and we need to
+    // load a new version of it.
+    Cu.unload("resource://shield-recipe-client-content/AboutPages.jsm");
+  }
+
+  receiveMessage(message) {
+    switch (message.name) {
+      case "Shield:ShuttingDown":
+        this.onShutdown();
+        break;
+    }
+  }
+}
+
+// Only register in content processes; the parent process handles registration
+// separately.
+if (Services.appinfo.processType === Services.appinfo.PROCESS_TYPE_CONTENT) {
+  const listener = new ShieldChildListener();
+  listener.onStartup();
+}

--- a/browser/extensions/shield-recipe-client/install.rdf.in
+++ b/browser/extensions/shield-recipe-client/install.rdf.in
@@ -3,17 +3,17 @@
 #filter substitution
 
 <RDF xmlns="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:em="http://www.mozilla.org/2004/em-rdf#">
   <Description about="urn:mozilla:install-manifest">
     <em:id>shield-recipe-client@mozilla.org</em:id>
     <em:type>2</em:type>
     <em:bootstrap>true</em:bootstrap>
     <em:unpack>false</em:unpack>
-    <em:version>55.1</em:version>
+    <em:version>65</em:version>
     <em:name>Shield Recipe Client</em:name>
     <em:description>Client to download and run recipes for SHIELD, Heartbeat, etc.</em:description>
     <em:multiprocessCompatible>true</em:multiprocessCompatible>
 
     <em:targetApplication>
       <Description>
         <em:id>{ec8030f7-c20a-464f-9b0e-13a3a9e97384}</em:id>
         <em:minVersion>@MOZ_APP_VERSION@</em:minVersion>

--- a/browser/extensions/shield-recipe-client/jar.mn
+++ b/browser/extensions/shield-recipe-client/jar.mn
@@ -1,9 +1,13 @@
 # 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/.
 
 [features/shield-recipe-client@mozilla.org] chrome.jar:
-% resource shield-recipe-client %content/
-  content/lib/ (./lib/*)
-  content/node_modules/jexl/ (./node_modules/jexl/*)
-  content/skin/  (skin/*)
+% resource shield-recipe-client %
+  lib/ (./lib/*)
+  data/ (./data/*)
+  skin/  (skin/*)
+% resource shield-recipe-client-content %content/
+  content/ (./content/*)
+% resource shield-recipe-client-vendor %vendor/
+  vendor/ (./vendor/*)

--- a/browser/extensions/shield-recipe-client/lib/ActionSandboxManager.jsm
+++ b/browser/extensions/shield-recipe-client/lib/ActionSandboxManager.jsm
@@ -67,18 +67,14 @@ this.ActionSandboxManager = class extend
   async runAsyncCallback(callbackName, ...args) {
     const callbackWasRegistered = this.evalInSandbox(`asyncCallbacks.has("${callbackName}")`);
     if (!callbackWasRegistered) {
       log.debug(`Script did not register a callback with the name "${callbackName}"`);
       return undefined;
     }
 
     this.cloneIntoGlobal("callbackArgs", args);
-    try {
-      const result = await this.evalInSandbox(`
-        asyncCallbacks.get("${callbackName}")(sandboxedDriver, ...callbackArgs);
-      `);
-      return Cu.cloneInto(result, {});
-    } catch (err) {
-      throw new Error(Cu.cloneInto(err.message, {}));
-    }
+    const result = await this.evalInSandbox(`
+      asyncCallbacks.get("${callbackName}")(sandboxedDriver, ...callbackArgs);
+    `);
+    return Cu.cloneInto(result, {});
   }
 };

new file mode 100644
--- /dev/null
+++ b/browser/extensions/shield-recipe-client/lib/AddonStudies.jsm
@@ -0,0 +1,324 @@
+/* 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";
+
+/**
+ * @typedef {Object} Study
+ * @property {Number} recipeId
+ *   ID of the recipe that created the study. Used as the primary key of the
+ *   study.
+ * @property {string} name
+ *   Name of the study
+ * @property {string} description
+ *   Description of the study and its intent.
+ * @property {boolean} active
+ *   Is the study still running?
+ * @property {string} addonId
+ *   Add-on ID for this particular study.
+ * @property {string} addonUrl
+ *   URL that the study add-on was installed from.
+ * @property {string} addonVersion
+ *   Study add-on version number
+ * @property {string} studyStartDate
+ *   Date when the study was started.
+ * @property {Date} studyEndDate
+ *   Date when the study was ended.
+ */
+
+const {utils: Cu, interfaces: Ci} = Components;
+Cu.import("resource://gre/modules/osfile.jsm");
+Cu.import("resource://gre/modules/Services.jsm");
+Cu.import("resource://gre/modules/XPCOMUtils.jsm");
+
+XPCOMUtils.defineLazyModuleGetter(this, "FileUtils", "resource://gre/modules/FileUtils.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "IndexedDB", "resource://gre/modules/IndexedDB.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "AddonManager", "resource://gre/modules/AddonManager.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "Addons", "resource://shield-recipe-client/lib/Addons.jsm");
+XPCOMUtils.defineLazyModuleGetter(
+  this, "CleanupManager", "resource://shield-recipe-client/lib/CleanupManager.jsm"
+);
+XPCOMUtils.defineLazyModuleGetter(this, "LogManager", "resource://shield-recipe-client/lib/LogManager.jsm");
+
+Cu.importGlobalProperties(["fetch"]); /* globals fetch */
+
+this.EXPORTED_SYMBOLS = ["AddonStudies"];
+
+const DB_NAME = "shield";
+const STORE_NAME = "addon-studies";
+const DB_OPTIONS = {
+  version: 1,
+  storage: "persistent",
+};
+const STUDY_ENDED_TOPIC = "shield-study-ended";
+const log = LogManager.getLogger("addon-studies");
+
+/**
+ * Create a new connection to the database.
+ */
+function openDatabase() {
+  return IndexedDB.open(DB_NAME, DB_OPTIONS, db => {
+    db.createObjectStore(STORE_NAME, {
+      keyPath: "recipeId",
+    });
+  });
+}
+
+/**
+ * Cache the database connection so that it is shared among multiple operations.
+ */
+let databasePromise;
+async function getDatabase() {
+  if (!databasePromise) {
+    databasePromise = openDatabase();
+  }
+  return databasePromise;
+}
+
+/**
+ * Get a transaction for interacting with the study store.
+ *
+ * NOTE: Methods on the store returned by this function MUST be called
+ * synchronously, otherwise the transaction with the store will expire.
+ * This is why the helper takes a database as an argument; if we fetched the
+ * database in the helper directly, the helper would be async and the
+ * transaction would expire before methods on the store were called.
+ */
+function getStore(db) {
+  return db.objectStore(STORE_NAME, "readwrite");
+}
+
+/**
+ * Mark a study object as having ended. Modifies the study in-place.
+ * @param {IDBDatabase} db
+ * @param {Study} study
+ */
+async function markAsEnded(db, study) {
+  study.active = false;
+  study.studyEndDate = new Date();
+  await getStore(db).put(study);
+  Services.obs.notifyObservers(study, STUDY_ENDED_TOPIC);
+}
+
+this.AddonStudies = {
+  /**
+   * Test wrapper that temporarily replaces the stored studies with the given
+   * ones. The original stored studies are restored upon completion.
+   *
+   * This is defined here instead of in test code since it needs to access the
+   * getDatabase, which we don't expose to avoid outside modules relying on the
+   * type of storage used for studies.
+   *
+   * @param {Array} [studies=[]]
+   */
+  withStudies(studies = []) {
+    return function wrapper(testFunction) {
+      return async function wrappedTestFunction(...args) {
+        const oldStudies = await AddonStudies.getAll();
+        let db = await getDatabase();
+        await AddonStudies.clear();
+        for (const study of studies) {
+          await getStore(db).add(study);
+        }
+
+        try {
+          await testFunction(...args, studies);
+        } finally {
+          db = await getDatabase(); // Re-acquire in case the test closed the connection.
+          await AddonStudies.clear();
+          for (const study of oldStudies) {
+            await getStore(db).add(study);
+          }
+
+          await AddonStudies.close();
+        }
+      };
+    };
+  },
+
+  async init() {
+    // If an active study's add-on has been removed since we last ran, stop the
+    // study.
+    const activeStudies = (await this.getAll()).filter(study => study.active);
+    const db = await getDatabase();
+    for (const study of activeStudies) {
+      const addon = await AddonManager.getAddonByID(study.addonId);
+      if (!addon) {
+        await markAsEnded(db, study);
+      }
+    }
+    await this.close();
+
+    // Listen for add-on uninstalls so we can stop the corresponding studies.
+    AddonManager.addAddonListener(this);
+    CleanupManager.addCleanupHandler(() => {
+      AddonManager.removeAddonListener(this);
+    });
+  },
+
+  /**
+   * If a study add-on is uninstalled, mark the study as having ended.
+   * @param {Addon} addon
+   */
+  async onUninstalled(addon) {
+    const activeStudies = (await this.getAll()).filter(study => study.active);
+    const matchingStudy = activeStudies.find(study => study.addonId === addon.id);
+    if (matchingStudy) {
+      // Use a dedicated DB connection instead of the shared one so that we can
+      // close it without fear of affecting other users of the shared connection.
+      const db = await openDatabase();
+      await markAsEnded(db, matchingStudy);
+      await db.close();
+    }
+  },
+
+  /**
+   * Remove all stored studies.
+   */
+  async clear() {
+    const db = await getDatabase();
+    await getStore(db).clear();
+  },
+
+  /**
+   * Close the current database connection if it is open.
+   */
+  async close() {
+    if (databasePromise) {
+      const promise = databasePromise;
+      databasePromise = null;
+      const db = await promise;
+      await db.close();
+    }
+  },
+
+  /**
+   * Test whether there is a study in storage for the given recipe ID.
+   * @param {Number} recipeId
+   * @returns {Boolean}
+   */
+  async has(recipeId) {
+    const db = await getDatabase();
+    const study = await getStore(db).get(recipeId);
+    return !!study;
+  },
+
+  /**
+   * Fetch a study from storage.
+   * @param {Number} recipeId
+   * @return {Study}
+   */
+  async get(recipeId) {
+    const db = await getDatabase();
+    return getStore(db).get(recipeId);
+  },
+
+  /**
+   * Fetch all studies in storage.
+   * @return {Array<Study>}
+   */
+  async getAll() {
+    const db = await getDatabase();
+    return getStore(db).getAll();
+  },
+
+  /**
+   * Start a new study. Installs an add-on and stores the study info.
+   * @param {Object} options
+   * @param {Number} options.recipeId
+   * @param {String} options.name
+   * @param {String} options.description
+   * @param {String} options.addonUrl
+   * @throws
+   *   If any of the required options aren't given.
+   *   If a study for the given recipeID already exists in storage.
+   *   If add-on installation fails.
+   */
+  async start({recipeId, name, description, addonUrl}) {
+    if (!recipeId || !name || !description || !addonUrl) {
+      throw new Error("Required arguments (recipeId, name, description, addonUrl) missing.");
+    }
+
+    const db = await getDatabase();
+    if (await getStore(db).get(recipeId)) {
+      throw new Error(`A study for recipe ${recipeId} already exists.`);
+    }
+
+    const addonFile = await this.downloadAddonToTemporaryFile(addonUrl);
+    const install = await AddonManager.getInstallForFile(addonFile);
+    const study = {
+      recipeId,
+      name,
+      description,
+      addonId: install.addon.id,
+      addonVersion: install.addon.version,
+      addonUrl,
+      active: true,
+      studyStartDate: new Date(),
+    };
+
+    try {
+      await getStore(db).add(study);
+      await Addons.applyInstall(install, false);
+      return study;
+    } catch (err) {
+      await getStore(db).delete(recipeId);
+      throw err;
+    } finally {
+      Services.obs.notifyObservers(addonFile, "flush-cache-entry");
+      await OS.File.remove(addonFile.path);
+    }
+  },
+
+  /**
+   * Download a remote add-on and store it in a temporary nsIFile.
+   * @param {String} addonUrl
+   * @returns {nsIFile}
+   */
+  async downloadAddonToTemporaryFile(addonUrl) {
+    const response = await fetch(addonUrl);
+    if (!response.ok) {
+      throw new Error(`Download for ${addonUrl} failed: ${response.status} ${response.statusText}`);
+    }
+
+    // Create temporary file to store add-on.
+    const path = OS.Path.join(OS.Constants.Path.tmpDir, "study.xpi");
+    const {file, path: uniquePath} = await OS.File.openUnique(path);
+
+    // Write the add-on to the file
+    try {
+      const xpiArrayBufferView = new Uint8Array(await response.arrayBuffer());
+      await file.write(xpiArrayBufferView);
+    } finally {
+      await file.close();
+    }
+
+    return new FileUtils.File(uniquePath);
+  },
+
+  /**
+   * Stop an active study, uninstalling the associated add-on.
+   * @param {Number} recipeId
+   * @throws
+   *   If no study is found with the given recipeId.
+   *   If the study is already inactive.
+   */
+  async stop(recipeId) {
+    const db = await getDatabase();
+    const study = await getStore(db).get(recipeId);
+    if (!study) {
+      throw new Error(`No study found for recipe ${recipeId}`);
+    }
+    if (!study.active) {
+      throw new Error(`Cannot stop study for recipe ${recipeId}; it is already inactive.`);
+    }
+
+    await markAsEnded(db, study);
+
+    try {
+      await Addons.uninstall(study.addonId);
+    } catch (err) {
+      log.warn(`Could not uninstall addon ${study.addonId} for recipe ${study.recipeId}:`, err);
+    }
+  },
+};

new file mode 100644
--- /dev/null
+++ b/browser/extensions/shield-recipe-client/lib/Addons.jsm
@@ -0,0 +1,135 @@
+/* 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 {classes: Cc, interfaces: Ci, utils: Cu} = Components;
+Cu.import("resource://gre/modules/XPCOMUtils.jsm");
+
+XPCOMUtils.defineLazyModuleGetter(this, "AddonManager", "resource://gre/modules/AddonManager.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "Extension", "resource://gre/modules/Extension.jsm");
+XPCOMUtils.defineLazyModuleGetter(
+  this, "CleanupManager", "resource://shield-recipe-client/lib/CleanupManager.jsm"
+);
+
+this.EXPORTED_SYMBOLS = ["Addons"];
+
+/**
+ * SafeAddons store info about an add-on. They are single-depth
+ * objects to simplify cloning, and have no methods so they are safe
+ * to pass to sandboxes and filter expressions.
+ *
+ * @typedef {Object} SafeAddon
+ * @property {string} id
+ *   Add-on id, such as "shield-recipe-client@mozilla.com" or "{4ea51ac2-adf2-4af8-a69d-17b48c558a12}"
+ * @property {Date} installDate
+ * @property {boolean} isActive
+ * @property {string} name
+ * @property {string} type
+ *   "extension", "theme", etc.
+ * @property {string} version
+ */
+
+this.Addons = {
+  /**
+   * Get information about an installed add-on by ID.
+   *
+   * @param {string} addonId
+   * @returns {SafeAddon?} Add-on with given ID, or null if not found.
+   * @throws If addonId is not specified or not a string.
+   */
+  async get(addonId) {
+    const addon = await AddonManager.getAddonByID(addonId);
+    if (!addon) {
+      return null;
+    }
+    return this.serializeForSandbox(addon);
+  },
+
+  /**
+   * Get information about all installed add-ons.
+   * @async
+   * @returns {Array<SafeAddon>}
+   */
+  async getAll(addonId) {
+    const addons = await AddonManager.getAllAddons();
+    return addons.map(this.serializeForSandbox.bind(this));
+  },
+
+  /**
+   * Installs an add-on
+   *
+   * @param {string} addonUrl
+   *   Url to download the .xpi for the add-on from.
+   * @param {object} options
+   * @param {boolean} options.update=false
+   *   If true, will update an existing installed add-on with the same ID.
+   * @async
+   * @returns {string}
+   *   Add-on ID that was installed
+   * @throws {string}
+   *   If the add-on can not be installed, or overwriting is disabled and an
+   *   add-on with a matching ID is already installed.
+   */
+  async install(addonUrl, options) {
+    const installObj = await AddonManager.getInstallForURL(addonUrl, null, "application/x-xpinstall");
+    return this.applyInstall(installObj, options);
+  },
+
+  async applyInstall(addonInstall, {update = false} = {}) {
+    const result = new Promise((resolve, reject) => addonInstall.addListener({
+      onInstallStarted(cbInstall) {
+        if (cbInstall.existingAddon && !update) {
+          reject(new Error(`
+            Cannot install add-on ${cbInstall.addon.id}; an existing add-on
+            with the same ID exists and updating is disabled.
+          `));
+          return false;
+        }
+        return true;
+      },
+      onInstallEnded(cbInstall, addon) {
+        resolve(addon.id);
+      },
+      onInstallFailed(cbInstall) {
+        reject(new Error(`AddonInstall error code: [${cbInstall.error}]`));
+      },
+      onDownloadFailed(cbInstall) {
+        reject(new Error(`Download failed: [${cbInstall.sourceURI.spec}]`));
+      },
+    }));
+    addonInstall.install();
+    return result;
+  },
+
+  /**
+   * Uninstalls an add-on by ID.
+   * @param addonId {string} Add-on ID to uninstall.
+   * @async
+   * @throws If no add-on with `addonId` is installed.
+   */
+  async uninstall(addonId) {
+    const addon = await AddonManager.getAddonByID(addonId);
+    if (addon === null) {
+      throw new Error(`No addon with ID [${addonId}] found.`);
+    }
+    addon.uninstall();
+    return null;
+  },
+
+  /**
+   * Make a safe serialization of an add-on
+   * @param addon {Object} An add-on object as returned from AddonManager.
+   */
+  serializeForSandbox(addon) {
+    return {
+      id: addon.id,
+      installDate: new Date(addon.installDate),
+      isActive: addon.isActive,
+      name: addon.name,
+      type: addon.type,
+      version: addon.version,
+    };
+  },
+};

--- a/browser/extensions/shield-recipe-client/lib/ClientEnvironment.jsm
+++ b/browser/extensions/shield-recipe-client/lib/ClientEnvironment.jsm
@@ -11,19 +11,20 @@ Cu.import("resource://gre/modules/XPCOMU
 
 XPCOMUtils.defineLazyModuleGetter(this, "ShellService", "resource:///modules/ShellService.jsm");
 XPCOMUtils.defineLazyModuleGetter(this, "AddonManager", "resource://gre/modules/AddonManager.jsm");
 XPCOMUtils.defineLazyModuleGetter(this, "TelemetryArchive", "resource://gre/modules/TelemetryArchive.jsm");
 XPCOMUtils.defineLazyModuleGetter(this, "NormandyApi", "resource://shield-recipe-client/lib/NormandyApi.jsm");
 XPCOMUtils.defineLazyModuleGetter(
     this,
     "PreferenceExperiments",
-    "resource://shield-recipe-client/lib/PreferenceExperiments.jsm",
+    "resource://shield-recipe-client/lib/PreferenceExperiments.jsm"
 );
 XPCOMUtils.defineLazyModuleGetter(this, "Utils", "resource://shield-recipe-client/lib/Utils.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "Addons", "resource://shield-recipe-client/lib/Addons.jsm");
 
 const {generateUUID} = Cc["@mozilla.org/uuid-generator;1"].getService(Ci.nsIUUIDGenerator);
 
 this.EXPORTED_SYMBOLS = ["ClientEnvironment"];
 
 // Cached API request for client attributes that are determined by the Normandy
 // service.
 let _classifyRequest = null;
@@ -31,17 +32,17 @@ let _classifyRequest = null;
 this.ClientEnvironment = {
   /**
    * Fetches information about the client that is calculated on the server,
    * like geolocation and the current time.
    *
    * The server request is made lazily and is cached for the entire browser
    * session.
    */
-  getClientClassification() {
+  async getClientClassification() {
     if (!_classifyRequest) {
       _classifyRequest = NormandyApi.classifyClient();
     }
     return _classifyRequest;
   },
 
   clearClassifyCache() {
     _classifyRequest = null;
@@ -192,15 +193,20 @@ this.ClientEnvironment = {
         } else {
           names.active.push(experiment.name);
         }
       }
 
       return names;
     });
 
+    XPCOMUtils.defineLazyGetter(environment, "addons", async () => {
+      const addons = await Addons.getAll();
+      return Utils.keyBy(addons, "id");
+    });
+
     XPCOMUtils.defineLazyGetter(environment, "isFirstRun", () => {
       return Preferences.get("extensions.shield-recipe-client.first_run");
     });
 
     return environment;
   },
 };

--- a/browser/extensions/shield-recipe-client/lib/FilterExpressions.jsm
+++ b/browser/extensions/shield-recipe-client/lib/FilterExpressions.jsm
@@ -4,40 +4,62 @@
 
 "use strict";
 
 const {utils: Cu} = Components;
 Cu.import("resource://gre/modules/XPCOMUtils.jsm");
 Cu.import("resource://shield-recipe-client/lib/Sampling.jsm");
 Cu.import("resource://shield-recipe-client/lib/PreferenceFilters.jsm");
 
+XPCOMUtils.defineLazyModuleGetter(this, "mozjexl", "resource://shield-recipe-client-vendor/mozjexl.js");
+
 this.EXPORTED_SYMBOLS = ["FilterExpressions"];
 
-XPCOMUtils.defineLazyGetter(this, "nodeRequire", () => {
-  const {Loader, Require} = Cu.import("resource://gre/modules/commonjs/toolkit/loader.js", {});
-  const loader = new Loader({
-    paths: {
-      "": "resource://shield-recipe-client/node_modules/",
-    },
-  });
-  return new Require(loader, {});
-});
-
 XPCOMUtils.defineLazyGetter(this, "jexl", () => {
-  const {Jexl} = nodeRequire("jexl/lib/Jexl.js");
-  const jexl = new Jexl();
+  const jexl = new mozjexl.Jexl();
   jexl.addTransforms({
     date: dateString => new Date(dateString),
     stableSample: Sampling.stableSample,
     bucketSample: Sampling.bucketSample,
     preferenceValue: PreferenceFilters.preferenceValue,
     preferenceIsUserSet: PreferenceFilters.preferenceIsUserSet,
     preferenceExists: PreferenceFilters.preferenceExists,
+    keys,
   });
+  jexl.addBinaryOp("intersect", 40, operatorIntersect);
   return jexl;
 });
 
 this.FilterExpressions = {
   eval(expr, context = {}) {
     const onelineExpr = expr.replace(/[\t\n\r]/g, " ");
     return jexl.eval(onelineExpr, context);
   },
 };
+
+/**
+ * Return an array of the given object's own keys (specifically, its enumerable
+ * properties), or undefined if the argument isn't an object.
+ * @param {Object} obj
+ * @return {Array[String]|undefined}
+ */
+function keys(obj) {
+  if (typeof obj !== "object" || obj === null) {
+    return undefined;
+  }
+
+  return Object.keys(obj);
+}
+
+/**
+ * Find all the values that are present in both lists. Returns undefined if
+ * the arguments are not both Arrays.
+ * @param {Array} listA
+ * @param {Array} listB
+ * @return {Array|undefined}
+ */
+function operatorIntersect(listA, listB) {
+  if (!Array.isArray(listA) || !Array.isArray(listB)) {
+    return undefined;
+  }
+
+  return listA.filter(item => listB.includes(item));
+}

--- a/browser/extensions/shield-recipe-client/lib/NormandyApi.jsm
+++ b/browser/extensions/shield-recipe-client/lib/NormandyApi.jsm
@@ -1,29 +1,34 @@
 /* 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 {utils: Cu, classes: Cc, interfaces: Ci} = Components;
 Cu.import("resource://gre/modules/Services.jsm");
-Cu.import("resource://gre/modules/CanonicalJSON.jsm");
+Cu.import("resource://gre/modules/XPCOMUtils.jsm");
 Cu.import("resource://shield-recipe-client/lib/LogManager.jsm");
-Cu.import("resource://shield-recipe-client/lib/Utils.jsm");
+
+XPCOMUtils.defineLazyModuleGetter(
+  this, "CanonicalJSON", "resource://gre/modules/CanonicalJSON.jsm");
+
 Cu.importGlobalProperties(["fetch", "URL"]); /* globals fetch, URL */
 
 this.EXPORTED_SYMBOLS = ["NormandyApi"];
 
 const log = LogManager.getLogger("normandy-api");
 const prefs = Services.prefs.getBranch("extensions.shield-recipe-client.");
 
 let indexPromise = null;
 
 this.NormandyApi = {
+  InvalidSignatureError: class InvalidSignatureError extends Error {},
+
   clearIndexCache() {
     indexPromise = null;
   },
 
   apiCall(method, endpoint, data = {}) {
     const url = new URL(endpoint);
     method = method.toLowerCase();
 
@@ -58,95 +63,157 @@ this.NormandyApi = {
     } else if (url.startsWith("/")) {
       return server + url;
     }
     throw new Error("Can't use relative urls");
   },
 
   async getApiUrl(name) {
     if (!indexPromise) {
-      let apiBase = new URL(prefs.getCharPref("api_url"));
+      const apiBase = new URL(prefs.getCharPref("api_url"));
       if (!apiBase.pathname.endsWith("/")) {
         apiBase.pathname += "/";
       }
       indexPromise = this.get(apiBase.toString()).then(res => res.json());
     }
     const index = await indexPromise;
     if (!(name in index)) {
       throw new Error(`API endpoint with name "${name}" not found.`);
     }
     const url = index[name];
     return this.absolutify(url);
   },
 
-  async fetchRecipes(filters = {enabled: true}) {
-    const signedRecipesUrl = await this.getApiUrl("recipe-signed");
-    const recipesResponse = await this.get(signedRecipesUrl, filters);
-    const rawText = await recipesResponse.text();
-    const recipesWithSigs = JSON.parse(rawText);
+  async fetchSignedObjects(type, filters) {
+    const signedObjectsUrl = await this.getApiUrl(`${type}-signed`);
+    const objectsResponse = await this.get(signedObjectsUrl, filters);
+    const rawText = await objectsResponse.text();
+    const objectsWithSigs = JSON.parse(rawText);
+
+    const verifiedObjects = [];
 
-    const verifiedRecipes = [];
+    for (const objectWithSig of objectsWithSigs) {
+      const {signature, x5u} = objectWithSig.signature;
+      const object = objectWithSig[type];
 
-    for (const {recipe, signature: {signature, x5u}} of recipesWithSigs) {
-      const serialized = CanonicalJSON.stringify(recipe);
+      const serialized = CanonicalJSON.stringify(object);
+      // Check that the rawtext (the object and the signature)
+      // includes the CanonicalJSON version of the object. This isn't
+      // strictly needed, but it is a great benefit for debugging
+      // signature problems.
       if (!rawText.includes(serialized)) {
         log.debug(rawText, serialized);
-        throw new Error("Canonical recipe serialization does not match!");
+        throw new NormandyApi.InvalidSignatureError(
+          `Canonical ${type} serialization does not match!`);
       }
 
-      const certChainResponse = await fetch(this.absolutify(x5u));
+      const certChainResponse = await this.get(this.absolutify(x5u));
       const certChain = await certChainResponse.text();
       const builtSignature = `p384ecdsa=${signature}`;
 
       const verifier = Cc["@mozilla.org/security/contentsignatureverifier;1"]
         .createInstance(Ci.nsIContentSignatureVerifier);
 
-      const valid = verifier.verifyContentSignature(
-        serialized,
-        builtSignature,
-        certChain,
-        "normandy.content-signature.mozilla.org"
-      );
+      let valid;
+      try {
+        valid = verifier.verifyContentSignature(
+          serialized,
+          builtSignature,
+          certChain,
+          "normandy.content-signature.mozilla.org"
+        );
+      } catch (err) {
+        throw new NormandyApi.InvalidSignatureError(`${type} signature validation failed: ${err}`);
+      }
+
       if (!valid) {
-        throw new Error("Recipe signature is not valid");
+        throw new NormandyApi.InvalidSignatureError(`${type} signature is not valid`);
       }
-      verifiedRecipes.push(recipe);
+
+      verifiedObjects.push(object);
     }
 
     log.debug(
-      `Fetched ${verifiedRecipes.length} recipes from the server:`,
-      verifiedRecipes.map(r => r.name).join(", ")
+      `Fetched ${verifiedObjects.length} ${type} from the server:`,
+      verifiedObjects.map(r => r.name).join(", ")
     );
 
-    return verifiedRecipes;
+    return verifiedObjects;
   },
 
   /**
    * Fetch metadata about this client determined by the server.
    * @return {object} Metadata specified by the server
    */
   async classifyClient() {
     const classifyClientUrl = await this.getApiUrl("classify-client");
     const response = await this.get(classifyClientUrl);
     const clientData = await response.json();
     clientData.request_time = new Date(clientData.request_time);
     return clientData;
   },
 
   /**
    * Fetch an array of available actions from the server.
+   * @param filters
+   * @param filters.enabled {boolean} If true, only returns enabled
+   * recipes. Default true.
    * @resolves {Array}
    */
-  async fetchActions() {
-    const actionApiUrl = await this.getApiUrl("action-list");
-    const res = await this.get(actionApiUrl);
-    return res.json();
+  async fetchRecipes(filters = {enabled: true}) {
+    return this.fetchSignedObjects("recipe", filters);
+  },
+
+  /**
+   * Fetch an array of available actions from the server.
+   * @resolves {Array}
+   */
+  async fetchActions(filters = {}) {
+    return this.fetchSignedObjects("action", filters);
   },
 
   async fetchImplementation(action) {
-    const response = await fetch(action.implementation_url);
-    if (response.ok) {
-      return response.text();
+    const implementationUrl = new URL(this.absolutify(action.implementation_url));
+
+    // fetch implementation
+    const response = await fetch(implementationUrl);
+    if (!response.ok) {
+      throw new Error(
+        `Failed to fetch action implementation for ${action.name}: ${response.status}`
+      );
+    }
+    const responseText = await response.text();
+
+    // Try to verify integrity of the implementation text.  If the
+    // integrity value doesn't match the content or uses an unknown
+    // algorithm, fail.
+
+    // Get the last non-empty portion of the url path, and split it
+    // into two to get the aglorithm and hash.
+    const parts = implementationUrl.pathname.split("/");
+    const lastNonEmpty = parts.filter(p => p !== "").slice(-1)[0];
+    const [algorithm, ...hashParts] = lastNonEmpty.split("-");
+    const expectedHash = hashParts.join("-");
+
+    if (algorithm !== "sha384") {
+      throw new Error(
+        `Failed to fetch action implemenation for ${action.name}: ` +
+        `Unexpected integrity algorithm, expected "sha384", got ${algorithm}`
+      );
     }
 
-    throw new Error(`Failed to fetch action implementation for ${action.name}: ${response.status}`);
+    // verify integrity hash
+    const hasher = Cc["@mozilla.org/security/hash;1"].createInstance(Ci.nsICryptoHash);
+    hasher.init(hasher.SHA384);
+    const dataToHash = new TextEncoder().encode(responseText);
+    hasher.update(dataToHash, dataToHash.length);
+    const useBase64 = true;
+    const hash = hasher.finish(useBase64).replace(/\+/g, "-").replace(/\//g, "_");
+    if (hash !== expectedHash) {
+      throw new Error(
+        `Failed to fetch action implementation for ${action.name}: ` +
+        `Integrity hash does not match content. Expected ${expectedHash} got ${hash}.`
+      );
+    }
+
+    return responseText;
   },
 };

--- a/browser/extensions/shield-recipe-client/lib/NormandyDriver.jsm
+++ b/browser/extensions/shield-recipe-client/lib/NormandyDriver.jsm
@@ -1,29 +1,34 @@
 /* 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 {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/Preferences.jsm");
 Cu.import("resource:///modules/ShellService.jsm");
 Cu.import("resource://gre/modules/AddonManager.jsm");
 Cu.import("resource://gre/modules/Timer.jsm");
+Cu.import("resource://shield-recipe-client/lib/Addons.jsm");
 Cu.import("resource://shield-recipe-client/lib/LogManager.jsm");
 Cu.import("resource://shield-recipe-client/lib/Storage.jsm");
 Cu.import("resource://shield-recipe-client/lib/Heartbeat.jsm");
 Cu.import("resource://shield-recipe-client/lib/FilterExpressions.jsm");
 Cu.import("resource://shield-recipe-client/lib/ClientEnvironment.jsm");
 Cu.import("resource://shield-recipe-client/lib/PreferenceExperiments.jsm");
 Cu.import("resource://shield-recipe-client/lib/Sampling.jsm");
 
+XPCOMUtils.defineLazyModuleGetter(
+  this, "AddonStudies", "resource://shield-recipe-client/lib/AddonStudies.jsm");
+
 const {generateUUID} = Cc["@mozilla.org/uuid-generator;1"].getService(Ci.nsIUUIDGenerator);
 
 this.EXPORTED_SYMBOLS = ["NormandyDriver"];
 
 const log = LogManager.getLogger("normandy-driver");
 const actionLog = LogManager.getLogger("normandy-driver.actions");
 
 this.NormandyDriver = function(sandboxManager) {
@@ -151,22 +156,74 @@ this.NormandyDriver = function(sandboxMa
       return Cu.cloneInto(token, sandbox);
     },
 
     clearTimeout(token) {
       clearTimeout(token);
       sandboxManager.removeHold(`setTimeout-${token}`);
     },
 
+    addons: {
+      get: sandboxManager.wrapAsync(Addons.get.bind(Addons), {cloneInto: true}),
+      install: sandboxManager.wrapAsync(Addons.install.bind(Addons)),
+      uninstall: sandboxManager.wrapAsync(Addons.uninstall.bind(Addons)),
+    },
+
     // Sampling
     ratioSample: sandboxManager.wrapAsync(Sampling.ratioSample),
 
     // Preference Experiment API
     preferenceExperiments: {
       start: sandboxManager.wrapAsync(PreferenceExperiments.start, {cloneArguments: true}),
       markLastSeen: sandboxManager.wrapAsync(PreferenceExperiments.markLastSeen),
       stop: sandboxManager.wrapAsync(PreferenceExperiments.stop),
       get: sandboxManager.wrapAsync(PreferenceExperiments.get, {cloneInto: true}),
       getAllActive: sandboxManager.wrapAsync(PreferenceExperiments.getAllActive, {cloneInto: true}),
       has: sandboxManager.wrapAsync(PreferenceExperiments.has),
     },
+
+    // Study storage API
+    studies: {
+      start: sandboxManager.wrapAsync(
+        AddonStudies.start.bind(AddonStudies),
+        {cloneArguments: true, cloneInto: true}
+      ),
+      stop: sandboxManager.wrapAsync(AddonStudies.stop.bind(AddonStudies)),
+      get: sandboxManager.wrapAsync(AddonStudies.get.bind(AddonStudies), {cloneInto: true}),
+      getAll: sandboxManager.wrapAsync(AddonStudies.getAll.bind(AddonStudies), {cloneInto: true}),
+      has: sandboxManager.wrapAsync(AddonStudies.has.bind(AddonStudies)),
+    },
+
+    // Preference read-only API
+    preferences: {
+      getBool: wrapPrefGetter(Services.prefs.getBoolPref),
+      getInt: wrapPrefGetter(Services.prefs.getIntPref),
+      getChar: wrapPrefGetter(Services.prefs.getCharPref),
+      has(name) {
+        return Services.prefs.getPrefType(name) !== Services.prefs.PREF_INVALID;
+      },
+    },
   };
 };
+
+/**
+ * Wrap a getter form nsIPrefBranch for use in the sandbox.
+ *
+ * We don't want to export the getters directly in case they add parameters that
+ * aren't safe for the sandbox without us noticing; wrapping helps prevent
+ * passing unknown parameters.
+ *
+ * @param {Function} getter
+ *   Function on an nsIPrefBranch that fetches a preference value.
+ * @return {Function}
+ */
+function wrapPrefGetter(getter) {
+  return (value, defaultValue = undefined) => {
+    // Passing undefined as the defaultValue disables throwing exceptions when
+    // the pref is missing or the type doesn't match, so we need to specifically
+    // exclude it if we don't want default value behavior.
+    const args = [value];
+    if (defaultValue !== undefined) {
+      args.push(defaultValue);
+    }
+    return getter.apply(null, args);
+  };
+}

--- a/browser/extensions/shield-recipe-client/lib/PreferenceExperiments.jsm
+++ b/browser/extensions/shield-recipe-client/lib/PreferenceExperiments.jsm
@@ -144,17 +144,17 @@ this.PreferenceExperiments = {
   async init() {
     for (const experiment of await this.getAllActive()) {
       // Set experiment default preferences, since they don't persist between restarts
       if (experiment.preferenceBranchType === "default") {
         setPref(DefaultPreferences, experiment.preferenceName, experiment.preferenceType, experiment.preferenceValue);
       }
 
       // Check that the current value of the preference is still what we set it to
-      if (getPref(UserPreferences, experiment.preferenceName, experiment.preferenceType) !== experiment.preferenceValue) {
+      if (getPref(UserPreferences, experiment.preferenceName, experiment.preferenceType, undefined) !== experiment.preferenceValue) {
         // if not, stop the experiment, and skip the remaining steps
         log.info(`Stopping experiment "${experiment.name}" because its value changed`);
         await this.stop(experiment.name, false);
         continue;
       }
 
       // Notify Telemetry of experiments we're running, since they don't persist between restarts
       TelemetryEnvironment.setExperimentActive(experiment.name, experiment.branch);
@@ -237,17 +237,17 @@ this.PreferenceExperiments = {
     const experiment = {
       name,
       branch,
       expired: false,
       lastSeen: new Date().toJSON(),
       preferenceName,
       preferenceValue,
       preferenceType,
-      previousPreferenceValue: getPref(preferences, preferenceName, preferenceType),
+      previousPreferenceValue: getPref(preferences, preferenceName, preferenceType, undefined),
       preferenceBranchType,
     };
 
     const prevPrefType = Services.prefs.getPrefType(preferenceName);
     const givenPrefType = PREFERENCE_TYPE_MAP[preferenceType];
 
     if (!preferenceType || !givenPrefType) {
       throw new Error(`Invalid preferenceType provided (given "${preferenceType}")`);
@@ -284,17 +284,17 @@ this.PreferenceExperiments = {
       throw new Error(
         `An observer for the preference experiment ${experimentName} is already active.`
       );
     }
 
     const observerInfo = {
       preferenceName,
       observer() {
-        let newValue = getPref(UserPreferences, preferenceName, preferenceType);
+        let newValue = getPref(UserPreferences, preferenceName, preferenceType, undefined);
         if (newValue !== preferenceValue) {
           PreferenceExperiments.stop(experimentName, false)
                                .catch(Cu.reportError);
         }
       },
     };
     experimentObservers.set(experimentName, observerInfo);
     Services.prefs.addObserver(preferenceName, observerInfo.observer);

--- a/browser/extensions/shield-recipe-client/lib/RecipeRunner.jsm
+++ b/browser/extensions/shield-recipe-client/lib/RecipeRunner.jsm
@@ -24,16 +24,20 @@ XPCOMUtils.defineLazyModuleGetter(this, 
 XPCOMUtils.defineLazyModuleGetter(this, "SandboxManager",
                                   "resource://shield-recipe-client/lib/SandboxManager.jsm");
 XPCOMUtils.defineLazyModuleGetter(this, "ClientEnvironment",
                                   "resource://shield-recipe-client/lib/ClientEnvironment.jsm");
 XPCOMUtils.defineLazyModuleGetter(this, "CleanupManager",
                                   "resource://shield-recipe-client/lib/CleanupManager.jsm");
 XPCOMUtils.defineLazyModuleGetter(this, "ActionSandboxManager",
                                   "resource://shield-recipe-client/lib/ActionSandboxManager.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "AddonStudies",
+                                  "resource://shield-recipe-client/lib/AddonStudies.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "Uptake",
+                                  "resource://shield-recipe-client/lib/Uptake.jsm");
 
 Cu.importGlobalProperties(["fetch"]);
 
 this.EXPORTED_SYMBOLS = ["RecipeRunner"];
 
 const log = LogManager.getLogger("recipe-runner");
 const prefs = Services.prefs.getBranch("extensions.shield-recipe-client.");
 const TIMER_NAME = "recipe-client-addon-run";
@@ -122,106 +126,141 @@ this.RecipeRunner = {
     const runInterval = prefs.getIntPref(RUN_INTERVAL_PREF);
     timerManager.registerTimer(TIMER_NAME, () => this.run(), runInterval);
   },
 
   async run() {
     this.clearCaches();
     // Unless lazy classification is enabled, prep the classify cache.
     if (!Preferences.get("extensions.shield-recipe-client.experiments.lazy_classify", false)) {
-      await ClientEnvironment.getClientClassification();
+      try {
+        await ClientEnvironment.getClientClassification();
+      } catch (err) {
+        // Try to go on without this data; the filter expressions will
+        // gracefully fail without this info if they need it.
+      }
+    }
+
+    // Fetch recipes before execution in case we fail and exit early.
+    let recipes;
+    try {
+      recipes = await NormandyApi.fetchRecipes({enabled: true});
+    } catch (e) {
+      const apiUrl = prefs.getCharPref("api_url");
+      log.error(`Could not fetch recipes from ${apiUrl}: "${e}"`);
+
+      let status = Uptake.RUNNER_SERVER_ERROR;
+      if (/NetworkError/.test(e)) {
+        status = Uptake.RUNNER_NETWORK_ERROR;
+      } else if (e instanceof NormandyApi.InvalidSignatureError) {
+        status = Uptake.RUNNER_INVALID_SIGNATURE;
+      }
+      Uptake.reportRunner(status);
+      return;
     }
 
     const actionSandboxManagers = await this.loadActionSandboxManagers();
     Object.values(actionSandboxManagers).forEach(manager => manager.addHold("recipeRunner"));
 
     // Run pre-execution hooks. If a hook fails, we don't run recipes with that
     // action to avoid inconsistencies.
     for (const [actionName, manager] of Object.entries(actionSandboxManagers)) {
       try {
         await manager.runAsyncCallback("preExecution");
         manager.disabled = false;
       } catch (err) {
         log.error(`Could not run pre-execution hook for ${actionName}:`, err.message);
         manager.disabled = true;
+        Uptake.reportAction(actionName, Uptake.ACTION_PRE_EXECUTION_ERROR);
       }
     }
 
-    // Fetch recipes from the API
-    let recipes;
-    try {
-      recipes = await NormandyApi.fetchRecipes({enabled: true});
-    } catch (e) {
-      const apiUrl = prefs.getCharPref("api_url");
-      log.error(`Could not fetch recipes from ${apiUrl}: "${e}"`);
-      return;
-    }
-
     // Evaluate recipe filters
     const recipesToRun = [];
     for (const recipe of recipes) {
       if (await this.checkFilter(recipe)) {
         recipesToRun.push(recipe);
       }
     }
 
     // Execute recipes, if we have any.
     if (recipesToRun.length === 0) {
       log.debug("No recipes to execute");
     } else {
       for (const recipe of recipesToRun) {
         const manager = actionSandboxManagers[recipe.action];
+        let status;
         if (!manager) {
           log.error(
             `Could not execute recipe ${recipe.name}:`,
             `Action ${recipe.action} is either missing or invalid.`
           );
+          status = Uptake.RECIPE_INVALID_ACTION;
         } else if (manager.disabled) {
           log.warn(
             `Skipping recipe ${recipe.name} because ${recipe.action} failed during pre-execution.`
           );
+          status = Uptake.RECIPE_ACTION_DISABLED;
         } else {
           try {
             log.info(`Executing recipe "${recipe.name}" (action=${recipe.action})`);
             await manager.runAsyncCallback("action", recipe);
+            status = Uptake.RECIPE_SUCCESS;
           } catch (e) {
-            log.error(`Could not execute recipe ${recipe.name}:`, e);
+            log.error(`Could not execute recipe ${recipe.name}:`);
+            Cu.reportError(e);
+            status = Uptake.RECIPE_EXECUTION_ERROR;
           }
         }
+
+        Uptake.reportRecipe(recipe.id, status);
       }
     }
 
     // Run post-execution hooks
     for (const [actionName, manager] of Object.entries(actionSandboxManagers)) {
       // Skip if pre-execution failed.
       if (manager.disabled) {
         log.info(`Skipping post-execution hook for ${actionName} due to earlier failure.`);
         continue;
       }
 
       try {
         await manager.runAsyncCallback("postExecution");
+        Uptake.reportAction(actionName, Uptake.ACTION_SUCCESS);
       } catch (err) {
         log.info(`Could not run post-execution hook for ${actionName}:`, err.message);
+        Uptake.reportAction(actionName, Uptake.ACTION_POST_EXECUTION_ERROR);
       }
     }
 
     // Nuke sandboxes
     Object.values(actionSandboxManagers).forEach(manager => manager.removeHold("recipeRunner"));
+
+    // Close storage connections
+    await AddonStudies.close();
+
+    Uptake.reportRunner(Uptake.RUNNER_SUCCESS);
   },
 
   async loadActionSandboxManagers() {
     const actions = await NormandyApi.fetchActions();
     const actionSandboxManagers = {};
     for (const action of actions) {
       try {
         const implementation = await NormandyApi.fetchImplementation(action);
         actionSandboxManagers[action.name] = new ActionSandboxManager(implementation);
       } catch (err) {
         log.warn(`Could not fetch implementation for ${action.name}:`, err);
+
+        let status = Uptake.ACTION_SERVER_ERROR;
+        if (/NetworkError/.test(err)) {
+          status = Uptake.ACTION_NETWORK_ERROR;
+        }
+        Uptake.reportAction(action.name, status);
       }
     }
     return actionSandboxManagers;
   },
 
   getFilterContext(recipe) {
     return {
       normandy: Object.assign(ClientEnvironment.getEnvironment(), {

new file mode 100644
--- /dev/null
+++ b/browser/extensions/shield-recipe-client/lib/ShieldPreferences.jsm
@@ -0,0 +1,121 @@
+/* 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 {utils: Cu} = Components;
+Cu.import("resource://gre/modules/Services.jsm");
+Cu.import("resource://gre/modules/XPCOMUtils.jsm");
+
+XPCOMUtils.defineLazyModuleGetter(
+  this, "AppConstants", "resource://gre/modules/AppConstants.jsm"
+);
+XPCOMUtils.defineLazyModuleGetter(
+  this, "CleanupManager", "resource://shield-recipe-client/lib/CleanupManager.jsm"
+);
+
+this.EXPORTED_SYMBOLS = ["ShieldPreferences"];
+
+const XUL_NS = "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul";
+const NS_PREFBRANCH_PREFCHANGE_TOPIC_ID = "nsPref:changed"; // from modules/libpref/nsIPrefBranch.idl
+const FHR_UPLOAD_ENABLED_PREF = "datareporting.healthreport.uploadEnabled";
+const OPT_OUT_STUDIES_ENABLED_PREF = "app.shield.optoutstudies.enabled";
+
+/**
+ * Handles Shield-specific preferences, including their UI.
+ */
+this.ShieldPreferences = {
+  init() {
+    // If the FHR pref was disabled since our last run, disable opt-out as well.
+    if (!Services.prefs.getBoolPref(FHR_UPLOAD_ENABLED_PREF)) {
+      Services.prefs.setBoolPref(OPT_OUT_STUDIES_ENABLED_PREF, false);
+    }
+
+    // Watch for changes to the FHR pref
+    Services.prefs.addObserver(FHR_UPLOAD_ENABLED_PREF, this);
+    CleanupManager.addCleanupHandler(() => {
+      Services.prefs.removeObserver(FHR_UPLOAD_ENABLED_PREF, this);
+    });
+
+    // Disabled outside of en-* locales temporarily (bug 1377192).
+    // Disabled when MOZ_DATA_REPORTING is false since the FHR UI is also hidden
+    // when data reporting is false.
+    if (AppConstants.MOZ_DATA_REPORTING && Services.locale.getAppLocaleAsLangTag().startsWith("en")) {
+      Services.obs.addObserver(this, "advanced-pane-loaded");
+      CleanupManager.addCleanupHandler(() => {
+        Services.obs.removeObserver(this, "advanced-pane-loaded");
+      });
+    }
+  },
+
+  observe(subject, topic, data) {
+    switch (topic) {
+      // Add the opt-out-study checkbox to the Privacy preferences when it is shown.
+      case "advanced-pane-loaded":
+        if (!Services.prefs.getBoolPref("browser.preferences.useOldOrganization", false)) {
+          this.injectOptOutStudyCheckbox(subject.document);
+        }
+        break;
+      // If the FHR pref changes, set the opt-out-study pref to the value it is changing to.
+      case NS_PREFBRANCH_PREFCHANGE_TOPIC_ID:
+        if (data === FHR_UPLOAD_ENABLED_PREF) {
+          const fhrUploadEnabled = Services.prefs.getBoolPref(FHR_UPLOAD_ENABLED_PREF);
+          Services.prefs.setBoolPref(OPT_OUT_STUDIES_ENABLED_PREF, fhrUploadEnabled);
+        }
+        break;
+    }
+  },
+
+  /**
+   * Injects the opt-out-study preference checkbox into about:preferences and
+   * handles events coming from the UI for it.
+   */
+  injectOptOutStudyCheckbox(doc) {
+    const container = doc.createElementNS(XUL_NS, "vbox");
+    container.classList.add("indent");
+
+    const hContainer = doc.createElementNS(XUL_NS, "hbox");
+    hContainer.setAttribute("align", "center");
+    container.appendChild(hContainer);
+
+    const checkbox = doc.createElementNS(XUL_NS, "checkbox");
+    checkbox.setAttribute("id", "optOutStudiesEnabled");
+    checkbox.setAttribute("label", "Allow Firefox to install and run studies");
+    checkbox.setAttribute("preference", OPT_OUT_STUDIES_ENABLED_PREF);
+    checkbox.setAttribute("disabled", !Services.prefs.getBoolPref(FHR_UPLOAD_ENABLED_PREF));
+    hContainer.appendChild(checkbox);
+
+    const viewStudies = doc.createElementNS(XUL_NS, "label");
+    viewStudies.setAttribute("id", "viewShieldStudies");
+    viewStudies.setAttribute("href", "about:studies");
+    viewStudies.setAttribute("useoriginprincipal", true);
+    viewStudies.textContent = "View Firefox Studies";
+    viewStudies.classList.add("learnMore", "text-link");
+    hContainer.appendChild(viewStudies);
+
+    // <prefrence> elements for prefs that we need to monitor while the page is open.
+    const optOutPref = doc.createElementNS(XUL_NS, "preference");
+    optOutPref.setAttribute("id", OPT_OUT_STUDIES_ENABLED_PREF);
+    optOutPref.setAttribute("name", OPT_OUT_STUDIES_ENABLED_PREF);
+    optOutPref.setAttribute("type", "bool");
+
+    // Weirdly, FHR doesn't have a <preference> element on the page, so we create it.
+    const fhrPref = doc.createElementNS(XUL_NS, "preference");
+    fhrPref.setAttribute("id", FHR_UPLOAD_ENABLED_PREF);
+    fhrPref.setAttribute("name", FHR_UPLOAD_ENABLED_PREF);
+    fhrPref.setAttribute("type", "bool");
+    fhrPref.addEventListener("change", function(event) {
+      // Avoid reference to the document directly, to avoid leaks.
+      const eventTargetCheckbox = event.target.ownerDocument.getElementById("optOutStudiesEnabled");
+      eventTargetCheckbox.disabled = !Services.prefs.getBoolPref(FHR_UPLOAD_ENABLED_PREF);
+    });
+
+    // Actually inject the elements we've created.
+    const parent = doc.getElementById("submitHealthReportBox").closest("vbox");
+    parent.appendChild(container);
+
+    const preferences = doc.getElementById("privacyPreferences");
+    preferences.appendChild(optOutPref);
+    preferences.appendChild(fhrPref);
+  },
+};

--- a/browser/extensions/shield-recipe-client/lib/ShieldRecipeClient.jsm
+++ b/browser/extensions/shield-recipe-client/lib/ShieldRecipeClient.jsm
@@ -11,96 +11,82 @@ Cu.import("resource://gre/modules/XPCOMU
 XPCOMUtils.defineLazyModuleGetter(this, "LogManager",
   "resource://shield-recipe-client/lib/LogManager.jsm");
 XPCOMUtils.defineLazyModuleGetter(this, "RecipeRunner",
   "resource://shield-recipe-client/lib/RecipeRunner.jsm");
 XPCOMUtils.defineLazyModuleGetter(this, "CleanupManager",
   "resource://shield-recipe-client/lib/CleanupManager.jsm");
 XPCOMUtils.defineLazyModuleGetter(this, "PreferenceExperiments",
   "resource://shield-recipe-client/lib/PreferenceExperiments.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "AboutPages",
+  "resource://shield-recipe-client-content/AboutPages.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "ShieldPreferences",
+  "resource://shield-recipe-client/lib/ShieldPreferences.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "AddonStudies",
+  "resource://shield-recipe-client/lib/AddonStudies.jsm");
 
 this.EXPORTED_SYMBOLS = ["ShieldRecipeClient"];
 
 const {PREF_STRING, PREF_BOOL, PREF_INT} = Ci.nsIPrefBranch;
 
 const REASONS = {
   APP_STARTUP: 1,      // The application is starting up.
   APP_SHUTDOWN: 2,     // The application is shutting down.
   ADDON_ENABLE: 3,     // The add-on is being enabled.
   ADDON_DISABLE: 4,    // The add-on is being disabled. (Also sent during uninstallation)
   ADDON_INSTALL: 5,    // The add-on is being installed.
   ADDON_UNINSTALL: 6,  // The add-on is being uninstalled.
   ADDON_UPGRADE: 7,    // The add-on is being upgraded.
   ADDON_DOWNGRADE: 8,  // The add-on is being downgraded.
 };
-const PREF_BRANCH = "extensions.shield-recipe-client.";
-const DEFAULT_PREFS = {
-  api_url: ["https://normandy.cdn.mozilla.net/api/v1", PREF_STRING],
-  dev_mode: [false, PREF_BOOL],
-  enabled: [true, PREF_BOOL],
-  startup_delay_seconds: [300, PREF_INT],
-  "logging.level": [Log.Level.Warn, PREF_INT],
-  user_id: ["", PREF_STRING],
-  run_interval_seconds: [86400, PREF_INT], // 24 hours
-  first_run: [true, PREF_BOOL],
-};
 const PREF_DEV_MODE = "extensions.shield-recipe-client.dev_mode";
-const PREF_LOGGING_LEVEL = PREF_BRANCH + "logging.level";
+const PREF_LOGGING_LEVEL = "extensions.shield-recipe-client.logging.level";
 
 let log = null;
 
 /**
  * Handles startup and shutdown of the entire add-on. Bootsrap.js defers to this
  * module for most tasks so that we can more easily test startup and shutdown
  * (bootstrap.js is difficult to import in tests).
  */
 this.ShieldRecipeClient = {
   async startup() {
-    ShieldRecipeClient.setDefaultPrefs();
-
     // Setup logging and listen for changes to logging prefs
     LogManager.configure(Services.prefs.getIntPref(PREF_LOGGING_LEVEL));
     Services.prefs.addObserver(PREF_LOGGING_LEVEL, LogManager.configure);
     CleanupManager.addCleanupHandler(
       () => Services.prefs.removeObserver(PREF_LOGGING_LEVEL, LogManager.configure),
     );
     log = LogManager.getLogger("bootstrap");
 
+    try {
+      await AboutPages.init();
+    } catch (err) {
+      log.error("Failed to initialize about pages:", err);
+    }
+
+    try {
+      await AddonStudies.init();
+    } catch (err) {
+      log.error("Failed to initialize addon studies:", err);
+    }
+
     // Initialize experiments first to avoid a race between initializing prefs
     // and recipes rolling back pref changes when experiments end.
     try {
       await PreferenceExperiments.init();
     } catch (err) {
       log.error("Failed to initialize preference experiments:", err);
     }
 
+    try {
+      ShieldPreferences.init();
+    } catch (err) {
+      log.error("Failed to initialize preferences UI:", err);
+    }
+
     await RecipeRunner.init();
   },
 
   shutdown(reason) {
     CleanupManager.cleanup();
   },
-
-  setDefaultPrefs() {
-    for (const [key, [val, type]] of Object.entries(DEFAULT_PREFS)) {
-      const fullKey = PREF_BRANCH + key;
-      // If someone beat us to setting a default, don't overwrite it.
-      if (!Services.prefs.prefHasUserValue(fullKey)) {
-        switch (type) {
-          case PREF_BOOL:
-            Services.prefs.setBoolPref(fullKey, val);
-            break;
-
-          case PREF_INT:
-            Services.prefs.setIntPref(fullKey, val);
-            break;
-
-          case PREF_STRING:
-            Services.prefs.setStringPref(fullKey, val);
-            break;
-
-          default:
-            throw new TypeError(`Unexpected type (${type}) for preference ${fullKey}.`)
-        }
-      }
-    }
-  },
 };

new file mode 100644
--- /dev/null
+++ b/browser/extensions/shield-recipe-client/lib/Uptake.jsm
@@ -0,0 +1,48 @@
+/* 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 {utils: Cu} = Components;
+Cu.import("resource://gre/modules/XPCOMUtils.jsm");
+
+XPCOMUtils.defineLazyModuleGetter(
+  this, "UptakeTelemetry", "resource://services-common/uptake-telemetry.js");
+
+this.EXPORTED_SYMBOLS = ["Uptake"];
+
+const SOURCE_PREFIX = "shield-recipe-client";
+
+this.Uptake = {
+  // Action uptake
+  ACTION_NETWORK_ERROR: UptakeTelemetry.STATUS.NETWORK_ERROR,
+  ACTION_PRE_EXECUTION_ERROR: UptakeTelemetry.STATUS.CUSTOM_1_ERROR,
+  ACTION_POST_EXECUTION_ERROR: UptakeTelemetry.STATUS.CUSTOM_2_ERROR,
+  ACTION_SERVER_ERROR: UptakeTelemetry.STATUS.SERVER_ERROR,
+  ACTION_SUCCESS: UptakeTelemetry.STATUS.SUCCESS,
+
+  // Per-recipe uptake
+  RECIPE_ACTION_DISABLED: UptakeTelemetry.STATUS.CUSTOM_1_ERROR,
+  RECIPE_EXECUTION_ERROR: UptakeTelemetry.STATUS.APPLY_ERROR,
+  RECIPE_INVALID_ACTION: UptakeTelemetry.STATUS.DOWNLOAD_ERROR,
+  RECIPE_SUCCESS: UptakeTelemetry.STATUS.SUCCESS,
+
+  // Uptake for the runner as a whole
+  RUNNER_INVALID_SIGNATURE: UptakeTelemetry.STATUS.SIGNATURE_ERROR,
+  RUNNER_NETWORK_ERROR: UptakeTelemetry.STATUS.NETWORK_ERROR,
+  RUNNER_SERVER_ERROR: UptakeTelemetry.STATUS.SERVER_ERROR,
+  RUNNER_SUCCESS: UptakeTelemetry.STATUS.SUCCESS,
+
+  reportRunner(status) {
+    UptakeTelemetry.report(`${SOURCE_PREFIX}/runner`, status);
+  },
+
+  reportRecipe(recipeId, status) {
+    UptakeTelemetry.report(`${SOURCE_PREFIX}/recipe/${recipeId}`, status);
+  },
+
+  reportAction(actionName, status) {
+    UptakeTelemetry.report(`${SOURCE_PREFIX}/action/${actionName}`, status);
+  },
+};

deleted file mode 100644
--- a/browser/extensions/shield-recipe-client/node_modules/jexl/LICENSE.txt
+++ /dev/null
@@ -1,19 +0,0 @@
-Copyright (c) 2015 TechnologyAdvice
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
\ No newline at end of file

deleted file mode 100644
--- a/browser/extensions/shield-recipe-client/node_modules/jexl/lib/Jexl.js
+++ /dev/null
@@ -1,225 +0,0 @@
-/*
- * Jexl
- * Copyright (c) 2015 TechnologyAdvice
- */
-
-var Evaluator = require('./evaluator/Evaluator'),
-	Lexer = require('./Lexer'),
-	Parser = require('./parser/Parser'),
-	defaultGrammar = require('./grammar').elements;
-
-/**
- * Jexl is the Javascript Expression Language, capable of parsing and
- * evaluating basic to complex expression strings, combined with advanced
- * xpath-like drilldown into native Javascript objects.
- * @constructor
- */
-function Jexl() {
-	this._customGrammar = null;
-	this._lexer = null;
-	this._transforms = {};
-}
-
-/**
- * Adds a binary operator to Jexl at the specified precedence. The higher the
- * precedence, the earlier the operator is applied in the order of operations.
- * For example, * has a higher precedence than +, because multiplication comes
- * before division.
- *
- * Please see grammar.js for a listing of all default operators and their
- * precedence values in order to choose the appropriate precedence for the
- * new operator.
- * @param {string} operator The operator string to be added
- * @param {number} precedence The operator's precedence
- * @param {function} fn A function to run to calculate the result. The function
- *      will be called with two arguments: left and right, denoting the values
- *      on either side of the operator. It should return either the resulting
- *      value, or a Promise that resolves with the resulting value.
- */
-Jexl.prototype.addBinaryOp = function(operator, precedence, fn) {
-	this._addGrammarElement(operator, {
-		type: 'binaryOp',
-		precedence: precedence,
-		eval: fn
-	});
-};
-
-/**
- * Adds a unary operator to Jexl. Unary operators are currently only supported
- * on the left side of the value on which it will operate.
- * @param {string} operator The operator string to be added
- * @param {function} fn A function to run to calculate the result. The function
- *      will be called with one argument: the literal value to the right of the
- *      operator. It should return either the resulting value, or a Promise
- *      that resolves with the resulting value.
- */
-Jexl.prototype.addUnaryOp = function(operator, fn) {
-	this._addGrammarElement(operator, {
-		type: 'unaryOp',
-		weight: Infinity,
-		eval: fn
-	});
-};
-
-/**
- * Adds or replaces a transform function in this Jexl instance.
- * @param {string} name The name of the transform function, as it will be used
- *      within Jexl expressions
- * @param {function} fn The function to be executed when this transform is
- *      invoked.  It will be provided with two arguments:
- *          - {*} value: The value to be transformed
- *          - {{}} args: The arguments for this transform
- *          - {function} cb: A callback function to be called with an error
- *            if the transform fails, or a null first argument and the
- *            transformed value as the second argument on success.
- */
-Jexl.prototype.addTransform = function(name, fn) {
-	this._transforms[name] = fn;
-};
-
-/**
- * Syntactic sugar for calling {@link #addTransform} repeatedly.  This function
- * accepts a map of one or more transform names to their transform function.
- * @param {{}} map A map of transform names to transform functions
- */
-Jexl.prototype.addTransforms = function(map) {
-	for (var key in map) {
-		if (map.hasOwnProperty(key))
-			this._transforms[key] = map[key];
-	}
-};
-
-/**
- * Retrieves a previously set transform function.
- * @param {string} name The name of the transform function
- * @returns {function} The transform function
- */
-Jexl.prototype.getTransform = function(name) {
-	return this._transforms[name];
-};
-
-/**
- * Evaluates a Jexl string within an optional context.
- * @param {string} expression The Jexl expression to be evaluated
- * @param {Object} [context] A mapping of variables to values, which will be
- *      made accessible to the Jexl expression when evaluating it
- * @param {function} [cb] An optional callback function to be executed when
- *      evaluation is complete.  It will be supplied with two arguments:
- *          - {Error|null} err: Present if an error occurred
- *          - {*} result: The result of the evaluation
- * @returns {Promise<*>} resolves with the result of the evaluation.  Note that
- *      if a callback is supplied, the returned promise will already have
- *      a '.catch' attached to it in order to pass the error to the callback.
- */
-Jexl.prototype.eval = function(expression, context, cb) {
-	if (typeof context === 'function') {
-		cb = context;
-		context = {};
-	}
-	else if (!context)
-		context = {};
-	var valPromise = this._eval(expression, context);
-	if (cb) {
-		// setTimeout is used for the callback to break out of the Promise's
-		// try/catch in case the callback throws.
-		var called = false;
-		return valPromise.then(function(val) {
-			called = true;
-			setTimeout(cb.bind(null, null, val), 0);
-		}).catch(function(err) {
-			if (!called)
-				setTimeout(cb.bind(null, err), 0);
-		});
-	}
-	return valPromise;
-};
-
-/**
- * Removes a binary or unary operator from the Jexl grammar.
- * @param {string} operator The operator string to be removed
- */
-Jexl.prototype.removeOp = function(operator) {
-	var grammar = this._getCustomGrammar();
-	if (grammar[operator] && (grammar[operator].type == 'binaryOp' ||
-			grammar[operator].type == 'unaryOp')) {
-		delete grammar[operator];
-		this._lexer = null;
-	}
-};
-
-/**
- * Adds an element to the grammar map used by this Jexl instance, cloning
- * the default grammar first if necessary.
- * @param {string} str The key string to be added
- * @param {{type: <string>}} obj A map of configuration options for this
- *      grammar element
- * @private
- */
-Jexl.prototype._addGrammarElement = function(str, obj) {
-	var grammar = this._getCustomGrammar();
-	grammar[str] = obj;
-	this._lexer = null;
-};
-
-/**
- * Evaluates a Jexl string in the given context.
- * @param {string} exp The Jexl expression to be evaluated
- * @param {Object} [context] A mapping of variables to values, which will be
- *      made accessible to the Jexl expression when evaluating it
- * @returns {Promise<*>} resolves with the result of the evaluation.
- * @private
- */
-Jexl.prototype._eval = function(exp, context) {
-	var self = this,
-		grammar = this._getGrammar(),
-		parser = new Parser(grammar),
-		evaluator = new Evaluator(grammar, this._transforms, context);
-	return Promise.resolve().then(function() {
-		parser.addTokens(self._getLexer().tokenize(exp));
-		return evaluator.eval(parser.complete());
-	});
-};
-
-/**
- * Gets the custom grammar object, creating it first if necessary. New custom
- * grammars are created by executing a shallow clone of the default grammar
- * map. The returned map is available to be changed.
- * @returns {{}} a customizable grammar map.
- * @private
- */
-Jexl.prototype._getCustomGrammar = function() {
-	if (!this._customGrammar) {
-		this._customGrammar = {};
-		for (var key in defaultGrammar) {
-			if (defaultGrammar.hasOwnProperty(key))
-				this._customGrammar[key] = defaultGrammar[key];
-		}
-	}
-	return this._customGrammar;
-};
-
-/**
- * Gets the grammar map currently being used by Jexl; either the default map,
- * or a locally customized version. The returned map should never be changed
- * in any way.
- * @returns {{}} the grammar map currently in use.
- * @private
- */
-Jexl.prototype._getGrammar = function() {
-	return this._customGrammar || defaultGrammar;
-};
-
-/**
- * Gets a Lexer instance as a singleton in reference to this Jexl instance.
- * @returns {Lexer} an instance of Lexer, initialized with a grammar
- *      appropriate to this Jexl instance.
- * @private
- */
-Jexl.prototype._getLexer = function() {
-	if (!this._lexer)
-		this._lexer = new Lexer(this._getGrammar());
-	return this._lexer;
-};
-
-module.exports = new Jexl();
-module.exports.Jexl = Jexl;

deleted file mode 100644
--- a/browser/extensions/shield-recipe-client/node_modules/jexl/lib/Lexer.js
+++ /dev/null
@@ -1,244 +0,0 @@
-/*
- * Jexl
- * Copyright (c) 2015 TechnologyAdvice
- */
-
-var numericRegex = /^-?(?:(?:[0-9]*\.[0-9]+)|[0-9]+)$/,
-	identRegex = /^[a-zA-Z_\$][a-zA-Z0-9_\$]*$/,
-	escEscRegex = /\\\\/,
-	preOpRegexElems = [
-		// Strings
-		"'(?:(?:\\\\')?[^'])*'",
-		'"(?:(?:\\\\")?[^"])*"',
-		// Whitespace
-		'\\s+',
-		// Booleans
-		'\\btrue\\b',
-		'\\bfalse\\b'
-	],
-	postOpRegexElems = [
-		// Identifiers
-		'\\b[a-zA-Z_\\$][a-zA-Z0-9_\\$]*\\b',
-		// Numerics (without negative symbol)
-		'(?:(?:[0-9]*\\.[0-9]+)|[0-9]+)'
-	],
-	minusNegatesAfter = ['binaryOp', 'unaryOp', 'openParen', 'openBracket',
-		'question', 'colon'];
-
-/**
- * Lexer is a collection of stateless, statically-accessed functions for the
- * lexical parsing of a Jexl string.  Its responsibility is to identify the
- * "parts of speech" of a Jexl expression, and tokenize and label each, but
- * to do only the most minimal syntax checking; the only errors the Lexer
- * should be concerned with are if it's unable to identify the utility of
- * any of its tokens.  Errors stemming from these tokens not being in a
- * sensible configuration should be left for the Parser to handle.
- * @type {{}}
- */
-function Lexer(grammar) {
-	this._grammar = grammar;
-}
-
-/**
- * Splits a Jexl expression string into an array of expression elements.
- * @param {string} str A Jexl expression string
- * @returns {Array<string>} An array of substrings defining the functional
- *      elements of the expression.
- */
-Lexer.prototype.getElements = function(str) {
-	var regex = this._getSplitRegex();
-	return str.split(regex).filter(function(elem) {
-		// Remove empty strings
-		return elem;
-	});
-};
-
-/**
- * Converts an array of expression elements into an array of tokens.  Note that
- * the resulting array may not equal the element array in length, as any
- * elements that consist only of whitespace get appended to the previous
- * token's "raw" property.  For the structure of a token object, please see
- * {@link Lexer#tokenize}.
- * @param {Array<string>} elements An array of Jexl expression elements to be
- *      converted to tokens
- * @returns {Array<{type, value, raw}>} an array of token objects.
- */
-Lexer.prototype.getTokens = function(elements) {
-	var tokens = [],
-		negate = false;
-	for (var i = 0; i < elements.length; i++) {
-		if (this._isWhitespace(elements[i])) {
-			if (tokens.length)
-				tokens[tokens.length - 1].raw += elements[i];
-		}
-		else if (elements[i] === '-' && this._isNegative(tokens))
-			negate = true;
-		else {
-			if (negate) {
-				elements[i] = '-' + elements[i];
-				negate = false;
-			}
-			tokens.push(this._createToken(elements[i]));
-		}
-	}
-	// Catch a - at the end of the string. Let the parser handle that issue.
-	if (negate)
-		tokens.push(this._createToken('-'));
-	return tokens;
-};
-
-/**
- * Converts a Jexl string into an array of tokens.  Each token is an object
- * in the following format:
- *
- *     {
- *         type: <string>,
- *         [name]: <string>,
- *         value: <boolean|number|string>,
- *         raw: <string>
- *     }
- *
- * Type is one of the following:
- *
- *      literal, identifier, binaryOp, unaryOp
- *
- * OR, if the token is a control character its type is the name of the element
- * defined in the Grammar.
- *
- * Name appears only if the token is a control string found in
- * {@link grammar#elements}, and is set to the name of the element.
- *
- * Value is the value of the token in the correct type (boolean or numeric as
- * appropriate). Raw is the string representation of this value taken directly
- * from the expression string, including any trailing spaces.
- * @param {string} str The Jexl string to be tokenized
- * @returns {Array<{type, value, raw}>} an array of token objects.
- * @throws {Error} if the provided string contains an invalid token.
- */
-Lexer.prototype.tokenize = function(str) {
-	var elements = this.getElements(str);
-	return this.getTokens(elements);
-};
-
-/**
- * Creates a new token object from an element of a Jexl string. See
- * {@link Lexer#tokenize} for a description of the token object.
- * @param {string} element The element from which a token should be made
- * @returns {{value: number|boolean|string, [name]: string, type: string,
- *      raw: string}} a token object describing the provided element.
- * @throws {Error} if the provided string is not a valid expression element.
- * @private
- */
-Lexer.prototype._createToken = function(element) {
-	var token = {
-		type: 'literal',
-		value: element,
-		raw: element
-	};
-	if (element[0] == '"' || element[0] == "'")
-		token.value = this._unquote(element);
-	else if (element.match(numericRegex))
-		token.value = parseFloat(element);
-	else if (element === 'true' || element === 'false')
-		token.value = element === 'true';
-	else if (this._grammar[element])
-		token.type = this._grammar[element].type;
-	else if (element.match(identRegex))
-		token.type = 'identifier';
-	else
-		throw new Error("Invalid expression token: " + element);
-	return token;
-};
-
-/**
- * Escapes a string so that it can be treated as a string literal within a
- * regular expression.
- * @param {string} str The string to be escaped
- * @returns {string} the RegExp-escaped string.
- * @see https://developer.mozilla.org/en/docs/Web/JavaScript/Guide/Regular_Expressions
- * @private
- */
-Lexer.prototype._escapeRegExp = function(str) {
-	str = str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-	if (str.match(identRegex))
-		str = '\\b' + str + '\\b';
-	return str;
-};
-
-/**
- * Gets a RegEx object appropriate for splitting a Jexl string into its core
- * elements.
- * @returns {RegExp} An element-splitting RegExp object
- * @private
- */
-Lexer.prototype._getSplitRegex = function() {
-	if (!this._splitRegex) {
-		var elemArray = Object.keys(this._grammar);
-		// Sort by most characters to least, then regex escape each
-		elemArray = elemArray.sort(function(a ,b) {
-			return b.length - a.length;
-		}).map(function(elem) {
-			return this._escapeRegExp(elem);
-		}, this);
-		this._splitRegex = new RegExp('(' + [
-			preOpRegexElems.join('|'),
-			elemArray.join('|'),
-			postOpRegexElems.join('|')
-		].join('|') + ')');
-	}
-	return this._splitRegex;
-};
-
-/**
- * Determines whether the addition of a '-' token should be interpreted as a
- * negative symbol for an upcoming number, given an array of tokens already
- * processed.
- * @param {Array<Object>} tokens An array of tokens already processed
- * @returns {boolean} true if adding a '-' should be considered a negative
- *      symbol; false otherwise
- * @private
- */
-Lexer.prototype._isNegative = function(tokens) {
-	if (!tokens.length)
-		return true;
-	return minusNegatesAfter.some(function(type) {
-		return type === tokens[tokens.length - 1].type;
-	});
-};
-
-/**
- * A utility function to determine if a string consists of only space
- * characters.
- * @param {string} str A string to be tested
- * @returns {boolean} true if the string is empty or consists of only spaces;
- *      false otherwise.
- * @private
- */
-Lexer.prototype._isWhitespace = function(str) {
-	for (var i = 0; i < str.length; i++) {
-		if (str[i] != ' ')
-			return false;
-	}
-	return true;
-};
-
-/**
- * Removes the beginning and trailing quotes from a string, unescapes any
- * escaped quotes on its interior, and unescapes any escaped escape characters.
- * Note that this function is not defensive; it assumes that the provided
- * string is not empty, and that its first and last characters are actually
- * quotes.
- * @param {string} str A string whose first and last characters are quotes
- * @returns {string} a string with the surrounding quotes stripped and escapes
- *      properly processed.
- * @private
- */
-Lexer.prototype._unquote = function(str) {
-	var quote = str[0],
-		escQuoteRegex = new RegExp('\\\\' + quote, 'g');
-	return str.substr(1, str.length - 2)
-		.replace(escQuoteRegex, quote)
-		.replace(escEscRegex, '\\');
-};
-
-module.exports = Lexer;

deleted file mode 100644
--- a/browser/extensions/shield-recipe-client/node_modules/jexl/lib/evaluator/Evaluator.js
+++ /dev/null
@@ -1,153 +0,0 @@
-/*
- * Jexl
- * Copyright (c) 2015 TechnologyAdvice
- */
-
-var handlers = require('./handlers');
-
-/**
- * The Evaluator takes a Jexl expression tree as generated by the
- * {@link Parser} and calculates its value within a given context. The
- * collection of transforms, context, and a relative context to be used as the
- * root for relative identifiers, are all specific to an Evaluator instance.
- * When any of these things change, a new instance is required.  However, a
- * single instance can be used to simultaneously evaluate many different
- * expressions, and does not have to be reinstantiated for each.
- * @param {{}} grammar A grammar map against which to evaluate the expression
- *      tree
- * @param {{}} [transforms] A map of transform names to transform functions. A
- *      transform function takes two arguments:
- *          - {*} val: A value to be transformed
- *          - {{}} args: A map of argument keys to their evaluated values, as
- *              specified in the expression string
- *      The transform function should return either the transformed value, or
- *      a Promises/A+ Promise object that resolves with the value and rejects
- *      or throws only when an unrecoverable error occurs. Transforms should
- *      generally return undefined when they don't make sense to be used on the
- *      given value type, rather than throw/reject. An error is only
- *      appropriate when the transform would normally return a value, but
- *      cannot due to some other failure.
- * @param {{}} [context] A map of variable keys to their values. This will be
- *      accessed to resolve the value of each non-relative identifier. Any
- *      Promise values will be passed to the expression as their resolved
- *      value.
- * @param {{}|Array<{}|Array>} [relativeContext] A map or array to be accessed
- *      to resolve the value of a relative identifier.
- * @constructor
- */
-var Evaluator = function(grammar, transforms, context, relativeContext) {
-	this._grammar = grammar;
-	this._transforms = transforms || {};
-	this._context = context || {};
-	this._relContext = relativeContext || this._context;
-};
-
-/**
- * Evaluates an expression tree within the configured context.
- * @param {{}} ast An expression tree object
- * @returns {Promise<*>} resolves with the resulting value of the expression.
- */
-Evaluator.prototype.eval = function(ast) {
-	var self = this;
-	return Promise.resolve().then(function() {
-		return handlers[ast.type].call(self, ast);
-	});
-};
-
-/**
- * Simultaneously evaluates each expression within an array, and delivers the
- * response as an array with the resulting values at the same indexes as their
- * originating expressions.
- * @param {Array<string>} arr An array of expression strings to be evaluated
- * @returns {Promise<Array<{}>>} resolves with the result array
- */
-Evaluator.prototype.evalArray = function(arr) {
-	return Promise.all(arr.map(function(elem) {
-		return this.eval(elem);
-	}, this));
-};
-
-/**
- * Simultaneously evaluates each expression within a map, and delivers the
- * response as a map with the same keys, but with the evaluated result for each
- * as their value.
- * @param {{}} map A map of expression names to expression trees to be
- *      evaluated
- * @returns {Promise<{}>} resolves with the result map.
- */
-Evaluator.prototype.evalMap = function(map) {
-	var keys = Object.keys(map),
-		result = {};
-	var asts = keys.map(function(key) {
-		return this.eval(map[key]);
-	}, this);
-	return Promise.all(asts).then(function(vals) {
-		vals.forEach(function(val, idx) {
-			result[keys[idx]] = val;
-		});
-		return result;
-	});
-};
-
-/**
- * Applies a filter expression with relative identifier elements to a subject.
- * The intent is for the subject to be an array of subjects that will be
- * individually used as the relative context against the provided expression
- * tree. Only the elements whose expressions result in a truthy value will be
- * included in the resulting array.
- *
- * If the subject is not an array of values, it will be converted to a single-
- * element array before running the filter.
- * @param {*} subject The value to be filtered; usually an array. If this value is
- *      not an array, it will be converted to an array with this value as the
- *      only element.
- * @param {{}} expr The expression tree to run against each subject. If the
- *      tree evaluates to a truthy result, then the value will be included in
- *      the returned array; otherwise, it will be eliminated.
- * @returns {Promise<Array>} resolves with an array of values that passed the
- *      expression filter.
- * @private
- */
-Evaluator.prototype._filterRelative = function(subject, expr) {
-	var promises = [];
-	if (!Array.isArray(subject))
-		subject = [subject];
-	subject.forEach(function(elem) {
-		var evalInst = new Evaluator(this._grammar, this._transforms,
-			this._context, elem);
-		promises.push(evalInst.eval(expr));
-	}, this);
-	return Promise.all(promises).then(function(values) {
-		var results = [];
-		values.forEach(function(value, idx) {
-			if (value)
-				results.push(subject[idx]);
-		});
-		return results;
-	});
-};
-
-/**
- * Applies a static filter expression to a subject value.  If the filter
- * expression evaluates to boolean true, the subject is returned; if false,
- * undefined.
- *
- * For any other resulting value of the expression, this function will attempt
- * to respond with the property at that name or index of the subject.
- * @param {*} subject The value to be filtered.  Usually an Array (for which
- *      the expression would generally resolve to a numeric index) or an
- *      Object (for which the expression would generally resolve to a string
- *      indicating a property name)
- * @param {{}} expr The expression tree to run against the subject
- * @returns {Promise<*>} resolves with the value of the drill-down.
- * @private
- */
-Evaluator.prototype._filterStatic = function(subject, expr) {
-	return this.eval(expr).then(function(res) {
-		if (typeof res === 'boolean')
-			return res ? subject : undefined;
-		return subject[res];
-	});
-};
-
-module.exports = Evaluator;

deleted file mode 100644
--- a/browser/extensions/shield-recipe-client/node_modules/jexl/lib/evaluator/handlers.js
+++ /dev/null
@@ -1,159 +0,0 @@
-/*
- * Jexl
- * Copyright (c) 2015 TechnologyAdvice
- */
-
-/**
- * Evaluates an ArrayLiteral by returning its value, with each element
- * independently run through the evaluator.
- * @param {{type: 'ObjectLiteral', value: <{}>}} ast An expression tree with an
- *      ObjectLiteral as the top node
- * @returns {Promise.<[]>} resolves to a map contained evaluated values.
- * @private
- */
-exports.ArrayLiteral = function(ast) {
-	return this.evalArray(ast.value);
-};
-
-/**
- * Evaluates a BinaryExpression node by running the Grammar's evaluator for
- * the given operator.
- * @param {{type: 'BinaryExpression', operator: <string>, left: {},
- *      right: {}}} ast An expression tree with a BinaryExpression as the top
- *      node
- * @returns {Promise<*>} resolves with the value of the BinaryExpression.
- * @private
- */
-exports.BinaryExpression = function(ast) {
-	var self = this;
-	return Promise.all([
-		this.eval(ast.left),
-		this.eval(ast.right)
-	]).then(function(arr) {
-		return self._grammar[ast.operator].eval(arr[0], arr[1]);
-	});
-};
-
-/**
- * Evaluates a ConditionalExpression node by first evaluating its test branch,
- * and resolving with the consequent branch if the test is truthy, or the
- * alternate branch if it is not. If there is no consequent branch, the test
- * result will be used instead.
- * @param {{type: 'ConditionalExpression', test: {}, consequent: {},
- *      alternate: {}}} ast An expression tree with a ConditionalExpression as
- *      the top node
- * @private
- */
-exports.ConditionalExpression = function(ast) {
-	var self = this;
-	return this.eval(ast.test).then(function(res) {
-		if (res) {
-			if (ast.consequent)
-				return self.eval(ast.consequent);
-			return res;
-		}
-		return self.eval(ast.alternate);
-	});
-};
-
-/**
- * Evaluates a FilterExpression by applying it to the subject value.
- * @param {{type: 'FilterExpression', relative: <boolean>, expr: {},
- *      subject: {}}} ast An expression tree with a FilterExpression as the top
- *      node
- * @returns {Promise<*>} resolves with the value of the FilterExpression.
- * @private
- */
-exports.FilterExpression = function(ast) {
-	var self = this;
-	return this.eval(ast.subject).then(function(subject) {
-		if (ast.relative)
-			return self._filterRelative(subject, ast.expr);
-		return self._filterStatic(subject, ast.expr);
-	});
-};
-
-/**
- * Evaluates an Identifier by either stemming from the evaluated 'from'
- * expression tree or accessing the context provided when this Evaluator was
- * constructed.
- * @param {{type: 'Identifier', value: <string>, [from]: {}}} ast An expression
- *      tree with an Identifier as the top node
- * @returns {Promise<*>|*} either the identifier's value, or a Promise that
- *      will resolve with the identifier's value.
- * @private
- */
-exports.Identifier = function(ast) {
-	if (ast.from) {
-		return this.eval(ast.from).then(function(context) {
-			if (context === undefined)
-				return undefined;
-			if (Array.isArray(context))
-				context = context[0];
-			return context[ast.value];
-		});
-	}
-	else {
-		return ast.relative ? this._relContext[ast.value] :
-			this._context[ast.value];
-	}
-};
-
-/**
- * Evaluates a Literal by returning its value property.
- * @param {{type: 'Literal', value: <string|number|boolean>}} ast An expression
- *      tree with a Literal as its only node
- * @returns {string|number|boolean} The value of the Literal node
- * @private
- */
-exports.Literal = function(ast) {
-	return ast.value;
-};
-
-/**
- * Evaluates an ObjectLiteral by returning its value, with each key
- * independently run through the evaluator.
- * @param {{type: 'ObjectLiteral', value: <{}>}} ast An expression tree with an
- *      ObjectLiteral as the top node
- * @returns {Promise<{}>} resolves to a map contained evaluated values.
- * @private
- */
-exports.ObjectLiteral = function(ast) {
-	return this.evalMap(ast.value);
-};
-
-/**
- * Evaluates a Transform node by applying a function from the transforms map
- * to the subject value.
- * @param {{type: 'Transform', name: <string>, subject: {}}} ast An
- *      expression tree with a Transform as the top node
- * @returns {Promise<*>|*} the value of the transformation, or a Promise that
- *      will resolve with the transformed value.
- * @private
- */
-exports.Transform = function(ast) {
-	var transform = this._transforms[ast.name];
-	if (!transform)
-		throw new Error("Transform '" + ast.name + "' is not defined.");
-	return Promise.all([
-		this.eval(ast.subject),
-		this.evalArray(ast.args || [])
-	]).then(function(arr) {
-		return transform.apply(null, [arr[0]].concat(arr[1]));
-	});
-};
-
-/**
- * Evaluates a Unary expression by passing the right side through the
- * operator's eval function.
- * @param {{type: 'UnaryExpression', operator: <string>, right: {}}} ast An
- *      expression tree with a UnaryExpression as the top node
- * @returns {Promise<*>} resolves with the value of the UnaryExpression.
- * @constructor
- */
-exports.UnaryExpression = function(ast) {
-	var self = this;
-	return this.eval(ast.right).then(function(right) {
-		return self._grammar[ast.operator].eval(right);
-	});
-};