Adding upstream version 110.0.1.upstream/110.0.1upstream

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

1 files changed, 809 insertions, 0 deletions

diff --git a/browser/base/content/browser-ctrlTab.js b/browser/base/content/browser-ctrlTab.js
new file mode 100644
index 0000000000..f22e5eac11
--- /dev/null
+++ b/browser/base/content/browser-ctrlTab.js
@@ -0,0 +1,809 @@
+/* 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/. */
+
+// This file is loaded into the browser window scope.
+/* eslint-env mozilla/browser-window */
+
+/**
+ * Tab previews utility, produces thumbnails
+ */
+var tabPreviews = {
+  get aspectRatio() {
+    let { PageThumbUtils } = ChromeUtils.import(
+      "resource://gre/modules/PageThumbUtils.jsm"
+    );
+    let [width, height] = PageThumbUtils.getThumbnailSize(window);
+    delete this.aspectRatio;
+    return (this.aspectRatio = height / width);
+  },
+
+  /**
+   * Get the stored thumbnail URL for a given page URL and wait up to 1s for it
+   * to load. If the browser is discarded and there is no stored thumbnail, the
+   * image URL will fail to load and this method will return null after 1s.
+   * Callers should handle this case by doing nothing or using a fallback image.
+   * @param {String} uri The page URL.
+   * @returns {Promise<Image|null>}
+   */
+  loadImage: async function tabPreviews_loadImage(uri) {
+    let img = new Image();
+    img.src = PageThumbs.getThumbnailURL(uri);
+    if (img.complete && img.naturalWidth) {
+      return img;
+    }
+    return new Promise(resolve => {
+      const controller = new AbortController();
+      img.addEventListener(
+        "load",
+        () => {
+          clearTimeout(timeout);
+          controller.abort();
+          resolve(img);
+        },
+        { signal: controller.signal }
+      );
+      const timeout = setTimeout(() => {
+        controller.abort();
+        resolve(null);
+      }, 1000);
+    });
+  },
+
+  /**
+   * For a given tab, retrieve a preview thumbnail (a canvas or an image) from
+   * storage or capture a new one. If the tab's URL has changed since the
+   * previous call, the thumbnail will be regenerated.
+   * @param {MozTabbrowserTab} aTab The tab to get a preview for.
+   * @returns {Promise<HTMLCanvasElement|Image|null>} Resolves to...
+   * @resolves {HTMLCanvasElement} If a thumbnail can NOT be captured and stored
+   *   for the tab, or if the tab is still loading, a snapshot is taken and
+   *   returned as a canvas. It may be cached as a canvas (separately from
+   *   thumbnail storage) in aTab.__thumbnail if the tab is finished loading. If
+   *   the snapshot CAN be stored as a thumbnail, the snapshot is converted to a
+   *   blob image and drawn in the returned canvas, but the image is added to
+   *   thumbnail storage and cached in aTab.__thumbnail.
+   * @resolves {Image} A cached blob image from a previous thumbnail capture.
+   *   e.g. <img src="moz-page-thumb://thumbnails/?url=foo.com&revision=bar">
+   * @resolves {null} If a thumbnail cannot be captured for any reason (e.g.
+   *   because the tab is discarded) and there is no cached/stored thumbnail.
+   */
+  get: async function tabPreviews_get(aTab) {
+    let browser = aTab.linkedBrowser;
+    let uri = browser.currentURI.spec;
+
+    // Invalidate the cached thumbnail since the tab has changed.
+    if (aTab.__thumbnail_lastURI && aTab.__thumbnail_lastURI != uri) {
+      aTab.__thumbnail = null;
+      aTab.__thumbnail_lastURI = null;
+    }
+
+    // A cached thumbnail (not from thumbnail storage) is available.
+    if (aTab.__thumbnail) {
+      return aTab.__thumbnail;
+    }
+
+    // This means the browser is discarded. Try to load a stored thumbnail, and
+    // use a fallback style otherwise.
+    if (!browser.browsingContext) {
+      return this.loadImage(uri);
+    }
+
+    // Don't cache or store the thumbnail if the tab is still loading.
+    return this.capture(aTab, !aTab.hasAttribute("busy"));
+  },
+
+  /**
+   * For a given tab, capture a preview thumbnail (a canvas), optionally cache
+   * it in aTab.__thumbnail, and possibly store it in thumbnail storage.
+   * @param {MozTabbrowserTab} aTab The tab to capture a preview for.
+   * @param {Boolean} aShouldCache Cache/store the captured thumbnail?
+   * @returns {Promise<HTMLCanvasElement|null>} Resolves to...
+   * @resolves {HTMLCanvasElement} A snapshot of the tab's content. If the
+   *   snapshot is safe for storage and aShouldCache is true, the snapshot is
+   *   converted to a blob image, stored and cached, and drawn in the returned
+   *   canvas. The thumbnail can then be recovered even if the browser is
+   *   discarded. Otherwise, the canvas itself is cached in aTab.__thumbnail.
+   * @resolves {null} If a fatal exception occurred during thumbnail capture.
+   */
+  capture: async function tabPreviews_capture(aTab, aShouldCache) {
+    let browser = aTab.linkedBrowser;
+    let uri = browser.currentURI.spec;
+    let canvas = PageThumbs.createCanvas(window);
+    const doStore = await PageThumbs.shouldStoreThumbnail(browser);
+
+    if (doStore && aShouldCache) {
+      await PageThumbs.captureAndStore(browser);
+      let img = await this.loadImage(uri);
+      if (img) {
+        // Cache the stored blob image for future use.
+        aTab.__thumbnail = img;
+        aTab.__thumbnail_lastURI = uri;
+        // Draw the stored blob image in the canvas.
+        canvas.getContext("2d").drawImage(img, 0, 0);
+      } else {
+        canvas = null;
+      }
+    } else {
+      try {
+        await PageThumbs.captureToCanvas(browser, canvas);
+        if (aShouldCache) {
+          // Cache the canvas itself for future use.
+          aTab.__thumbnail = canvas;
+          aTab.__thumbnail_lastURI = uri;
+        }
+      } catch (error) {
+        console.error(error);
+        canvas = null;
+      }
+    }
+
+    return canvas;
+  },
+};
+
+var tabPreviewPanelHelper = {
+  opening(host) {
+    host.panel.hidden = false;
+
+    var handler = this._generateHandler(host);
+    host.panel.addEventListener("popupshown", handler);
+    host.panel.addEventListener("popuphiding", handler);
+
+    host._prevFocus = document.commandDispatcher.focusedElement;
+  },
+  _generateHandler(host) {
+    var self = this;
+    return function listener(event) {
+      if (event.target == host.panel) {
+        host.panel.removeEventListener(event.type, listener);
+        self["_" + event.type](host);
+      }
+    };
+  },
+  _popupshown(host) {
+    if ("setupGUI" in host) {
+      host.setupGUI();
+    }
+  },
+  _popuphiding(host) {
+    if ("suspendGUI" in host) {
+      host.suspendGUI();
+    }
+
+    if (host._prevFocus) {
+      Services.focus.setFocus(
+        host._prevFocus,
+        Ci.nsIFocusManager.FLAG_NOSCROLL
+      );
+      host._prevFocus = null;
+    } else {
+      gBrowser.selectedBrowser.focus();
+    }
+
+    if (host.tabToSelect) {
+      gBrowser.selectedTab = host.tabToSelect;
+      host.tabToSelect = null;
+    }
+  },
+};
+
+/**
+ * Ctrl-Tab panel
+ */
+var ctrlTab = {
+  maxTabPreviews: 7,
+  get panel() {
+    delete this.panel;
+    return (this.panel = document.getElementById("ctrlTab-panel"));
+  },
+  get showAllButton() {
+    delete this.showAllButton;
+    this.showAllButton = document.createXULElement("button");
+    this.showAllButton.id = "ctrlTab-showAll";
+    this.showAllButton.addEventListener("mouseover", this);
+    this.showAllButton.addEventListener("command", this);
+    this.showAllButton.addEventListener("click", this);
+    document
+      .getElementById("ctrlTab-showAll-container")
+      .appendChild(this.showAllButton);
+    return this.showAllButton;
+  },
+  get previews() {
+    delete this.previews;
+    this.previews = [];
+    let previewsContainer = document.getElementById("ctrlTab-previews");
+    for (let i = 0; i < this.maxTabPreviews; i++) {
+      let preview = this._makePreview();
+      previewsContainer.appendChild(preview);
+      this.previews.push(preview);
+    }
+    this.previews.push(this.showAllButton);
+    return this.previews;
+  },
+  get keys() {
+    var keys = {};
+    ["close", "find", "selectAll"].forEach(function(key) {
+      keys[key] = document
+        .getElementById("key_" + key)
+        .getAttribute("key")
+        .toLocaleLowerCase()
+        .charCodeAt(0);
+    });
+    delete this.keys;
+    return (this.keys = keys);
+  },
+  _selectedIndex: 0,
+  get selected() {
+    return this._selectedIndex < 0
+      ? document.activeElement
+      : this.previews[this._selectedIndex];
+  },
+  get isOpen() {
+    return (
+      this.panel.state == "open" || this.panel.state == "showing" || this._timer
+    );
+  },
+  get tabCount() {
+    return this.tabList.length;
+  },
+  get tabPreviewCount() {
+    return Math.min(this.maxTabPreviews, this.tabCount);
+  },
+
+  get tabList() {
+    return this._recentlyUsedTabs;
+  },
+
+  init: function ctrlTab_init() {
+    if (!this._recentlyUsedTabs) {
+      this._initRecentlyUsedTabs();
+      this._init(true);
+    }
+  },
+
+  uninit: function ctrlTab_uninit() {
+    if (this._recentlyUsedTabs) {
+      this._recentlyUsedTabs = null;
+      this._init(false);
+    }
+  },
+
+  prefName: "browser.ctrlTab.sortByRecentlyUsed",
+  readPref: function ctrlTab_readPref() {
+    var enable =
+      Services.prefs.getBoolPref(this.prefName) &&
+      !Services.prefs.getBoolPref(
+        "browser.ctrlTab.disallowForScreenReaders",
+        false
+      );
+
+    if (enable) {
+      this.init();
+    } else {
+      this.uninit();
+    }
+  },
+  observe(aSubject, aTopic, aPrefName) {
+    this.readPref();
+  },
+
+  _makePreview() {
+    let preview = document.createXULElement("button");
+    preview.className = "ctrlTab-preview";
+    preview.setAttribute("pack", "center");
+    preview.setAttribute("flex", "1");
+    preview.addEventListener("mouseover", this);
+    preview.addEventListener("command", this);
+    preview.addEventListener("click", this);
+
+    let previewInner = document.createXULElement("vbox");
+    previewInner.className = "ctrlTab-preview-inner";
+    preview.appendChild(previewInner);
+
+    let canvas = (preview._canvas = document.createXULElement("hbox"));
+    canvas.className = "ctrlTab-canvas";
+    previewInner.appendChild(canvas);
+
+    let faviconContainer = document.createXULElement("hbox");
+    faviconContainer.className = "ctrlTab-favicon-container";
+    previewInner.appendChild(faviconContainer);
+
+    let favicon = (preview._favicon = document.createXULElement("image"));
+    favicon.className = "ctrlTab-favicon";
+    faviconContainer.appendChild(favicon);
+
+    let label = (preview._label = document.createXULElement("label"));
+    label.className = "ctrlTab-label plain";
+    label.setAttribute("crop", "end");
+    previewInner.appendChild(label);
+
+    return preview;
+  },
+
+  updatePreviews: function ctrlTab_updatePreviews() {
+    for (let i = 0; i < this.previews.length; i++) {
+      this.updatePreview(this.previews[i], this.tabList[i]);
+    }
+
+    var showAllLabel = gNavigatorBundle.getString("ctrlTab.listAllTabs.label");
+    this.showAllButton.label = PluralForm.get(
+      this.tabCount,
+      showAllLabel
+    ).replace("#1", this.tabCount);
+    this.showAllButton.hidden = !gTabsPanel.canOpen;
+  },
+
+  updatePreview: function ctrlTab_updatePreview(aPreview, aTab) {
+    if (aPreview == this.showAllButton) {
+      return;
+    }
+
+    aPreview._tab = aTab;
+
+    if (aTab) {
+      let canvas = aPreview._canvas;
+      let canvasWidth = this.canvasWidth;
+      let canvasHeight = this.canvasHeight;
+      canvas.setAttribute("width", canvasWidth);
+      canvas.style.minWidth = canvasWidth + "px";
+      canvas.style.maxWidth = canvasWidth + "px";
+      canvas.style.minHeight = canvasHeight + "px";
+      canvas.style.maxHeight = canvasHeight + "px";
+      tabPreviews
+        .get(aTab)
+        .then(img => {
+          switch (aPreview._tab) {
+            case aTab:
+              this._clearCanvas(canvas);
+              if (img) {
+                canvas.appendChild(img);
+              }
+              break;
+            case null:
+              // The preview panel is not open, so don't render anything.
+              this._clearCanvas(canvas);
+              break;
+            // If the tab exists but it has changed since updatePreview was
+            // called, the preview will likely be handled by a later
+            // updatePreview call, e.g. on TabAttrModified.
+          }
+        })
+        .catch(error => console.error(error));
+
+      aPreview._label.setAttribute("value", aTab.label);
+      aPreview.setAttribute("tooltiptext", aTab.label);
+      if (aTab.image) {
+        aPreview._favicon.setAttribute("src", aTab.image);
+      } else {
+        aPreview._favicon.removeAttribute("src");
+      }
+      aPreview.hidden = false;
+    } else {
+      this._clearCanvas(aPreview._canvas);
+      aPreview.hidden = true;
+      aPreview._label.removeAttribute("value");
+      aPreview.removeAttribute("tooltiptext");
+      aPreview._favicon.removeAttribute("src");
+    }
+  },
+
+  // Remove previous preview images from the canvas box.
+  _clearCanvas(canvas) {
+    while (canvas.firstElementChild) {
+      canvas.firstElementChild.remove();
+    }
+  },
+
+  advanceFocus: function ctrlTab_advanceFocus(aForward) {
+    let selectedIndex = this.previews.indexOf(this.selected);
+    do {
+      selectedIndex += aForward ? 1 : -1;
+      if (selectedIndex < 0) {
+        selectedIndex = this.previews.length - 1;
+      } else if (selectedIndex >= this.previews.length) {
+        selectedIndex = 0;
+      }
+    } while (this.previews[selectedIndex].hidden);
+
+    if (this._selectedIndex == -1) {
+      // Focus is already in the panel.
+      this.previews[selectedIndex].focus();
+    } else {
+      this._selectedIndex = selectedIndex;
+    }
+
+    if (this.previews[selectedIndex]._tab) {
+      gBrowser.warmupTab(this.previews[selectedIndex]._tab);
+    }
+
+    if (this._timer) {
+      clearTimeout(this._timer);
+      this._timer = null;
+      this._openPanel();
+    }
+  },
+
+  _mouseOverFocus: function ctrlTab_mouseOverFocus(aPreview) {
+    if (this._trackMouseOver) {
+      aPreview.focus();
+    }
+  },
+
+  pick: function ctrlTab_pick(aPreview) {
+    if (!this.tabCount) {
+      return;
+    }
+
+    var select = aPreview || this.selected;
+
+    if (select == this.showAllButton) {
+      this.showAllTabs();
+    } else {
+      this.close(select._tab);
+    }
+  },
+
+  showAllTabs: function ctrlTab_showAllTabs(aPreview) {
+    this.close();
+    document.getElementById("Browser:ShowAllTabs").doCommand();
+  },
+
+  remove: function ctrlTab_remove(aPreview) {
+    if (aPreview._tab) {
+      gBrowser.removeTab(aPreview._tab);
+    }
+  },
+
+  attachTab: function ctrlTab_attachTab(aTab, aPos) {
+    // If the tab is hidden, don't add it to the list unless it's selected
+    // (Normally hidden tabs would be unhidden when selected, but that doesn't
+    // happen for Firefox View).
+    if (aTab.closing || (aTab.hidden && !aTab.selected)) {
+      return;
+    }
+
+    // If the tab is already in the list, remove it before re-inserting it.
+    this.detachTab(aTab);
+
+    if (aPos == 0) {
+      this._recentlyUsedTabs.unshift(aTab);
+    } else if (aPos) {
+      this._recentlyUsedTabs.splice(aPos, 0, aTab);
+    } else {
+      this._recentlyUsedTabs.push(aTab);
+    }
+  },
+
+  detachTab: function ctrlTab_detachTab(aTab) {
+    var i = this._recentlyUsedTabs.indexOf(aTab);
+    if (i >= 0) {
+      this._recentlyUsedTabs.splice(i, 1);
+    }
+  },
+
+  open: function ctrlTab_open() {
+    if (this.isOpen) {
+      return;
+    }
+
+    this.canvasWidth = Math.ceil(
+      (screen.availWidth * 0.85) / this.maxTabPreviews
+    );
+    this.canvasHeight = Math.round(this.canvasWidth * tabPreviews.aspectRatio);
+    this.updatePreviews();
+    this._selectedIndex = 1;
+    gBrowser.warmupTab(this.selected._tab);
+
+    // Add a slight delay before showing the UI, so that a quick
+    // "ctrl-tab" keypress just flips back to the MRU tab.
+    this._timer = setTimeout(() => {
+      this._timer = null;
+      this._openPanel();
+    }, 200);
+  },
+
+  _openPanel: function ctrlTab_openPanel() {
+    tabPreviewPanelHelper.opening(this);
+
+    let width = Math.min(
+      screen.availWidth * 0.99,
+      this.canvasWidth * 1.25 * this.tabPreviewCount
+    );
+    this.panel.style.width = width + "px";
+    var estimateHeight = this.canvasHeight * 1.25 + 75;
+    this.panel.openPopupAtScreen(
+      screen.availLeft + (screen.availWidth - width) / 2,
+      screen.availTop + (screen.availHeight - estimateHeight) / 2,
+      false
+    );
+  },
+
+  close: function ctrlTab_close(aTabToSelect) {
+    if (!this.isOpen) {
+      return;
+    }
+
+    if (this._timer) {
+      clearTimeout(this._timer);
+      this._timer = null;
+      this.suspendGUI();
+      if (aTabToSelect) {
+        gBrowser.selectedTab = aTabToSelect;
+      }
+      return;
+    }
+
+    this.tabToSelect = aTabToSelect;
+    this.panel.hidePopup();
+  },
+
+  setupGUI: function ctrlTab_setupGUI() {
+    this.selected.focus();
+    this._selectedIndex = -1;
+
+    // Track mouse movement after a brief delay so that the item that happens
+    // to be under the mouse pointer initially won't be selected unintentionally.
+    this._trackMouseOver = false;
+    setTimeout(
+      function(self) {
+        if (self.isOpen) {
+          self._trackMouseOver = true;
+        }
+      },
+      0,
+      this
+    );
+  },
+
+  suspendGUI: function ctrlTab_suspendGUI() {
+    for (let preview of this.previews) {
+      this.updatePreview(preview, null);
+    }
+  },
+
+  onKeyDown(event) {
+    let action = ShortcutUtils.getSystemActionForEvent(event);
+    if (action != ShortcutUtils.CYCLE_TABS) {
+      return;
+    }
+
+    event.preventDefault();
+    event.stopPropagation();
+
+    if (this.isOpen) {
+      this.advanceFocus(!event.shiftKey);
+      return;
+    }
+
+    if (event.shiftKey) {
+      this.showAllTabs();
+      return;
+    }
+
+    Services.els.addSystemEventListener(document, "keyup", this, false);
+
+    let tabs = gBrowser.visibleTabs;
+    if (tabs.length > 2) {
+      this.open();
+    } else if (tabs.length == 2) {
+      let index = tabs[0].selected ? 1 : 0;
+      gBrowser.selectedTab = tabs[index];
+    }
+  },
+
+  onKeyPress(event) {
+    if (!this.isOpen || !event.ctrlKey) {
+      return;
+    }
+
+    event.preventDefault();
+    event.stopPropagation();
+
+    if (event.keyCode == event.DOM_VK_DELETE) {
+      this.remove(this.selected);
+      return;
+    }
+
+    switch (event.charCode) {
+      case this.keys.close:
+        this.remove(this.selected);
+        break;
+      case this.keys.find:
+      case this.keys.selectAll:
+        this.showAllTabs();
+        break;
+    }
+  },
+
+  removeClosingTabFromUI: function ctrlTab_removeClosingTabFromUI(aTab) {
+    if (this.tabCount == 2) {
+      this.close();
+      return;
+    }
+
+    this.updatePreviews();
+
+    if (this.selected.hidden) {
+      this.advanceFocus(false);
+    }
+    if (this.selected == this.showAllButton) {
+      this.advanceFocus(false);
+    }
+
+    // If the current tab is removed, another tab can steal our focus.
+    if (aTab.selected && this.panel.state == "open") {
+      setTimeout(
+        function(selected) {
+          selected.focus();
+        },
+        0,
+        this.selected
+      );
+    }
+  },
+
+  handleEvent: function ctrlTab_handleEvent(event) {
+    switch (event.type) {
+      case "SSWindowRestored":
+        this._initRecentlyUsedTabs();
+        break;
+      case "TabAttrModified":
+        // tab attribute modified (i.e. label, busy, image)
+        // update preview only if tab attribute modified in the list
+        if (
+          event.detail.changed.some((elem, ind, arr) =>
+            ["label", "busy", "image"].includes(elem)
+          )
+        ) {
+          for (let i = this.previews.length - 1; i >= 0; i--) {
+            if (
+              this.previews[i]._tab &&
+              this.previews[i]._tab == event.target
+            ) {
+              this.updatePreview(this.previews[i], event.target);
+              break;
+            }
+          }
+        }
+        break;
+      case "TabSelect":
+        this.attachTab(event.target, 0);
+        // If the previous tab was hidden (e.g. Firefox View), remove it from
+        // the list when it's deselected.
+        let previousTab = event.detail.previousTab;
+        if (previousTab.hidden) {
+          this.detachTab(previousTab);
+        }
+        break;
+      case "TabOpen":
+        this.attachTab(event.target, 1);
+        break;
+      case "TabClose":
+        this.detachTab(event.target);
+        if (this.isOpen) {
+          this.removeClosingTabFromUI(event.target);
+        }
+        break;
+      case "TabHide":
+        this.detachTab(event.target);
+        break;
+      case "TabShow":
+        this.attachTab(event.target);
+        this._sortRecentlyUsedTabs();
+        break;
+      case "keydown":
+        this.onKeyDown(event);
+        break;
+      case "keypress":
+        this.onKeyPress(event);
+        break;
+      case "keyup":
+        // During cycling tabs, we avoid sending keyup event to content document.
+        event.preventDefault();
+        event.stopPropagation();
+
+        if (event.keyCode === event.DOM_VK_CONTROL) {
+          Services.els.removeSystemEventListener(
+            document,
+            "keyup",
+            this,
+            false
+          );
+
+          if (this.isOpen) {
+            this.pick();
+          }
+        }
+        break;
+      case "popupshowing":
+        if (event.target.id == "menu_viewPopup") {
+          document.getElementById(
+            "menu_showAllTabs"
+          ).hidden = !gTabsPanel.canOpen;
+        }
+        break;
+      case "mouseover":
+        this._mouseOverFocus(event.currentTarget);
+        break;
+      case "command":
+        this.pick(event.currentTarget);
+        break;
+      case "click":
+        if (event.button == 1) {
+          this.remove(event.currentTarget);
+        } else if (AppConstants.platform == "macosx" && event.button == 2) {
+          // Control+click is a right click on macOS, but in this case we want
+          // to handle it like a left click.
+          this.pick(event.currentTarget);
+        }
+        break;
+    }
+  },
+
+  filterForThumbnailExpiration(aCallback) {
+    // Save a few more thumbnails than we actually display, so that when tabs
+    // are closed, the previews we add instead still get thumbnails.
+    const extraThumbnails = 3;
+    const thumbnailCount = Math.min(
+      this.tabPreviewCount + extraThumbnails,
+      this.tabCount
+    );
+
+    let urls = [];
+    for (let i = 0; i < thumbnailCount; i++) {
+      urls.push(this.tabList[i].linkedBrowser.currentURI.spec);
+    }
+
+    aCallback(urls);
+  },
+  _sortRecentlyUsedTabs() {
+    this._recentlyUsedTabs.sort(
+      (tab1, tab2) => tab2.lastAccessed - tab1.lastAccessed
+    );
+  },
+  _initRecentlyUsedTabs() {
+    this._recentlyUsedTabs = Array.prototype.filter.call(
+      gBrowser.tabs,
+      tab => !tab.closing && !tab.hidden
+    );
+    this._sortRecentlyUsedTabs();
+  },
+
+  _init: function ctrlTab__init(enable) {
+    var toggleEventListener = enable
+      ? "addEventListener"
+      : "removeEventListener";
+
+    window[toggleEventListener]("SSWindowRestored", this);
+
+    var tabContainer = gBrowser.tabContainer;
+    tabContainer[toggleEventListener]("TabOpen", this);
+    tabContainer[toggleEventListener]("TabAttrModified", this);
+    tabContainer[toggleEventListener]("TabSelect", this);
+    tabContainer[toggleEventListener]("TabClose", this);
+    tabContainer[toggleEventListener]("TabHide", this);
+    tabContainer[toggleEventListener]("TabShow", this);
+
+    if (enable) {
+      Services.els.addSystemEventListener(document, "keydown", this, false);
+    } else {
+      Services.els.removeSystemEventListener(document, "keydown", this, false);
+    }
+    document[toggleEventListener]("keypress", this);
+    gBrowser.tabbox.handleCtrlTab = !enable;
+
+    if (enable) {
+      PageThumbs.addExpirationFilter(this);
+    } else {
+      PageThumbs.removeExpirationFilter(this);
+    }
+
+    // If we're not running, hide the "Show All Tabs" menu item,
+    // as Shift+Ctrl+Tab will be handled by the tab bar.
+    document.getElementById("menu_showAllTabs").hidden = !enable;
+    document
+      .getElementById("menu_viewPopup")
+      [toggleEventListener]("popupshowing", this);
+  },
+};