summaryrefslogtreecommitdiffstats
path: root/toolkit/components/thumbnails/BackgroundPageThumbs.sys.mjs
diff options
context:
space:
mode:
Diffstat (limited to 'toolkit/components/thumbnails/BackgroundPageThumbs.sys.mjs')
-rw-r--r--toolkit/components/thumbnails/BackgroundPageThumbs.sys.mjs789
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);
+}