forked from mirrors/gecko-dev
cbe72a6d2e
This fixes tests that block me from landing bug 1847584. In particular, consider that we set a tab to `display: none` (e.g. by entering customize mode). Only then, we try to switch tabs. There can be the case that painting is fast enough in clearing our layers, and by the time we set renderLayers = false, we already do not have layers (from display: none clearing them). This makes transitioning to UNLOADING/LOADING potentially transition directly to LOADED/UNLOADED, but that seems fine. That's already the case for non-remote browsers. This makes the remote and non-remote code-paths more similar, which is nice. Differential Revision: https://phabricator.services.mozilla.com/D187387
1509 lines
46 KiB
JavaScript
1509 lines
46 KiB
JavaScript
/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*-
|
|
* 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/. */
|
|
|
|
import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
|
|
import { AppConstants } from "resource://gre/modules/AppConstants.sys.mjs";
|
|
|
|
const lazy = {};
|
|
|
|
ChromeUtils.defineESModuleGetters(lazy, {
|
|
PictureInPicture: "resource://gre/modules/PictureInPicture.sys.mjs",
|
|
});
|
|
|
|
XPCOMUtils.defineLazyPreferenceGetter(
|
|
lazy,
|
|
"gTabWarmingEnabled",
|
|
"browser.tabs.remote.warmup.enabled"
|
|
);
|
|
XPCOMUtils.defineLazyPreferenceGetter(
|
|
lazy,
|
|
"gTabWarmingMax",
|
|
"browser.tabs.remote.warmup.maxTabs"
|
|
);
|
|
XPCOMUtils.defineLazyPreferenceGetter(
|
|
lazy,
|
|
"gTabWarmingUnloadDelayMs",
|
|
"browser.tabs.remote.warmup.unloadDelayMs"
|
|
);
|
|
XPCOMUtils.defineLazyPreferenceGetter(
|
|
lazy,
|
|
"gTabCacheSize",
|
|
"browser.tabs.remote.tabCacheSize"
|
|
);
|
|
|
|
/**
|
|
* The tab switcher is responsible for asynchronously switching
|
|
* tabs in e10s. It waits until the new tab is ready (i.e., the
|
|
* layer tree is available) before switching to it. Then it
|
|
* unloads the layer tree for the old tab.
|
|
*
|
|
* The tab switcher is a state machine. For each tab, it
|
|
* maintains state about whether the layer tree for the tab is
|
|
* available, being loaded, being unloaded, or unavailable. It
|
|
* also keeps track of the tab currently being displayed, the tab
|
|
* it's trying to load, and the tab the user has asked to switch
|
|
* to. The switcher object is created upon tab switch. It is
|
|
* released when there are no pending tabs to load or unload.
|
|
*
|
|
* The following general principles have guided the design:
|
|
*
|
|
* 1. We only request one layer tree at a time. If the user
|
|
* switches to a different tab while waiting, we don't request
|
|
* the new layer tree until the old tab has loaded or timed out.
|
|
*
|
|
* 2. If loading the layers for a tab times out, we show the
|
|
* spinner and possibly request the layer tree for another tab if
|
|
* the user has requested one.
|
|
*
|
|
* 3. We discard layer trees on a delay. This way, if the user is
|
|
* switching among the same tabs frequently, we don't continually
|
|
* load the same tabs.
|
|
*
|
|
* It's important that we always show either the spinner or a tab
|
|
* whose layers are available. Otherwise the compositor will draw
|
|
* an entirely black frame, which is very jarring. To ensure this
|
|
* never happens when switching away from a tab, we assume the
|
|
* old tab might still be drawn until a MozAfterPaint event
|
|
* occurs. Because layout and compositing happen asynchronously,
|
|
* we don't have any other way of knowing when the switch
|
|
* actually takes place. Therefore, we don't unload the old tab
|
|
* until the next MozAfterPaint event.
|
|
*/
|
|
export class AsyncTabSwitcher {
|
|
constructor(tabbrowser) {
|
|
this.log("START");
|
|
|
|
// How long to wait for a tab's layers to load. After this
|
|
// time elapses, we're free to put up the spinner and start
|
|
// trying to load a different tab.
|
|
this.TAB_SWITCH_TIMEOUT = 400; // ms
|
|
|
|
// When the user hasn't switched tabs for this long, we unload
|
|
// layers for all tabs that aren't in use.
|
|
this.UNLOAD_DELAY = 300; // ms
|
|
|
|
// The next three tabs form the principal state variables.
|
|
// See the assertions in postActions for their invariants.
|
|
|
|
// Tab the user requested most recently.
|
|
this.requestedTab = tabbrowser.selectedTab;
|
|
|
|
// Tab we're currently trying to load.
|
|
this.loadingTab = null;
|
|
|
|
// We show this tab in case the requestedTab hasn't loaded yet.
|
|
this.lastVisibleTab = tabbrowser.selectedTab;
|
|
|
|
// Auxilliary state variables:
|
|
|
|
this.visibleTab = tabbrowser.selectedTab; // Tab that's on screen.
|
|
this.spinnerTab = null; // Tab showing a spinner.
|
|
this.blankTab = null; // Tab showing blank.
|
|
this.lastPrimaryTab = tabbrowser.selectedTab; // Tab with primary="true"
|
|
|
|
this.tabbrowser = tabbrowser;
|
|
this.window = tabbrowser.ownerGlobal;
|
|
this.loadTimer = null; // TAB_SWITCH_TIMEOUT nsITimer instance.
|
|
this.unloadTimer = null; // UNLOAD_DELAY nsITimer instance.
|
|
|
|
// Map from tabs to STATE_* (below).
|
|
this.tabState = new Map();
|
|
|
|
// True if we're in the midst of switching tabs.
|
|
this.switchInProgress = false;
|
|
|
|
// Transaction id for the composite that will show the requested
|
|
// tab for the first tab after a tab switch.
|
|
// Set to -1 when we're not waiting for notification of a
|
|
// completed switch.
|
|
this.switchPaintId = -1;
|
|
|
|
// Set of tabs that might be visible right now. We maintain
|
|
// this set because we can't be sure when a tab is actually
|
|
// drawn. A tab is added to this set when we ask to make it
|
|
// visible. All tabs but the most recently shown tab are
|
|
// removed from the set upon MozAfterPaint.
|
|
this.maybeVisibleTabs = new Set([tabbrowser.selectedTab]);
|
|
|
|
// This holds onto the set of tabs that we've been asked to warm up,
|
|
// and tabs are evicted once they're done loading or are unloaded.
|
|
this.warmingTabs = new WeakSet();
|
|
|
|
this.STATE_UNLOADED = 0;
|
|
this.STATE_LOADING = 1;
|
|
this.STATE_LOADED = 2;
|
|
this.STATE_UNLOADING = 3;
|
|
|
|
// re-entrancy guard:
|
|
this._processing = false;
|
|
|
|
// For telemetry, keeps track of what most recently cleared
|
|
// the loadTimer, which can tell us something about the cause
|
|
// of tab switch spinners.
|
|
this._loadTimerClearedBy = "none";
|
|
|
|
this._useDumpForLogging = false;
|
|
this._logInit = false;
|
|
this._logFlags = [];
|
|
|
|
this.window.addEventListener("MozAfterPaint", this);
|
|
this.window.addEventListener("MozLayerTreeReady", this);
|
|
this.window.addEventListener("MozLayerTreeCleared", this);
|
|
this.window.addEventListener("TabRemotenessChange", this);
|
|
this.window.addEventListener("SwapDocShells", this, true);
|
|
this.window.addEventListener("EndSwapDocShells", this, true);
|
|
this.window.document.addEventListener("visibilitychange", this);
|
|
|
|
let initialTab = this.requestedTab;
|
|
let initialBrowser = initialTab.linkedBrowser;
|
|
|
|
let tabIsLoaded =
|
|
!initialBrowser.isRemoteBrowser ||
|
|
initialBrowser.frameLoader.remoteTab?.hasLayers;
|
|
|
|
// If we minimized the window before the switcher was activated,
|
|
// we might have set the preserveLayers flag for the current
|
|
// browser. Let's clear it.
|
|
initialBrowser.preserveLayers(false);
|
|
|
|
if (!this.windowHidden) {
|
|
this.log("Initial tab is loaded?: " + tabIsLoaded);
|
|
this.setTabState(
|
|
initialTab,
|
|
tabIsLoaded ? this.STATE_LOADED : this.STATE_LOADING
|
|
);
|
|
}
|
|
|
|
for (let ppBrowser of this.tabbrowser._printPreviewBrowsers) {
|
|
let ppTab = this.tabbrowser.getTabForBrowser(ppBrowser);
|
|
let state = ppBrowser.hasLayers ? this.STATE_LOADED : this.STATE_LOADING;
|
|
this.setTabState(ppTab, state);
|
|
}
|
|
}
|
|
|
|
destroy() {
|
|
if (this.unloadTimer) {
|
|
this.clearTimer(this.unloadTimer);
|
|
this.unloadTimer = null;
|
|
}
|
|
if (this.loadTimer) {
|
|
this.clearTimer(this.loadTimer);
|
|
this.loadTimer = null;
|
|
}
|
|
|
|
this.window.removeEventListener("MozAfterPaint", this);
|
|
this.window.removeEventListener("MozLayerTreeReady", this);
|
|
this.window.removeEventListener("MozLayerTreeCleared", this);
|
|
this.window.removeEventListener("TabRemotenessChange", this);
|
|
this.window.removeEventListener("SwapDocShells", this, true);
|
|
this.window.removeEventListener("EndSwapDocShells", this, true);
|
|
this.window.document.removeEventListener("visibilitychange", this);
|
|
|
|
this.tabbrowser._switcher = null;
|
|
}
|
|
|
|
// Wraps nsITimer. Must not use the vanilla setTimeout and
|
|
// clearTimeout, because they will be blocked by nsIPromptService
|
|
// dialogs.
|
|
setTimer(callback, timeout) {
|
|
let event = {
|
|
notify: callback,
|
|
};
|
|
|
|
var timer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer);
|
|
timer.initWithCallback(event, timeout, Ci.nsITimer.TYPE_ONE_SHOT);
|
|
return timer;
|
|
}
|
|
|
|
clearTimer(timer) {
|
|
timer.cancel();
|
|
}
|
|
|
|
getTabState(tab) {
|
|
let state = this.tabState.get(tab);
|
|
|
|
// As an optimization, we lazily evaluate the state of tabs
|
|
// that we've never seen before. Once we've figured it out,
|
|
// we stash it in our state map.
|
|
if (state === undefined) {
|
|
state = this.STATE_UNLOADED;
|
|
|
|
if (tab && tab.linkedPanel) {
|
|
let b = tab.linkedBrowser;
|
|
if (b.renderLayers && b.hasLayers) {
|
|
state = this.STATE_LOADED;
|
|
} else if (b.renderLayers && !b.hasLayers) {
|
|
state = this.STATE_LOADING;
|
|
} else if (!b.renderLayers && b.hasLayers) {
|
|
state = this.STATE_UNLOADING;
|
|
}
|
|
}
|
|
|
|
this.setTabStateNoAction(tab, state);
|
|
}
|
|
|
|
return state;
|
|
}
|
|
|
|
setTabStateNoAction(tab, state) {
|
|
if (state == this.STATE_UNLOADED) {
|
|
this.tabState.delete(tab);
|
|
} else {
|
|
this.tabState.set(tab, state);
|
|
}
|
|
}
|
|
|
|
setTabState(tab, state) {
|
|
if (state == this.getTabState(tab)) {
|
|
return;
|
|
}
|
|
|
|
this.setTabStateNoAction(tab, state);
|
|
|
|
let browser = tab.linkedBrowser;
|
|
let { remoteTab } = browser.frameLoader;
|
|
if (state == this.STATE_LOADING) {
|
|
this.assert(!this.windowHidden);
|
|
|
|
// If we're not in the process of warming this tab, we
|
|
// don't need to delay activating its DocShell.
|
|
if (!this.warmingTabs.has(tab)) {
|
|
browser.docShellIsActive = true;
|
|
}
|
|
|
|
if (remoteTab) {
|
|
browser.renderLayers = true;
|
|
remoteTab.priorityHint = true;
|
|
}
|
|
if (browser.hasLayers) {
|
|
this.onLayersReady(browser);
|
|
}
|
|
} else if (state == this.STATE_UNLOADING) {
|
|
this.unwarmTab(tab);
|
|
// Setting the docShell to be inactive will also cause it
|
|
// to stop rendering layers.
|
|
browser.docShellIsActive = false;
|
|
if (remoteTab) {
|
|
remoteTab.priorityHint = false;
|
|
}
|
|
if (!browser.hasLayers) {
|
|
this.onLayersCleared(browser);
|
|
}
|
|
} else if (state == this.STATE_LOADED) {
|
|
this.maybeActivateDocShell(tab);
|
|
}
|
|
|
|
if (!tab.linkedBrowser.isRemoteBrowser) {
|
|
// setTabState is potentially re-entrant, so we must re-get the state for
|
|
// this assertion.
|
|
let nonRemoteState = this.getTabState(tab);
|
|
// Non-remote tabs can never stay in the STATE_LOADING
|
|
// or STATE_UNLOADING states. By the time this function
|
|
// exits, a non-remote tab must be in STATE_LOADED or
|
|
// STATE_UNLOADED, since the painting and the layer
|
|
// upload happen synchronously.
|
|
this.assert(
|
|
nonRemoteState == this.STATE_UNLOADED ||
|
|
nonRemoteState == this.STATE_LOADED
|
|
);
|
|
}
|
|
}
|
|
|
|
get windowHidden() {
|
|
return this.window.document.hidden;
|
|
}
|
|
|
|
get tabLayerCache() {
|
|
return this.tabbrowser._tabLayerCache;
|
|
}
|
|
|
|
finish() {
|
|
this.log("FINISH");
|
|
|
|
this.assert(this.tabbrowser._switcher);
|
|
this.assert(this.tabbrowser._switcher === this);
|
|
this.assert(!this.spinnerTab);
|
|
this.assert(!this.blankTab);
|
|
this.assert(!this.loadTimer);
|
|
this.assert(!this.loadingTab);
|
|
this.assert(this.lastVisibleTab === this.requestedTab);
|
|
this.assert(
|
|
this.windowHidden ||
|
|
this.getTabState(this.requestedTab) == this.STATE_LOADED
|
|
);
|
|
|
|
this.destroy();
|
|
|
|
this.window.document.commandDispatcher.unlock();
|
|
|
|
let event = new this.window.CustomEvent("TabSwitchDone", {
|
|
bubbles: true,
|
|
cancelable: true,
|
|
});
|
|
this.tabbrowser.dispatchEvent(event);
|
|
}
|
|
|
|
// This function is called after all the main state changes to
|
|
// make sure we display the right tab.
|
|
updateDisplay() {
|
|
let requestedTabState = this.getTabState(this.requestedTab);
|
|
let requestedBrowser = this.requestedTab.linkedBrowser;
|
|
|
|
// It is often more desirable to show a blank tab when appropriate than
|
|
// the tab switch spinner - especially since the spinner is usually
|
|
// preceded by a perceived lag of TAB_SWITCH_TIMEOUT ms in the
|
|
// tab switch. We can hide this lag, and hide the time being spent
|
|
// constructing BrowserChild's, layer trees, etc, by showing a blank
|
|
// tab instead and focusing it immediately.
|
|
let shouldBeBlank = false;
|
|
if (requestedBrowser.isRemoteBrowser) {
|
|
// If a tab is remote and the window is not minimized, we can show a
|
|
// blank tab instead of a spinner in the following cases:
|
|
//
|
|
// 1. The tab has just crashed, and we haven't started showing the
|
|
// tab crashed page yet (in this case, the RemoteTab is null)
|
|
// 2. The tab has never presented, and has not finished loading
|
|
// a non-local-about: page.
|
|
//
|
|
// For (2), "finished loading a non-local-about: page" is
|
|
// determined by the busy state on the tab element and checking
|
|
// if the loaded URI is local.
|
|
let isBusy = this.requestedTab.hasAttribute("busy");
|
|
let isLocalAbout = requestedBrowser.currentURI.schemeIs("about");
|
|
let hasSufficientlyLoaded = !isBusy && !isLocalAbout;
|
|
|
|
let fl = requestedBrowser.frameLoader;
|
|
shouldBeBlank =
|
|
!this.windowHidden &&
|
|
(!fl.remoteTab ||
|
|
(!hasSufficientlyLoaded && !fl.remoteTab.hasPresented));
|
|
|
|
if (this.logging()) {
|
|
let flag = shouldBeBlank ? "blank" : "nonblank";
|
|
this.addLogFlag(
|
|
flag,
|
|
this.windowHidden,
|
|
fl.remoteTab,
|
|
isBusy,
|
|
isLocalAbout,
|
|
fl.remoteTab ? fl.remoteTab.hasPresented : 0
|
|
);
|
|
}
|
|
}
|
|
|
|
if (requestedBrowser.isRemoteBrowser) {
|
|
this.addLogFlag("isRemote");
|
|
}
|
|
|
|
// Figure out which tab we actually want visible right now.
|
|
let showTab = null;
|
|
if (
|
|
requestedTabState != this.STATE_LOADED &&
|
|
this.lastVisibleTab &&
|
|
this.loadTimer &&
|
|
!shouldBeBlank
|
|
) {
|
|
// If we can't show the requestedTab, and lastVisibleTab is
|
|
// available, show it.
|
|
showTab = this.lastVisibleTab;
|
|
} else {
|
|
// Show the requested tab. If it's not available, we'll show the spinner or a blank tab.
|
|
showTab = this.requestedTab;
|
|
}
|
|
|
|
// First, let's deal with blank tabs, which we show instead
|
|
// of the spinner when the tab is not currently set up
|
|
// properly in the content process.
|
|
if (!shouldBeBlank && this.blankTab) {
|
|
this.blankTab.linkedBrowser.removeAttribute("blank");
|
|
this.blankTab = null;
|
|
} else if (shouldBeBlank && this.blankTab !== showTab) {
|
|
if (this.blankTab) {
|
|
this.blankTab.linkedBrowser.removeAttribute("blank");
|
|
}
|
|
this.blankTab = showTab;
|
|
this.blankTab.linkedBrowser.setAttribute("blank", "true");
|
|
}
|
|
|
|
// Show or hide the spinner as needed.
|
|
let needSpinner =
|
|
this.getTabState(showTab) != this.STATE_LOADED &&
|
|
!this.windowHidden &&
|
|
!shouldBeBlank &&
|
|
!this.loadTimer;
|
|
|
|
if (!needSpinner && this.spinnerTab) {
|
|
this.noteSpinnerHidden();
|
|
this.tabbrowser.tabpanels.removeAttribute("pendingpaint");
|
|
this.spinnerTab.linkedBrowser.removeAttribute("pendingpaint");
|
|
this.spinnerTab = null;
|
|
} else if (needSpinner && this.spinnerTab !== showTab) {
|
|
if (this.spinnerTab) {
|
|
this.spinnerTab.linkedBrowser.removeAttribute("pendingpaint");
|
|
} else {
|
|
this.noteSpinnerDisplayed();
|
|
}
|
|
this.spinnerTab = showTab;
|
|
this.tabbrowser.tabpanels.toggleAttribute("pendingpaint", true);
|
|
this.spinnerTab.linkedBrowser.toggleAttribute("pendingpaint", true);
|
|
}
|
|
|
|
// Switch to the tab we've decided to make visible.
|
|
if (this.visibleTab !== showTab) {
|
|
this.tabbrowser._adjustFocusBeforeTabSwitch(this.visibleTab, showTab);
|
|
this.visibleTab = showTab;
|
|
|
|
this.maybeVisibleTabs.add(showTab);
|
|
|
|
let tabpanels = this.tabbrowser.tabpanels;
|
|
let showPanel = this.tabbrowser.tabContainer.getRelatedElement(showTab);
|
|
let index = Array.prototype.indexOf.call(tabpanels.children, showPanel);
|
|
if (index != -1) {
|
|
this.log(`Switch to tab ${index} - ${this.tinfo(showTab)}`);
|
|
tabpanels.updateSelectedIndex(index);
|
|
if (showTab === this.requestedTab) {
|
|
if (requestedTabState == this.STATE_LOADED) {
|
|
// The new tab will be made visible in the next paint, record the expected
|
|
// transaction id for that, and we'll mark when we get notified of its
|
|
// completion.
|
|
this.switchPaintId = this.window.windowUtils.lastTransactionId + 1;
|
|
} else {
|
|
this.noteMakingTabVisibleWithoutLayers();
|
|
}
|
|
|
|
this.tabbrowser._adjustFocusAfterTabSwitch(showTab);
|
|
this.window.gURLBar.afterTabSwitchFocusChange();
|
|
this.maybeActivateDocShell(this.requestedTab);
|
|
}
|
|
}
|
|
|
|
// This doesn't necessarily exist if we're a new window and haven't switched tabs yet
|
|
if (this.lastVisibleTab) {
|
|
this.lastVisibleTab._visuallySelected = false;
|
|
}
|
|
|
|
this.visibleTab._visuallySelected = true;
|
|
}
|
|
|
|
this.lastVisibleTab = this.visibleTab;
|
|
}
|
|
|
|
assert(cond) {
|
|
if (!cond) {
|
|
dump("Assertion failure\n" + Error().stack);
|
|
|
|
// Don't break a user's browser if an assertion fails.
|
|
if (AppConstants.DEBUG) {
|
|
throw new Error("Assertion failure");
|
|
}
|
|
}
|
|
}
|
|
|
|
maybeClearLoadTimer(caller) {
|
|
if (this.loadingTab) {
|
|
this._loadTimerClearedBy = caller;
|
|
this.loadingTab = null;
|
|
if (this.loadTimer) {
|
|
this.clearTimer(this.loadTimer);
|
|
this.loadTimer = null;
|
|
}
|
|
}
|
|
}
|
|
|
|
// We've decided to try to load requestedTab.
|
|
loadRequestedTab() {
|
|
this.assert(!this.loadTimer);
|
|
this.assert(!this.windowHidden);
|
|
|
|
// loadingTab can be non-null here if we timed out loading the current tab.
|
|
// In that case we just overwrite it with a different tab; it's had its chance.
|
|
this.loadingTab = this.requestedTab;
|
|
this.log("Loading tab " + this.tinfo(this.loadingTab));
|
|
|
|
this.loadTimer = this.setTimer(
|
|
() => this.handleEvent({ type: "loadTimeout" }),
|
|
this.TAB_SWITCH_TIMEOUT
|
|
);
|
|
this.setTabState(this.requestedTab, this.STATE_LOADING);
|
|
}
|
|
|
|
maybeActivateDocShell(tab) {
|
|
// If we've reached the point where the requested tab has entered
|
|
// the loaded state, but the DocShell is still not yet active, we
|
|
// should activate it.
|
|
let browser = tab.linkedBrowser;
|
|
let state = this.getTabState(tab);
|
|
let canCheckDocShellState =
|
|
!browser.mDestroyed &&
|
|
(browser.docShell || browser.frameLoader.remoteTab);
|
|
if (
|
|
tab == this.requestedTab &&
|
|
canCheckDocShellState &&
|
|
state == this.STATE_LOADED &&
|
|
!browser.docShellIsActive &&
|
|
!this.windowHidden
|
|
) {
|
|
browser.docShellIsActive = true;
|
|
this.logState(
|
|
"Set requested tab docshell to active and preserveLayers to false"
|
|
);
|
|
// If we minimized the window before the switcher was activated,
|
|
// we might have set the preserveLayers flag for the current
|
|
// browser. Let's clear it.
|
|
browser.preserveLayers(false);
|
|
}
|
|
}
|
|
|
|
// This function runs before every event. It fixes up the state
|
|
// to account for closed tabs.
|
|
preActions() {
|
|
this.assert(this.tabbrowser._switcher);
|
|
this.assert(this.tabbrowser._switcher === this);
|
|
|
|
for (let i = 0; i < this.tabLayerCache.length; i++) {
|
|
let tab = this.tabLayerCache[i];
|
|
if (!tab.linkedBrowser) {
|
|
this.tabState.delete(tab);
|
|
this.tabLayerCache.splice(i, 1);
|
|
i--;
|
|
}
|
|
}
|
|
|
|
for (let [tab] of this.tabState) {
|
|
if (!tab.linkedBrowser) {
|
|
this.tabState.delete(tab);
|
|
this.unwarmTab(tab);
|
|
}
|
|
}
|
|
|
|
if (this.lastVisibleTab && !this.lastVisibleTab.linkedBrowser) {
|
|
this.lastVisibleTab = null;
|
|
}
|
|
if (this.lastPrimaryTab && !this.lastPrimaryTab.linkedBrowser) {
|
|
this.lastPrimaryTab = null;
|
|
}
|
|
if (this.blankTab && !this.blankTab.linkedBrowser) {
|
|
this.blankTab = null;
|
|
}
|
|
if (this.spinnerTab && !this.spinnerTab.linkedBrowser) {
|
|
this.noteSpinnerHidden();
|
|
this.spinnerTab = null;
|
|
}
|
|
if (this.loadingTab && !this.loadingTab.linkedBrowser) {
|
|
this.maybeClearLoadTimer("preActions");
|
|
}
|
|
}
|
|
|
|
// This code runs after we've responded to an event or requested a new
|
|
// tab. It's expected that we've already updated all the principal
|
|
// state variables. This function takes care of updating any auxilliary
|
|
// state.
|
|
postActions(eventString) {
|
|
// Once we finish loading loadingTab, we null it out. So the state should
|
|
// always be LOADING.
|
|
this.assert(
|
|
!this.loadingTab ||
|
|
this.getTabState(this.loadingTab) == this.STATE_LOADING
|
|
);
|
|
|
|
// We guarantee that loadingTab is non-null iff loadTimer is non-null. So
|
|
// the timer is set only when we're loading something.
|
|
this.assert(!this.loadTimer || this.loadingTab);
|
|
this.assert(!this.loadingTab || this.loadTimer);
|
|
|
|
// If we're switching to a non-remote tab, there's no need to wait
|
|
// for it to send layers to the compositor, as this will happen
|
|
// synchronously. Clearing this here means that in the next step,
|
|
// we can load the non-remote browser immediately.
|
|
if (!this.requestedTab.linkedBrowser.isRemoteBrowser) {
|
|
this.maybeClearLoadTimer("postActions");
|
|
}
|
|
|
|
// If we're not loading anything, try loading the requested tab.
|
|
let stateOfRequestedTab = this.getTabState(this.requestedTab);
|
|
if (
|
|
!this.loadTimer &&
|
|
!this.windowHidden &&
|
|
(stateOfRequestedTab == this.STATE_UNLOADED ||
|
|
stateOfRequestedTab == this.STATE_UNLOADING ||
|
|
this.warmingTabs.has(this.requestedTab))
|
|
) {
|
|
this.assert(stateOfRequestedTab != this.STATE_LOADED);
|
|
this.loadRequestedTab();
|
|
}
|
|
|
|
let numBackgroundCached = 0;
|
|
for (let tab of this.tabLayerCache) {
|
|
if (tab !== this.requestedTab) {
|
|
numBackgroundCached++;
|
|
}
|
|
}
|
|
|
|
// See how many tabs still have work to do.
|
|
let numPending = 0;
|
|
let numWarming = 0;
|
|
for (let [tab, state] of this.tabState) {
|
|
if (!this.shouldDeactivateDocShell(tab.linkedBrowser)) {
|
|
continue;
|
|
}
|
|
|
|
if (
|
|
state == this.STATE_LOADED &&
|
|
tab !== this.requestedTab &&
|
|
!this.tabLayerCache.includes(tab)
|
|
) {
|
|
numPending++;
|
|
|
|
if (tab !== this.visibleTab) {
|
|
numWarming++;
|
|
}
|
|
}
|
|
if (state == this.STATE_LOADING || state == this.STATE_UNLOADING) {
|
|
numPending++;
|
|
}
|
|
}
|
|
|
|
this.updateDisplay();
|
|
|
|
// It's possible for updateDisplay to trigger one of our own event
|
|
// handlers, which might cause finish() to already have been called.
|
|
// Check for that before calling finish() again.
|
|
if (!this.tabbrowser._switcher) {
|
|
return;
|
|
}
|
|
|
|
this.maybeFinishTabSwitch();
|
|
|
|
if (numBackgroundCached > 0) {
|
|
this.deactivateCachedBackgroundTabs();
|
|
}
|
|
|
|
if (numWarming > lazy.gTabWarmingMax) {
|
|
this.logState("Hit tabWarmingMax");
|
|
if (this.unloadTimer) {
|
|
this.clearTimer(this.unloadTimer);
|
|
}
|
|
this.unloadNonRequiredTabs();
|
|
}
|
|
|
|
if (numPending == 0) {
|
|
this.finish();
|
|
}
|
|
|
|
this.logState("/" + eventString);
|
|
}
|
|
|
|
// Fires when we're ready to unload unused tabs.
|
|
onUnloadTimeout() {
|
|
this.unloadTimer = null;
|
|
this.unloadNonRequiredTabs();
|
|
}
|
|
|
|
deactivateCachedBackgroundTabs() {
|
|
for (let tab of this.tabLayerCache) {
|
|
if (tab !== this.requestedTab) {
|
|
let browser = tab.linkedBrowser;
|
|
browser.preserveLayers(true);
|
|
browser.docShellIsActive = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
// If there are any non-visible and non-requested tabs in
|
|
// STATE_LOADED, sets them to STATE_UNLOADING. Also queues
|
|
// up the unloadTimer to run onUnloadTimeout if there are still
|
|
// tabs in the process of unloading.
|
|
unloadNonRequiredTabs() {
|
|
this.warmingTabs = new WeakSet();
|
|
let numPending = 0;
|
|
|
|
// Unload any tabs that can be unloaded.
|
|
for (let [tab, state] of this.tabState) {
|
|
if (!this.shouldDeactivateDocShell(tab.linkedBrowser)) {
|
|
continue;
|
|
}
|
|
|
|
let isInLayerCache = this.tabLayerCache.includes(tab);
|
|
|
|
if (
|
|
state == this.STATE_LOADED &&
|
|
!this.maybeVisibleTabs.has(tab) &&
|
|
tab !== this.lastVisibleTab &&
|
|
tab !== this.loadingTab &&
|
|
tab !== this.requestedTab &&
|
|
!isInLayerCache
|
|
) {
|
|
this.setTabState(tab, this.STATE_UNLOADING);
|
|
}
|
|
|
|
if (
|
|
state != this.STATE_UNLOADED &&
|
|
tab !== this.requestedTab &&
|
|
!isInLayerCache
|
|
) {
|
|
numPending++;
|
|
}
|
|
}
|
|
|
|
if (numPending) {
|
|
// Keep the timer going since there may be more tabs to unload.
|
|
this.unloadTimer = this.setTimer(
|
|
() => this.handleEvent({ type: "unloadTimeout" }),
|
|
this.UNLOAD_DELAY
|
|
);
|
|
}
|
|
}
|
|
|
|
// Fires when an ongoing load has taken too long.
|
|
onLoadTimeout() {
|
|
this.maybeClearLoadTimer("onLoadTimeout");
|
|
}
|
|
|
|
// Fires when the layers become available for a tab.
|
|
onLayersReady(browser) {
|
|
let tab = this.tabbrowser.getTabForBrowser(browser);
|
|
if (!tab) {
|
|
// We probably got a layer update from a tab that got before
|
|
// the switcher was created, or for browser that's not being
|
|
// tracked by the async tab switcher (like the preloaded about:newtab).
|
|
return;
|
|
}
|
|
|
|
this.logState(`onLayersReady(${tab._tPos}, ${browser.isRemoteBrowser})`);
|
|
this.assert(
|
|
this.getTabState(tab) == this.STATE_LOADING ||
|
|
this.getTabState(tab) == this.STATE_LOADED
|
|
);
|
|
this.setTabState(tab, this.STATE_LOADED);
|
|
this.unwarmTab(tab);
|
|
|
|
if (this.loadingTab === tab) {
|
|
this.maybeClearLoadTimer("onLayersReady");
|
|
}
|
|
}
|
|
|
|
// Fires when we paint the screen. Any tab switches we initiated
|
|
// previously are done, so there's no need to keep the old layers
|
|
// around.
|
|
onPaint(event) {
|
|
this.addLogFlag(
|
|
"onPaint",
|
|
this.switchPaintId != -1,
|
|
event.transactionId >= this.switchPaintId
|
|
);
|
|
this.notePaint(event);
|
|
this.maybeVisibleTabs.clear();
|
|
}
|
|
|
|
// Called when we're done clearing the layers for a tab.
|
|
onLayersCleared(browser) {
|
|
let tab = this.tabbrowser.getTabForBrowser(browser);
|
|
if (!tab) {
|
|
return;
|
|
}
|
|
this.logState(`onLayersCleared(${tab._tPos})`);
|
|
this.assert(
|
|
this.getTabState(tab) == this.STATE_UNLOADING ||
|
|
this.getTabState(tab) == this.STATE_UNLOADED
|
|
);
|
|
this.setTabState(tab, this.STATE_UNLOADED);
|
|
}
|
|
|
|
// Called when a tab switches from remote to non-remote. In this case
|
|
// a MozLayerTreeReady notification that we requested may never fire,
|
|
// so we need to simulate it.
|
|
onRemotenessChange(tab) {
|
|
this.logState(
|
|
`onRemotenessChange(${tab._tPos}, ${tab.linkedBrowser.isRemoteBrowser})`
|
|
);
|
|
if (!tab.linkedBrowser.isRemoteBrowser) {
|
|
if (this.getTabState(tab) == this.STATE_LOADING) {
|
|
this.onLayersReady(tab.linkedBrowser);
|
|
} else if (this.getTabState(tab) == this.STATE_UNLOADING) {
|
|
this.onLayersCleared(tab.linkedBrowser);
|
|
}
|
|
} else if (this.getTabState(tab) == this.STATE_LOADED) {
|
|
// A tab just changed from non-remote to remote, which means
|
|
// that it's gone back into the STATE_LOADING state until
|
|
// it sends up a layer tree.
|
|
this.setTabState(tab, this.STATE_LOADING);
|
|
}
|
|
}
|
|
|
|
onTabRemoved(tab) {
|
|
if (this.lastVisibleTab == tab) {
|
|
this.handleEvent({ type: "tabRemoved", tab });
|
|
}
|
|
}
|
|
|
|
// Called when a tab has been removed, and the browser node is
|
|
// about to be removed from the DOM.
|
|
onTabRemovedImpl(tab) {
|
|
this.lastVisibleTab = null;
|
|
}
|
|
|
|
onVisibilityChange() {
|
|
if (this.windowHidden) {
|
|
for (let [tab, state] of this.tabState) {
|
|
if (!this.shouldDeactivateDocShell(tab.linkedBrowser)) {
|
|
continue;
|
|
}
|
|
|
|
if (state == this.STATE_LOADING || state == this.STATE_LOADED) {
|
|
this.setTabState(tab, this.STATE_UNLOADING);
|
|
}
|
|
}
|
|
this.maybeClearLoadTimer("onSizeModeOrOcc");
|
|
} else {
|
|
// We're no longer minimized or occluded. This means we might want
|
|
// to activate the current tab's docShell.
|
|
this.maybeActivateDocShell(this.tabbrowser.selectedTab);
|
|
}
|
|
}
|
|
|
|
onSwapDocShells(ourBrowser, otherBrowser) {
|
|
// This event fires before the swap. ourBrowser is from
|
|
// our window. We save the state of otherBrowser since ourBrowser
|
|
// needs to take on that state at the end of the swap.
|
|
|
|
let otherTabbrowser = otherBrowser.ownerGlobal.gBrowser;
|
|
let otherState;
|
|
if (otherTabbrowser && otherTabbrowser._switcher) {
|
|
let otherTab = otherTabbrowser.getTabForBrowser(otherBrowser);
|
|
let otherSwitcher = otherTabbrowser._switcher;
|
|
otherState = otherSwitcher.getTabState(otherTab);
|
|
} else {
|
|
otherState = otherBrowser.docShellIsActive
|
|
? this.STATE_LOADED
|
|
: this.STATE_UNLOADED;
|
|
}
|
|
if (!this.swapMap) {
|
|
this.swapMap = new WeakMap();
|
|
}
|
|
this.swapMap.set(otherBrowser, {
|
|
state: otherState,
|
|
});
|
|
}
|
|
|
|
onEndSwapDocShells(ourBrowser, otherBrowser) {
|
|
// The swap has happened. We reset the loadingTab in
|
|
// case it has been swapped. We also set ourBrowser's state
|
|
// to whatever otherBrowser's state was before the swap.
|
|
|
|
// Clearing the load timer means that we will
|
|
// immediately display a spinner if ourBrowser isn't
|
|
// ready yet. Typically it will already be ready
|
|
// though. If it's not, we're probably in a new window,
|
|
// in which case we have no other tabs to display anyway.
|
|
this.maybeClearLoadTimer("onEndSwapDocShells");
|
|
|
|
let { state: otherState } = this.swapMap.get(otherBrowser);
|
|
|
|
this.swapMap.delete(otherBrowser);
|
|
|
|
let ourTab = this.tabbrowser.getTabForBrowser(ourBrowser);
|
|
if (ourTab) {
|
|
this.setTabStateNoAction(ourTab, otherState);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Check if the browser should be deactivated. If the browser is a print preivew or
|
|
* PiP browser then we won't deactive it.
|
|
* @param browser The browser to check if it should be deactivated
|
|
* @returns false if a print preview or PiP browser else true
|
|
*/
|
|
shouldDeactivateDocShell(browser) {
|
|
return !(
|
|
this.tabbrowser._printPreviewBrowsers.has(browser) ||
|
|
lazy.PictureInPicture.isOriginatingBrowser(browser)
|
|
);
|
|
}
|
|
|
|
shouldActivateDocShell(browser) {
|
|
let tab = this.tabbrowser.getTabForBrowser(browser);
|
|
let state = this.getTabState(tab);
|
|
return state == this.STATE_LOADING || state == this.STATE_LOADED;
|
|
}
|
|
|
|
activateBrowserForPrintPreview(browser) {
|
|
let tab = this.tabbrowser.getTabForBrowser(browser);
|
|
let state = this.getTabState(tab);
|
|
if (state != this.STATE_LOADING && state != this.STATE_LOADED) {
|
|
this.setTabState(tab, this.STATE_LOADING);
|
|
this.logState(
|
|
"Activated browser " + this.tinfo(tab) + " for print preview"
|
|
);
|
|
}
|
|
}
|
|
|
|
canWarmTab(tab) {
|
|
if (!lazy.gTabWarmingEnabled) {
|
|
return false;
|
|
}
|
|
|
|
if (!tab) {
|
|
return false;
|
|
}
|
|
|
|
// If the tab is not yet inserted, closing, not remote,
|
|
// crashed, already visible, or already requested, warming
|
|
// up the tab makes no sense.
|
|
if (
|
|
this.windowHidden ||
|
|
!tab.linkedPanel ||
|
|
tab.closing ||
|
|
!tab.linkedBrowser.isRemoteBrowser ||
|
|
!tab.linkedBrowser.frameLoader.remoteTab
|
|
) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
shouldWarmTab(tab) {
|
|
if (this.canWarmTab(tab)) {
|
|
// Tabs that are already in STATE_LOADING or STATE_LOADED
|
|
// have no need to be warmed up.
|
|
let state = this.getTabState(tab);
|
|
if (state === this.STATE_UNLOADING || state === this.STATE_UNLOADED) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
unwarmTab(tab) {
|
|
this.warmingTabs.delete(tab);
|
|
}
|
|
|
|
warmupTab(tab) {
|
|
if (!this.shouldWarmTab(tab)) {
|
|
return;
|
|
}
|
|
|
|
this.logState("warmupTab " + this.tinfo(tab));
|
|
|
|
this.warmingTabs.add(tab);
|
|
this.setTabState(tab, this.STATE_LOADING);
|
|
this.queueUnload(lazy.gTabWarmingUnloadDelayMs);
|
|
}
|
|
|
|
cleanUpTabAfterEviction(tab) {
|
|
this.assert(tab !== this.requestedTab);
|
|
let browser = tab.linkedBrowser;
|
|
if (browser) {
|
|
browser.preserveLayers(false);
|
|
}
|
|
this.setTabState(tab, this.STATE_UNLOADING);
|
|
}
|
|
|
|
evictOldestTabFromCache() {
|
|
let tab = this.tabLayerCache.shift();
|
|
this.cleanUpTabAfterEviction(tab);
|
|
}
|
|
|
|
maybePromoteTabInLayerCache(tab) {
|
|
if (
|
|
lazy.gTabCacheSize > 1 &&
|
|
tab.linkedBrowser.isRemoteBrowser &&
|
|
tab.linkedBrowser.currentURI.spec != "about:blank"
|
|
) {
|
|
let tabIndex = this.tabLayerCache.indexOf(tab);
|
|
|
|
if (tabIndex != -1) {
|
|
this.tabLayerCache.splice(tabIndex, 1);
|
|
}
|
|
|
|
this.tabLayerCache.push(tab);
|
|
|
|
if (this.tabLayerCache.length > lazy.gTabCacheSize) {
|
|
this.evictOldestTabFromCache();
|
|
}
|
|
}
|
|
}
|
|
|
|
// Called when the user asks to switch to a given tab.
|
|
requestTab(tab) {
|
|
if (tab === this.requestedTab) {
|
|
return;
|
|
}
|
|
|
|
let tabState = this.getTabState(tab);
|
|
this.noteTabRequested(tab, tabState);
|
|
|
|
this.logState("requestTab " + this.tinfo(tab));
|
|
this.startTabSwitch();
|
|
|
|
let oldBrowser = this.requestedTab.linkedBrowser;
|
|
oldBrowser.deprioritize();
|
|
this.requestedTab = tab;
|
|
if (tabState == this.STATE_LOADED) {
|
|
this.maybeVisibleTabs.clear();
|
|
}
|
|
|
|
tab.linkedBrowser.setAttribute("primary", "true");
|
|
if (this.lastPrimaryTab && this.lastPrimaryTab != tab) {
|
|
this.lastPrimaryTab.linkedBrowser.removeAttribute("primary");
|
|
}
|
|
this.lastPrimaryTab = tab;
|
|
|
|
this.queueUnload(this.UNLOAD_DELAY);
|
|
}
|
|
|
|
queueUnload(unloadTimeout) {
|
|
this.handleEvent({ type: "queueUnload", unloadTimeout });
|
|
}
|
|
|
|
onQueueUnload(unloadTimeout) {
|
|
if (this.unloadTimer) {
|
|
this.clearTimer(this.unloadTimer);
|
|
}
|
|
this.unloadTimer = this.setTimer(
|
|
() => this.handleEvent({ type: "unloadTimeout" }),
|
|
unloadTimeout
|
|
);
|
|
}
|
|
|
|
handleEvent(event, delayed = false) {
|
|
if (this._processing) {
|
|
this.setTimer(() => this.handleEvent(event, true), 0);
|
|
return;
|
|
}
|
|
if (delayed && this.tabbrowser._switcher != this) {
|
|
// if we delayed processing this event, we might be out of date, in which
|
|
// case we drop the delayed events
|
|
return;
|
|
}
|
|
this._processing = true;
|
|
try {
|
|
this.preActions();
|
|
|
|
switch (event.type) {
|
|
case "queueUnload":
|
|
this.onQueueUnload(event.unloadTimeout);
|
|
break;
|
|
case "unloadTimeout":
|
|
this.onUnloadTimeout();
|
|
break;
|
|
case "loadTimeout":
|
|
this.onLoadTimeout();
|
|
break;
|
|
case "tabRemoved":
|
|
this.onTabRemovedImpl(event.tab);
|
|
break;
|
|
case "MozLayerTreeReady": {
|
|
let browser = event.originalTarget;
|
|
if (!browser.renderLayers) {
|
|
// By the time we handle this event, it's possible that something
|
|
// else has already set renderLayers to false, in which case this
|
|
// event is stale and we can safely ignore it.
|
|
return;
|
|
}
|
|
this.onLayersReady(browser);
|
|
break;
|
|
}
|
|
case "MozAfterPaint":
|
|
this.onPaint(event);
|
|
break;
|
|
case "MozLayerTreeCleared": {
|
|
let browser = event.originalTarget;
|
|
if (browser.renderLayers) {
|
|
// By the time we handle this event, it's possible that something
|
|
// else has already set renderLayers to true, in which case this
|
|
// event is stale and we can safely ignore it.
|
|
return;
|
|
}
|
|
this.onLayersCleared(browser);
|
|
break;
|
|
}
|
|
case "TabRemotenessChange":
|
|
this.onRemotenessChange(event.target);
|
|
break;
|
|
case "visibilitychange":
|
|
this.onVisibilityChange();
|
|
break;
|
|
case "SwapDocShells":
|
|
this.onSwapDocShells(event.originalTarget, event.detail);
|
|
break;
|
|
case "EndSwapDocShells":
|
|
this.onEndSwapDocShells(event.originalTarget, event.detail);
|
|
break;
|
|
}
|
|
|
|
this.postActions(event.type);
|
|
} finally {
|
|
this._processing = false;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Telemetry and Profiler related helpers for recording tab switch
|
|
* timing.
|
|
*/
|
|
|
|
startTabSwitch() {
|
|
this.noteStartTabSwitch();
|
|
this.switchInProgress = true;
|
|
}
|
|
|
|
/**
|
|
* Something has occurred that might mean that we've completed
|
|
* the tab switch (layers are ready, paints are done, spinners
|
|
* are hidden). This checks to make sure all conditions are
|
|
* satisfied, and then records the tab switch as finished.
|
|
*/
|
|
maybeFinishTabSwitch() {
|
|
if (
|
|
this.switchInProgress &&
|
|
this.requestedTab &&
|
|
(this.getTabState(this.requestedTab) == this.STATE_LOADED ||
|
|
this.requestedTab === this.blankTab)
|
|
) {
|
|
if (this.requestedTab !== this.blankTab) {
|
|
this.maybePromoteTabInLayerCache(this.requestedTab);
|
|
}
|
|
|
|
this.noteFinishTabSwitch();
|
|
this.switchInProgress = false;
|
|
|
|
let event = new this.window.CustomEvent("TabSwitched", {
|
|
bubbles: true,
|
|
detail: {
|
|
tab: this.requestedTab,
|
|
},
|
|
});
|
|
this.tabbrowser.dispatchEvent(event);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Debug related logging for switcher.
|
|
*/
|
|
logging() {
|
|
if (this._useDumpForLogging) {
|
|
return true;
|
|
}
|
|
if (this._logInit) {
|
|
return this._shouldLog;
|
|
}
|
|
let result = Services.prefs.getBoolPref(
|
|
"browser.tabs.remote.logSwitchTiming",
|
|
false
|
|
);
|
|
this._shouldLog = result;
|
|
this._logInit = true;
|
|
return this._shouldLog;
|
|
}
|
|
|
|
tinfo(tab) {
|
|
if (tab) {
|
|
return tab._tPos + "(" + tab.linkedBrowser.currentURI.spec + ")";
|
|
}
|
|
return "null";
|
|
}
|
|
|
|
log(s) {
|
|
if (!this.logging()) {
|
|
return;
|
|
}
|
|
if (this._useDumpForLogging) {
|
|
dump(s + "\n");
|
|
} else {
|
|
Services.console.logStringMessage(s);
|
|
}
|
|
}
|
|
|
|
addLogFlag(flag, ...subFlags) {
|
|
if (this.logging()) {
|
|
if (subFlags.length) {
|
|
flag += `(${subFlags.map(f => (f ? 1 : 0)).join("")})`;
|
|
}
|
|
this._logFlags.push(flag);
|
|
}
|
|
}
|
|
|
|
logState(suffix) {
|
|
if (!this.logging()) {
|
|
return;
|
|
}
|
|
|
|
let getTabString = tab => {
|
|
let tabString = "";
|
|
|
|
let state = this.getTabState(tab);
|
|
let isWarming = this.warmingTabs.has(tab);
|
|
let isCached = this.tabLayerCache.includes(tab);
|
|
let isClosing = tab.closing;
|
|
let linkedBrowser = tab.linkedBrowser;
|
|
let isActive = linkedBrowser && linkedBrowser.docShellIsActive;
|
|
let isRendered = linkedBrowser && linkedBrowser.renderLayers;
|
|
let isPiP =
|
|
linkedBrowser &&
|
|
lazy.PictureInPicture.isOriginatingBrowser(linkedBrowser);
|
|
|
|
if (tab === this.lastVisibleTab) {
|
|
tabString += "V";
|
|
}
|
|
if (tab === this.loadingTab) {
|
|
tabString += "L";
|
|
}
|
|
if (tab === this.requestedTab) {
|
|
tabString += "R";
|
|
}
|
|
if (tab === this.blankTab) {
|
|
tabString += "B";
|
|
}
|
|
if (this.maybeVisibleTabs.has(tab)) {
|
|
tabString += "M";
|
|
}
|
|
|
|
let extraStates = "";
|
|
if (isWarming) {
|
|
extraStates += "W";
|
|
}
|
|
if (isCached) {
|
|
extraStates += "C";
|
|
}
|
|
if (isClosing) {
|
|
extraStates += "X";
|
|
}
|
|
if (isActive) {
|
|
extraStates += "A";
|
|
}
|
|
if (isRendered) {
|
|
extraStates += "R";
|
|
}
|
|
if (isPiP) {
|
|
extraStates += "P";
|
|
}
|
|
if (extraStates != "") {
|
|
tabString += `(${extraStates})`;
|
|
}
|
|
|
|
switch (state) {
|
|
case this.STATE_LOADED: {
|
|
tabString += "(loaded)";
|
|
break;
|
|
}
|
|
case this.STATE_LOADING: {
|
|
tabString += "(loading)";
|
|
break;
|
|
}
|
|
case this.STATE_UNLOADING: {
|
|
tabString += "(unloading)";
|
|
break;
|
|
}
|
|
case this.STATE_UNLOADED: {
|
|
tabString += "(unloaded)";
|
|
break;
|
|
}
|
|
}
|
|
|
|
return tabString;
|
|
};
|
|
|
|
let accum = "";
|
|
|
|
// This is a bit tricky to read, but what we're doing here is collapsing
|
|
// identical tab states down to make the overal string shorter and easier
|
|
// to read, and we move all simply unloaded tabs to the back of the list.
|
|
// I.e., we turn
|
|
// "0:(unloaded) 1:(unloaded) 2:(unloaded) 3:(loaded)""
|
|
// into
|
|
// "3:(loaded) 0...2:(unloaded)"
|
|
let tabStrings = this.tabbrowser.tabs.map(t => getTabString(t));
|
|
let lastMatch = -1;
|
|
let unloadedTabsStrings = [];
|
|
for (let i = 0; i <= tabStrings.length; i++) {
|
|
if (i > 0) {
|
|
if (i < tabStrings.length && tabStrings[i] == tabStrings[lastMatch]) {
|
|
continue;
|
|
}
|
|
|
|
if (tabStrings[lastMatch] == "(unloaded)") {
|
|
if (lastMatch == i - 1) {
|
|
unloadedTabsStrings.push(lastMatch.toString());
|
|
} else {
|
|
unloadedTabsStrings.push(`${lastMatch}...${i - 1}`);
|
|
}
|
|
} else if (lastMatch == i - 1) {
|
|
accum += `${lastMatch}:${tabStrings[lastMatch]} `;
|
|
} else {
|
|
accum += `${lastMatch}...${i - 1}:${tabStrings[lastMatch]} `;
|
|
}
|
|
}
|
|
|
|
lastMatch = i;
|
|
}
|
|
|
|
if (unloadedTabsStrings.length) {
|
|
accum += `${unloadedTabsStrings.join(",")}:(unloaded) `;
|
|
}
|
|
|
|
accum += "cached: " + this.tabLayerCache.length + " ";
|
|
|
|
if (this._logFlags.length) {
|
|
accum += `[${this._logFlags.join(",")}] `;
|
|
this._logFlags = [];
|
|
}
|
|
|
|
// It can be annoying to read through the entirety of a log string just
|
|
// to check if something changed or not. So if we can tell that nothing
|
|
// changed, just write "unchanged" to save the reader's time.
|
|
let logString;
|
|
if (this._lastLogString == accum) {
|
|
accum = "unchanged";
|
|
} else {
|
|
this._lastLogString = accum;
|
|
}
|
|
logString = `ATS: ${accum}{${suffix}}`;
|
|
|
|
if (this._useDumpForLogging) {
|
|
dump(logString + "\n");
|
|
} else {
|
|
Services.console.logStringMessage(logString);
|
|
}
|
|
}
|
|
|
|
noteMakingTabVisibleWithoutLayers() {
|
|
// We're making the tab visible even though we haven't yet got layers for it.
|
|
// It's hard to know which composite the layers will first be available in (and
|
|
// the parent process might not even get MozAfterPaint delivered for it), so just
|
|
// give up measuring this for now. :(
|
|
TelemetryStopwatch.cancel("FX_TAB_SWITCH_COMPOSITE_E10S_MS", this.window);
|
|
}
|
|
|
|
notePaint(event) {
|
|
if (this.switchPaintId != -1 && event.transactionId >= this.switchPaintId) {
|
|
if (
|
|
TelemetryStopwatch.running(
|
|
"FX_TAB_SWITCH_COMPOSITE_E10S_MS",
|
|
this.window
|
|
)
|
|
) {
|
|
let time = TelemetryStopwatch.timeElapsed(
|
|
"FX_TAB_SWITCH_COMPOSITE_E10S_MS",
|
|
this.window
|
|
);
|
|
if (time != -1) {
|
|
TelemetryStopwatch.finish(
|
|
"FX_TAB_SWITCH_COMPOSITE_E10S_MS",
|
|
this.window
|
|
);
|
|
}
|
|
}
|
|
let { innerWindowId } = this.window.windowGlobalChild;
|
|
ChromeUtils.addProfilerMarker("AsyncTabSwitch:Composited", {
|
|
innerWindowId,
|
|
});
|
|
this.switchPaintId = -1;
|
|
}
|
|
}
|
|
|
|
noteTabRequested(tab, tabState) {
|
|
if (lazy.gTabWarmingEnabled) {
|
|
let warmingState = "disqualified";
|
|
|
|
if (this.canWarmTab(tab)) {
|
|
if (tabState == this.STATE_LOADING) {
|
|
warmingState = "stillLoading";
|
|
} else if (tabState == this.STATE_LOADED) {
|
|
warmingState = "loaded";
|
|
} else if (
|
|
tabState == this.STATE_UNLOADING ||
|
|
tabState == this.STATE_UNLOADED
|
|
) {
|
|
// At this point, if the tab's browser was being inserted
|
|
// lazily, we never had a chance to warm it up, and unfortunately
|
|
// there's no great way to detect that case. Those cases will
|
|
// end up in the "notWarmed" bucket, along with legitimate cases
|
|
// where tabs could have been warmed but weren't.
|
|
warmingState = "notWarmed";
|
|
}
|
|
}
|
|
|
|
Services.telemetry
|
|
.getHistogramById("FX_TAB_SWITCH_REQUEST_TAB_WARMING_STATE")
|
|
.add(warmingState);
|
|
}
|
|
}
|
|
|
|
noteStartTabSwitch() {
|
|
TelemetryStopwatch.cancel("FX_TAB_SWITCH_TOTAL_E10S_MS", this.window);
|
|
TelemetryStopwatch.start("FX_TAB_SWITCH_TOTAL_E10S_MS", this.window);
|
|
|
|
if (
|
|
TelemetryStopwatch.running("FX_TAB_SWITCH_COMPOSITE_E10S_MS", this.window)
|
|
) {
|
|
TelemetryStopwatch.cancel("FX_TAB_SWITCH_COMPOSITE_E10S_MS", this.window);
|
|
}
|
|
TelemetryStopwatch.start("FX_TAB_SWITCH_COMPOSITE_E10S_MS", this.window);
|
|
let { innerWindowId } = this.window.windowGlobalChild;
|
|
ChromeUtils.addProfilerMarker("AsyncTabSwitch:Start", { innerWindowId });
|
|
}
|
|
|
|
noteFinishTabSwitch() {
|
|
// After this point the tab has switched from the content thread's point of view.
|
|
// The changes will be visible after the next refresh driver tick + composite.
|
|
let time = TelemetryStopwatch.timeElapsed(
|
|
"FX_TAB_SWITCH_TOTAL_E10S_MS",
|
|
this.window
|
|
);
|
|
if (time != -1) {
|
|
TelemetryStopwatch.finish("FX_TAB_SWITCH_TOTAL_E10S_MS", this.window);
|
|
this.log("DEBUG: tab switch time = " + time);
|
|
let { innerWindowId } = this.window.windowGlobalChild;
|
|
ChromeUtils.addProfilerMarker("AsyncTabSwitch:Finish", { innerWindowId });
|
|
}
|
|
}
|
|
|
|
noteSpinnerDisplayed() {
|
|
this.assert(!this.spinnerTab);
|
|
let browser = this.requestedTab.linkedBrowser;
|
|
this.assert(browser.isRemoteBrowser);
|
|
TelemetryStopwatch.start("FX_TAB_SWITCH_SPINNER_VISIBLE_MS", this.window);
|
|
// We have a second, similar probe for capturing recordings of
|
|
// when the spinner is displayed for very long periods.
|
|
TelemetryStopwatch.start(
|
|
"FX_TAB_SWITCH_SPINNER_VISIBLE_LONG_MS",
|
|
this.window
|
|
);
|
|
let { innerWindowId } = this.window.windowGlobalChild;
|
|
ChromeUtils.addProfilerMarker("AsyncTabSwitch:SpinnerShown", {
|
|
innerWindowId,
|
|
});
|
|
Services.telemetry
|
|
.getHistogramById("FX_TAB_SWITCH_SPINNER_VISIBLE_TRIGGER")
|
|
.add(this._loadTimerClearedBy);
|
|
if (AppConstants.NIGHTLY_BUILD) {
|
|
Services.obs.notifyObservers(null, "tabswitch-spinner");
|
|
}
|
|
}
|
|
|
|
noteSpinnerHidden() {
|
|
this.assert(this.spinnerTab);
|
|
this.log(
|
|
"DEBUG: spinner time = " +
|
|
TelemetryStopwatch.timeElapsed(
|
|
"FX_TAB_SWITCH_SPINNER_VISIBLE_MS",
|
|
this.window
|
|
)
|
|
);
|
|
TelemetryStopwatch.finish("FX_TAB_SWITCH_SPINNER_VISIBLE_MS", this.window);
|
|
TelemetryStopwatch.finish(
|
|
"FX_TAB_SWITCH_SPINNER_VISIBLE_LONG_MS",
|
|
this.window
|
|
);
|
|
let { innerWindowId } = this.window.windowGlobalChild;
|
|
ChromeUtils.addProfilerMarker("AsyncTabSwitch:SpinnerHidden", {
|
|
innerWindowId,
|
|
});
|
|
// we do not get a onPaint after displaying the spinner
|
|
this._loadTimerClearedBy = "none";
|
|
}
|
|
}
|