Adding upstream version 124.0.1.upstream/124.0.1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 789 insertions, 0 deletions

diff --git a/toolkit/components/thumbnails/BackgroundPageThumbs.sys.mjs b/toolkit/components/thumbnails/BackgroundPageThumbs.sys.mjs
new file mode 100644
index 0000000000..8467653acb
--- /dev/null
+++ b/toolkit/components/thumbnails/BackgroundPageThumbs.sys.mjs
@@ -0,0 +1,789 @@
+/* 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/. */
+
+const DEFAULT_CAPTURE_TIMEOUT = 30000; // ms
+// For testing, the above timeout is excessive, and makes our tests overlong.
+const TESTING_CAPTURE_TIMEOUT = 5000; // ms
+
+const DESTROY_BROWSER_TIMEOUT = 60000; // ms
+
+// Let the page settle for this amount of milliseconds before capturing to allow
+// for any in-page changes or redirects.
+const SETTLE_WAIT_TIME = 2500;
+// For testing, the above timeout is excessive, and makes our tests overlong.
+const TESTING_SETTLE_WAIT_TIME = 0;
+
+const TELEMETRY_HISTOGRAM_ID_PREFIX = "FX_THUMBNAILS_BG_";
+
+const ABOUT_NEWTAB_SEGREGATION_PREF =
+  "privacy.usercontext.about_newtab_segregation.enabled";
+
+import {
+  PageThumbs,
+  PageThumbsStorage,
+} from "resource://gre/modules/PageThumbs.sys.mjs";
+
+// possible FX_THUMBNAILS_BG_CAPTURE_DONE_REASON_2 telemetry values
+const TEL_CAPTURE_DONE_OK = 0;
+const TEL_CAPTURE_DONE_TIMEOUT = 1;
+// 2 and 3 were used when we had special handling for private-browsing.
+const TEL_CAPTURE_DONE_CRASHED = 4;
+const TEL_CAPTURE_DONE_BAD_URI = 5;
+const TEL_CAPTURE_DONE_LOAD_FAILED = 6;
+const TEL_CAPTURE_DONE_IMAGE_ZERO_DIMENSION = 7;
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  ContextualIdentityService:
+    "resource://gre/modules/ContextualIdentityService.sys.mjs",
+});
+
+export const BackgroundPageThumbs = {
+  /**
+   * Asynchronously captures a thumbnail of the given URL.
+   *
+   * The page is loaded anonymously, and plug-ins are disabled.
+   *
+   * @param url      The URL to capture.
+   * @param options  An optional object that configures the capture.  Its
+   *                 properties are the following, and all are optional:
+   * @opt onDone     A function that will be asynchronously called when the
+   *                 capture is complete or times out.  It's called as
+   *                   onDone(url),
+   *                 where `url` is the captured URL.
+   * @opt timeout    The capture will time out after this many milliseconds have
+   *                 elapsed after the capture has progressed to the head of
+   *                 the queue and started.  Defaults to 30000 (30 seconds).
+   * @opt isImage    If true, backgroundPageThumbsContent will attempt to render
+   *                 the url directly to canvas. Note that images will mostly get
+   *                 detected and rendered as such anyway, but this will ensure it.
+   * @opt targetWidth The target width when capturing an image.
+   * @opt backgroundColor The background colour when capturing an image.
+   * @opt dontStore  If set to true, the image blob won't be stored to disk, an
+   *                 object will instead be passed as third argument to onDone:
+   *                 {
+   *                   data: an ArrayBuffer containing the data
+   *                   contentType: the data content-type
+   *                   originalUrl: the originally requested url
+   *                   currentUrl: the final url after redirects
+   *                 }
+   * @opt contentType can be set to an image contentType for the capture,
+   *                  defaults to PageThumbs.contentType.
+   */
+  capture(url, options = {}) {
+    if (!PageThumbs._prefEnabled()) {
+      if (options.onDone) {
+        schedule(() => options.onDone(url));
+      }
+      return;
+    }
+    this._captureQueue = this._captureQueue || [];
+    this._capturesByURL = this._capturesByURL || new Map();
+
+    tel("QUEUE_SIZE_ON_CAPTURE", this._captureQueue.length);
+
+    // We want to avoid duplicate captures for the same URL.  If there is an
+    // existing one, we just add the callback to that one and we are done.
+    let existing = this._capturesByURL.get(url);
+    if (existing) {
+      if (options.onDone) {
+        existing.doneCallbacks.push(options.onDone);
+      }
+      // The queue is already being processed, so nothing else to do...
+      return;
+    }
+    let cap = new Capture(url, this._onCaptureOrTimeout.bind(this), options);
+    this._captureQueue.push(cap);
+    this._capturesByURL.set(url, cap);
+    this._processCaptureQueue();
+  },
+
+  /**
+   * Asynchronously captures a thumbnail of the given URL if one does not
+   * already exist.  Otherwise does nothing.
+   *
+   * @param url      The URL to capture.
+   * @param options  An optional object that configures the capture.  See
+   *                 capture() for description.
+   *   unloadingPromise This option is resolved when the calling context is
+   *                    unloading, so things can be cleaned up to avoid leak.
+   * @return {Promise} A Promise that resolves when this task completes
+   */
+  async captureIfMissing(url, options = {}) {
+    // Short circuit this function if pref is enabled, or else we leak observers.
+    // See Bug 1400562
+    if (!PageThumbs._prefEnabled()) {
+      if (options.onDone) {
+        options.onDone(url);
+      }
+      return url;
+    }
+    // The fileExistsForURL call is an optimization, potentially but unlikely
+    // incorrect, and no big deal when it is.  After the capture is done, we
+    // atomically test whether the file exists before writing it.
+    let exists = await PageThumbsStorage.fileExistsForURL(url);
+    if (exists) {
+      if (options.onDone) {
+        options.onDone(url);
+      }
+      return url;
+    }
+    let thumbPromise = new Promise((resolve, reject) => {
+      let observe = (subject, topic, data) => {
+        if (data === url) {
+          switch (topic) {
+            case "page-thumbnail:create":
+              resolve();
+              break;
+            case "page-thumbnail:error":
+              reject(new Error("page-thumbnail:error"));
+              break;
+          }
+          cleanup();
+        }
+      };
+      Services.obs.addObserver(observe, "page-thumbnail:create");
+      Services.obs.addObserver(observe, "page-thumbnail:error");
+
+      // Make sure to clean up to avoid leaks by removing observers when
+      // observed or when our caller is unloading
+      function cleanup() {
+        if (observe) {
+          Services.obs.removeObserver(observe, "page-thumbnail:create");
+          Services.obs.removeObserver(observe, "page-thumbnail:error");
+          observe = null;
+        }
+      }
+      if (options.unloadingPromise) {
+        options.unloadingPromise.then(cleanup);
+      }
+    });
+    try {
+      this.capture(url, options);
+      await thumbPromise;
+    } catch (err) {
+      if (options.onDone) {
+        options.onDone(url);
+      }
+      throw err;
+    }
+    return url;
+  },
+
+  /**
+   * Tell the service that the thumbnail browser should be recreated at next
+   * call of _ensureBrowser().
+   */
+  renewThumbnailBrowser() {
+    this._renewThumbBrowser = true;
+  },
+
+  get useFissionBrowser() {
+    return Services.appinfo.fissionAutostart;
+  },
+
+  /**
+   * Ensures that initialization of the thumbnail browser's parent window has
+   * begun.
+   *
+   * @return  True if the parent window is completely initialized and can be
+   *          used, and false if initialization has started but not completed.
+   */
+  _ensureParentWindowReady() {
+    if (this._parentWin) {
+      // Already fully initialized.
+      return true;
+    }
+    if (this._startedParentWinInit) {
+      // Already started initializing.
+      return false;
+    }
+
+    this._startedParentWinInit = true;
+
+    // Create a windowless browser and load our hosting
+    // (privileged) document in it.
+    const flags = this.useFissionBrowser
+      ? Ci.nsIWebBrowserChrome.CHROME_REMOTE_WINDOW |
+        Ci.nsIWebBrowserChrome.CHROME_FISSION_WINDOW
+      : 0;
+    let wlBrowser = Services.appShell.createWindowlessBrowser(true, flags);
+    wlBrowser.QueryInterface(Ci.nsIInterfaceRequestor);
+    let webProgress = wlBrowser.getInterface(Ci.nsIWebProgress);
+    this._listener = {
+      QueryInterface: ChromeUtils.generateQI([
+        "nsIWebProgressListener",
+        "nsIWebProgressListener2",
+        "nsISupportsWeakReference",
+      ]),
+    };
+    this._listener.onStateChange = (wbp, request, stateFlags, status) => {
+      if (!request) {
+        return;
+      }
+      if (
+        stateFlags & Ci.nsIWebProgressListener.STATE_STOP &&
+        stateFlags & Ci.nsIWebProgressListener.STATE_IS_NETWORK
+      ) {
+        webProgress.removeProgressListener(this._listener);
+        delete this._listener;
+        // Get the window reference via the document.
+        this._parentWin = wlBrowser.document.defaultView;
+        this._processCaptureQueue();
+      }
+    };
+    webProgress.addProgressListener(
+      this._listener,
+      Ci.nsIWebProgress.NOTIFY_STATE_ALL
+    );
+    let loadURIOptions = {
+      triggeringPrincipal: Services.scriptSecurityManager.getSystemPrincipal(),
+    };
+    wlBrowser.loadURI(
+      Services.io.newURI("chrome://global/content/backgroundPageThumbs.xhtml"),
+      loadURIOptions
+    );
+    this._windowlessContainer = wlBrowser;
+
+    return false;
+  },
+
+  _init() {
+    Services.prefs.addObserver(ABOUT_NEWTAB_SEGREGATION_PREF, this);
+    Services.obs.addObserver(this, "profile-before-change");
+  },
+
+  observe(subject, topic, data) {
+    if (topic == "profile-before-change") {
+      this._destroy();
+    } else if (
+      topic == "nsPref:changed" &&
+      data == ABOUT_NEWTAB_SEGREGATION_PREF
+    ) {
+      BackgroundPageThumbs.renewThumbnailBrowser();
+    }
+  },
+
+  /**
+   * Destroys the service.  Queued and pending captures will never complete, and
+   * their consumer callbacks will never be called.
+   */
+  _destroy() {
+    if (this._captureQueue) {
+      this._captureQueue.forEach(cap => cap.destroy());
+    }
+    this._destroyBrowser();
+    if (this._windowlessContainer) {
+      this._windowlessContainer.close();
+    }
+    delete this._captureQueue;
+    delete this._windowlessContainer;
+    delete this._startedParentWinInit;
+    delete this._parentWin;
+    delete this._listener;
+  },
+
+  QueryInterface: ChromeUtils.generateQI([
+    Ci.nsIWebProgressListener,
+    Ci.nsIWebProgressListener2,
+    Ci.nsISupportsWeakReference,
+  ]),
+
+  onStateChange(wbp, request, stateFlags, status) {
+    if (!request || !wbp.isTopLevel) {
+      return;
+    }
+
+    if (
+      stateFlags & Ci.nsIWebProgressListener.STATE_STOP &&
+      stateFlags & Ci.nsIWebProgressListener.STATE_IS_NETWORK
+    ) {
+      // If about:blank is being loaded after a capture, move on
+      // to the next capture, otherwise ignore about:blank loads.
+      if (
+        request instanceof Ci.nsIChannel &&
+        request.URI.spec == "about:blank"
+      ) {
+        if (this._expectingAboutBlank) {
+          this._expectingAboutBlank = false;
+          if (this._captureQueue.length) {
+            this._processCaptureQueue();
+          }
+        }
+        return;
+      }
+
+      if (!this._captureQueue.length) {
+        return;
+      }
+
+      let currentCapture = this._captureQueue[0];
+      if (
+        Components.isSuccessCode(status) ||
+        status === Cr.NS_BINDING_ABORTED
+      ) {
+        this._thumbBrowser.ownerGlobal.requestIdleCallback(() => {
+          currentCapture.pageLoaded(this._thumbBrowser);
+        });
+      } else {
+        currentCapture._done(
+          this._thumbBrowser,
+          null,
+          currentCapture.timedOut
+            ? TEL_CAPTURE_DONE_TIMEOUT
+            : TEL_CAPTURE_DONE_LOAD_FAILED
+        );
+      }
+    }
+  },
+
+  /**
+   * Creates the thumbnail browser if it doesn't already exist.
+   */
+  _ensureBrowser() {
+    if (this._thumbBrowser && !this._renewThumbBrowser) {
+      return;
+    }
+
+    this._destroyBrowser();
+    this._renewThumbBrowser = false;
+
+    let browser = this._parentWin.document.createXULElement("browser");
+    browser.setAttribute("type", "content");
+    browser.setAttribute("remote", "true");
+    if (this.useFissionBrowser) {
+      browser.setAttribute("maychangeremoteness", "true");
+    }
+    browser.setAttribute("disableglobalhistory", "true");
+    browser.setAttribute("messagemanagergroup", "thumbnails");
+    browser.setAttribute("manualactiveness", "true");
+
+    if (Services.prefs.getBoolPref(ABOUT_NEWTAB_SEGREGATION_PREF)) {
+      // Use the private container for thumbnails.
+      let privateIdentity = lazy.ContextualIdentityService.getPrivateIdentity(
+        "userContextIdInternal.thumbnail"
+      );
+      browser.setAttribute("usercontextid", privateIdentity.userContextId);
+    }
+
+    // Size the browser.  Make its aspect ratio the same as the canvases' that
+    // the thumbnails are drawn into; the canvases' aspect ratio is the same as
+    // the screen's, so use that.  Aim for a size in the ballpark of 1024x768.
+    let [swidth, sheight] = [{}, {}];
+    Cc["@mozilla.org/gfx/screenmanager;1"]
+      .getService(Ci.nsIScreenManager)
+      .primaryScreen.GetRectDisplayPix({}, {}, swidth, sheight);
+    let bwidth = Math.min(1024, swidth.value);
+    // Setting the width and height attributes doesn't work -- the resulting
+    // thumbnails are blank and transparent -- but setting the style does.
+    browser.style.width = bwidth + "px";
+    browser.style.height = (bwidth * sheight.value) / swidth.value + "px";
+    browser.style.colorScheme = "env(-moz-content-preferred-color-scheme)";
+
+    this._parentWin.document.documentElement.appendChild(browser);
+
+    browser.addProgressListener(this, Ci.nsIWebProgress.NOTIFY_STATE_WINDOW);
+    browser.mute();
+
+    // an event that is sent if the remote process crashes - no need to remove
+    // it as we want it to be there as long as the browser itself lives.
+    browser.addEventListener("oop-browser-crashed", event => {
+      if (!event.isTopFrame) {
+        // It was a subframe that crashed. We'll ignore this.
+        return;
+      }
+
+      console.error("BackgroundThumbnails remote process crashed - recovering");
+      this._destroyBrowser();
+      let curCapture = this._captureQueue.length ? this._captureQueue[0] : null;
+      // we could retry the pending capture, but it's possible the crash
+      // was due directly to it, so trying again might just crash again.
+      // We could keep a flag to indicate if it previously crashed, but
+      // "resetting" the capture requires more work - so for now, we just
+      // discard it.
+      if (curCapture) {
+        // Continue queue processing by calling curCapture._done().  Do it after
+        // this crashed listener returns, though.  A new browser will be created
+        // immediately (on the same stack as the _done call stack) if there are
+        // any more queued-up captures, and that seems to mess up the new
+        // browser's message manager if it happens on the same stack as the
+        // listener.  Trying to send a message to the manager in that case
+        // throws NS_ERROR_NOT_INITIALIZED.
+        Services.tm.dispatchToMainThread(() => {
+          curCapture._done(browser, null, TEL_CAPTURE_DONE_CRASHED);
+        });
+      }
+      // else: we must have been idle and not currently doing a capture (eg,
+      // maybe a GC or similar crashed) - so there's no need to attempt a
+      // queue restart - the next capture request will set everything up.
+    });
+
+    this._thumbBrowser = browser;
+    browser.docShellIsActive = false;
+  },
+
+  _destroyBrowser() {
+    if (!this._thumbBrowser) {
+      return;
+    }
+    this._expectingAboutBlank = false;
+    this._thumbBrowser.remove();
+    delete this._thumbBrowser;
+  },
+
+  async _loadAboutBlank() {
+    if (this._expectingAboutBlank) {
+      return;
+    }
+
+    this._expectingAboutBlank = true;
+
+    let loadURIOptions = {
+      triggeringPrincipal: Services.scriptSecurityManager.getSystemPrincipal(),
+      loadFlags: Ci.nsIWebNavigation.LOAD_FLAGS_STOP_CONTENT,
+    };
+    this._thumbBrowser.loadURI(
+      Services.io.newURI("about:blank"),
+      loadURIOptions
+    );
+  },
+
+  /**
+   * Starts the next capture if the queue is not empty and the service is fully
+   * initialized.
+   */
+  _processCaptureQueue() {
+    if (!this._captureQueue.length) {
+      if (this._thumbBrowser) {
+        BackgroundPageThumbs._loadAboutBlank();
+      }
+      return;
+    }
+
+    if (
+      this._captureQueue[0].pending ||
+      !this._ensureParentWindowReady() ||
+      this._expectingAboutBlank
+    ) {
+      return;
+    }
+
+    // Ready to start the first capture in the queue.
+    this._ensureBrowser();
+    this._captureQueue[0].start(this._thumbBrowser);
+    if (this._destroyBrowserTimer) {
+      this._destroyBrowserTimer.cancel();
+      delete this._destroyBrowserTimer;
+    }
+  },
+
+  /**
+   * Called when the current capture completes or fails (eg, times out, remote
+   * process crashes.)
+   */
+  _onCaptureOrTimeout(capture, reason) {
+    // Since timeouts start as an item is being processed, only the first
+    // item in the queue can be passed to this method.
+    if (capture !== this._captureQueue[0]) {
+      throw new Error("The capture should be at the head of the queue.");
+    }
+
+    this._captureQueue.shift();
+    this._capturesByURL.delete(capture.url);
+    if (reason != TEL_CAPTURE_DONE_OK) {
+      Services.obs.notifyObservers(null, "page-thumbnail:error", capture.url);
+    }
+
+    // Start the destroy-browser timer *before* processing the capture queue.
+    let timer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer);
+    timer.initWithCallback(
+      this._destroyBrowser.bind(this),
+      this._destroyBrowserTimeout,
+      Ci.nsITimer.TYPE_ONE_SHOT
+    );
+    this._destroyBrowserTimer = timer;
+
+    this._processCaptureQueue();
+  },
+
+  _destroyBrowserTimeout: DESTROY_BROWSER_TIMEOUT,
+};
+
+BackgroundPageThumbs._init();
+
+/**
+ * Represents a single capture request in the capture queue.
+ *
+ * @param url              The URL to capture.
+ * @param captureCallback  A function you want called when the capture
+ *                         completes.
+ * @param options          The capture options.
+ */
+function Capture(url, captureCallback, options) {
+  this.url = url;
+  this.captureCallback = captureCallback;
+  this.redirectTimer = null;
+  this.timedOut = false;
+  this.options = options;
+  this.id = Capture.nextID++;
+  this.creationDate = new Date();
+  this.doneCallbacks = [];
+  if (options.onDone) {
+    this.doneCallbacks.push(options.onDone);
+  }
+}
+
+Capture.prototype = {
+  get pending() {
+    return !!this._timeoutTimer;
+  },
+
+  /**
+   * Sends a message to the content script to start the capture.
+   *
+   * @param browser  The thumbnail browser.
+   */
+  start(browser) {
+    this.startDate = new Date();
+    tel("CAPTURE_QUEUE_TIME_MS", this.startDate - this.creationDate);
+
+    let fallbackTimeout = Cu.isInAutomation
+      ? TESTING_CAPTURE_TIMEOUT
+      : DEFAULT_CAPTURE_TIMEOUT;
+
+    // timeout timer
+    let timeout =
+      typeof this.options.timeout == "number"
+        ? this.options.timeout
+        : fallbackTimeout;
+    this._timeoutTimer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer);
+    this._timeoutTimer.initWithCallback(
+      this,
+      timeout,
+      Ci.nsITimer.TYPE_ONE_SHOT
+    );
+
+    this._browser = browser;
+
+    if (!browser.browsingContext) {
+      return;
+    }
+
+    this._pageLoadStartTime = new Date();
+
+    BackgroundPageThumbs._expectingAboutBlank = false;
+
+    let thumbnailsActor = browser.browsingContext.currentWindowGlobal.getActor(
+      "BackgroundThumbnails"
+    );
+    thumbnailsActor
+      .sendQuery("Browser:Thumbnail:LoadURL", {
+        url: this.url,
+      })
+      .then(
+        success => {
+          // If it failed, then this was likely a bad url. If successful,
+          // BackgroundPageThumbs.onStateChange will call _done() after the
+          // load has completed.
+          if (!success) {
+            this._done(browser, null, TEL_CAPTURE_DONE_BAD_URI);
+          }
+        },
+        failure => {
+          // The query can fail when a crash occurs while loading. The error causes
+          // thumbnail crash tests to fail with an uninteresting error message.
+        }
+      );
+  },
+
+  readBlob: function readBlob(blob) {
+    return new Promise((resolve, reject) => {
+      let reader = new FileReader();
+      reader.onloadend = function onloadend() {
+        if (reader.readyState != FileReader.DONE) {
+          reject(reader.error);
+        } else {
+          resolve(reader.result);
+        }
+      };
+      reader.readAsArrayBuffer(blob);
+    });
+  },
+
+  async pageLoaded(aBrowser) {
+    if (this.timedOut) {
+      this._done(aBrowser, null, TEL_CAPTURE_DONE_TIMEOUT);
+      return;
+    }
+
+    let waitTime = Cu.isInAutomation
+      ? TESTING_SETTLE_WAIT_TIME
+      : SETTLE_WAIT_TIME;
+
+    // There was additional activity, so restart the wait timer
+    if (this.redirectTimer) {
+      this.redirectTimer.delay = waitTime;
+      return;
+    }
+
+    // The requested page has loaded or stopped/aborted, so capture the page
+    // soon but first let it settle in case of in-page redirects
+    await new Promise(resolve => {
+      this.redirectTimer = Cc["@mozilla.org/timer;1"].createInstance(
+        Ci.nsITimer
+      );
+      this.redirectTimer.init(resolve, waitTime, Ci.nsITimer.TYPE_ONE_SHOT);
+    });
+
+    this.redirectTimer = null;
+
+    let pageLoadTime = new Date() - this._pageLoadStartTime;
+    let canvasDrawStartTime = new Date();
+
+    let canvas = PageThumbs.createCanvas(aBrowser.ownerGlobal, 1, 1);
+    try {
+      await PageThumbs.captureToCanvas(
+        aBrowser,
+        canvas,
+        {
+          isBackgroundThumb: true,
+          isImage: this.options.isImage,
+          backgroundColor: this.options.backgroundColor,
+        },
+        true
+      );
+    } catch (ex) {
+      this._done(
+        aBrowser,
+        null,
+        ex == "IMAGE_ZERO_DIMENSION"
+          ? TEL_CAPTURE_DONE_IMAGE_ZERO_DIMENSION
+          : TEL_CAPTURE_DONE_LOAD_FAILED
+      );
+      return;
+    }
+
+    let canvasDrawTime = new Date() - canvasDrawStartTime;
+
+    let contentType =
+      (this.options.dontStore && this.options.contentType) ||
+      PageThumbs.contentType;
+    let imageData = await new Promise(resolve => {
+      canvas.toBlob(blob => {
+        resolve(blob, contentType);
+      }, contentType);
+    });
+
+    this._done(aBrowser, imageData, TEL_CAPTURE_DONE_OK, {
+      CAPTURE_PAGE_LOAD_TIME_MS: pageLoadTime,
+      CAPTURE_CANVAS_DRAW_TIME_MS: canvasDrawTime,
+    });
+  },
+
+  /**
+   * The only intended external use of this method is by the service when it's
+   * uninitializing and doing things like destroying the thumbnail browser.  In
+   * that case the consumer's completion callback will never be called.
+   */
+  destroy() {
+    // This method may be called for captures that haven't started yet, so
+    // guard against not yet having _timeoutTimer, _msgMan etc properties...
+    if (this._timeoutTimer) {
+      this._timeoutTimer.cancel();
+      delete this._timeoutTimer;
+    }
+    delete this.captureCallback;
+    delete this.doneCallbacks;
+    delete this.options;
+  },
+
+  // Called when the timeout timer fires.
+  notify() {
+    this.timedOut = true;
+    this._browser.stop();
+  },
+
+  _done(browser, imageData, reason, telemetry) {
+    // Note that _done will be called only once, by either receiveMessage or
+    // notify, since it calls destroy here, which cancels the timeout timer and
+    // removes the didCapture message listener.
+    let { captureCallback, doneCallbacks, options } = this;
+    this.destroy();
+
+    if (typeof reason != "number") {
+      throw new Error("A done reason must be given.");
+    }
+
+    tel("CAPTURE_DONE_REASON_2", reason);
+
+    if (telemetry) {
+      // Telemetry is currently disabled in the content process (bug 680508).
+      for (let id in telemetry) {
+        tel(id, telemetry[id]);
+      }
+    }
+
+    let done = (info = null) => {
+      captureCallback(this, reason);
+      for (let callback of doneCallbacks) {
+        try {
+          callback.call(options, this.url, reason, info);
+        } catch (err) {
+          console.error(err);
+        }
+      }
+
+      if (Services.prefs.getBoolPref(ABOUT_NEWTAB_SEGREGATION_PREF)) {
+        // Clear the data in the private container for thumbnails.
+        let privateIdentity = lazy.ContextualIdentityService.getPrivateIdentity(
+          "userContextIdInternal.thumbnail"
+        );
+        if (privateIdentity) {
+          Services.clearData.deleteDataFromOriginAttributesPattern({
+            userContextId: privateIdentity.userContextId,
+          });
+        }
+      }
+    };
+
+    if (!imageData) {
+      done();
+      return;
+    }
+
+    this.readBlob(imageData).then(buffer => {
+      if (options.dontStore) {
+        done({
+          data: buffer,
+          originalUrl: this.url,
+          finalUrl: browser.currentURI.spec,
+          contentType: options.contentType || PageThumbs.contentType,
+        });
+      } else {
+        PageThumbs._store(this.url, browser.currentURI.spec, buffer, true).then(
+          done,
+          done
+        );
+      }
+    });
+  },
+};
+
+Capture.nextID = 0;
+
+/**
+ * Adds a value to one of this module's telemetry histograms.
+ *
+ * @param histogramID  This is prefixed with this module's ID.
+ * @param value        The value to add.
+ */
+function tel(histogramID, value) {
+  let id = TELEMETRY_HISTOGRAM_ID_PREFIX + histogramID;
+  Services.telemetry.getHistogramById(id).add(value);
+}
+
+function schedule(callback) {
+  Services.tm.dispatchToMainThread(callback);
+}