/* -*- 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/. */ { // start private scope for gBrowser /** * A set of known icons to use for internal pages. These are hardcoded so we can * start loading them faster than ContentLinkHandler would normally find them. */ const FAVICON_DEFAULTS = { "about:newtab": "chrome://branding/content/icon32.png", "about:home": "chrome://branding/content/icon32.png", "about:welcome": "chrome://branding/content/icon32.png", "about:privatebrowsing": "chrome://browser/skin/privatebrowsing/favicon.svg", }; const { LOAD_FLAGS_NONE, LOAD_FLAGS_FROM_EXTERNAL, LOAD_FLAGS_FIRST_LOAD, LOAD_FLAGS_DISALLOW_INHERIT_PRINCIPAL, LOAD_FLAGS_ALLOW_THIRD_PARTY_FIXUP, LOAD_FLAGS_FIXUP_SCHEME_TYPOS, LOAD_FLAGS_FORCE_ALLOW_DATA_URI, LOAD_FLAGS_DISABLE_TRR, } = Ci.nsIWebNavigation; /** * Updates the User Context UI indicators if the browser is in a non-default context */ function updateUserContextUIIndicator() { function replaceContainerClass(classType, element, value) { let prefix = "identity-" + classType + "-"; if (value && element.classList.contains(prefix + value)) { return; } for (let className of element.classList) { if (className.startsWith(prefix)) { element.classList.remove(className); } } if (value) { element.classList.add(prefix + value); } } let hbox = document.getElementById("userContext-icons"); let userContextId = gBrowser.selectedBrowser.getAttribute("usercontextid"); if (!userContextId) { replaceContainerClass("color", hbox, ""); hbox.hidden = true; return; } let identity = ContextualIdentityService.getPublicIdentityFromId(userContextId); if (!identity) { replaceContainerClass("color", hbox, ""); hbox.hidden = true; return; } replaceContainerClass("color", hbox, identity.color); let label = ContextualIdentityService.getUserContextLabel(userContextId); document.getElementById("userContext-label").setAttribute("value", label); // Also set the container label as the tooltip so we can only show the icon // in small windows. hbox.setAttribute("tooltiptext", label); let indicator = document.getElementById("userContext-indicator"); replaceContainerClass("icon", indicator, identity.icon); hbox.hidden = false; } window._gBrowser = { init() { ChromeUtils.defineModuleGetter( this, "AsyncTabSwitcher", "resource:///modules/AsyncTabSwitcher.jsm" ); ChromeUtils.defineESModuleGetters(this, { UrlbarProviderOpenTabs: "resource:///modules/UrlbarProviderOpenTabs.sys.mjs", PictureInPicture: "resource://gre/modules/PictureInPicture.sys.mjs", }); XPCOMUtils.defineLazyServiceGetters(this, { MacSharingService: [ "@mozilla.org/widget/macsharingservice;1", "nsIMacSharingService", ], }); XPCOMUtils.defineLazyGetter(this, "tabLocalization", () => { return new Localization( ["browser/tabbrowser.ftl", "branding/brand.ftl"], true ); }); if (AppConstants.MOZ_CRASHREPORTER) { ChromeUtils.defineModuleGetter( this, "TabCrashHandler", "resource:///modules/ContentCrashHandlers.jsm" ); } Services.obs.addObserver(this, "contextual-identity-updated"); Services.els.addSystemEventListener(document, "keydown", this, false); Services.els.addSystemEventListener(document, "keypress", this, false); document.addEventListener("visibilitychange", this); window.addEventListener("framefocusrequested", this); this.tabContainer.init(); this._setupInitialBrowserAndTab(); if ( Services.prefs.getIntPref("browser.display.document_color_use") == 2 ) { this.tabpanels.style.backgroundColor = Services.prefs.getBoolPref( "browser.display.use_system_colors" ) ? "canvas" : Services.prefs.getCharPref("browser.display.background_color"); } this._setFindbarData(); // We take over setting the document title, so remove the l10n id to // avoid it being re-translated and overwriting document content if // we ever switch languages at runtime. After a language change, the // window title will update at the next tab or location change. document.querySelector("title").removeAttribute("data-l10n-id"); this._setupEventListeners(); this._initialized = true; }, ownerGlobal: window, ownerDocument: document, closingTabsEnum: { ALL: 0, OTHER: 1, TO_START: 2, TO_END: 3, MULTI_SELECTED: 4, }, _lastRelatedTabMap: new WeakMap(), mProgressListeners: [], mTabsProgressListeners: [], _tabListeners: new Map(), _tabFilters: new Map(), _isBusy: false, _awaitingToggleCaretBrowsingPrompt: false, arrowKeysShouldWrap: AppConstants == "macosx", _previewMode: false, _lastFindValue: "", _contentWaitingCount: 0, _tabLayerCache: [], tabAnimationsInProgress: 0, /** * Binding from browser to tab */ _tabForBrowser: new WeakMap(), /** * `_createLazyBrowser` will define properties on the unbound lazy browser * which correspond to properties defined in MozBrowser which will be bound to * the browser when it is inserted into the document. If any of these * properties are accessed by consumers, `_insertBrowser` is called and * the browser is inserted to ensure that things don't break. This list * provides the names of properties that may be called while the browser * is in its unbound (lazy) state. */ _browserBindingProperties: [ "canGoBack", "canGoForward", "goBack", "goForward", "permitUnload", "reload", "reloadWithFlags", "stop", "loadURI", "fixupAndLoadURIString", "gotoIndex", "currentURI", "documentURI", "remoteType", "preferences", "imageDocument", "isRemoteBrowser", "messageManager", "getTabBrowser", "finder", "fastFind", "sessionHistory", "contentTitle", "characterSet", "fullZoom", "textZoom", "tabHasCustomZoom", "webProgress", "addProgressListener", "removeProgressListener", "audioPlaybackStarted", "audioPlaybackStopped", "resumeMedia", "mute", "unmute", "blockedPopups", "lastURI", "purgeSessionHistory", "stopScroll", "startScroll", "userTypedValue", "userTypedClear", "didStartLoadSinceLastUserTyping", "audioMuted", ], _removingTabs: new Set(), _multiSelectedTabsSet: new WeakSet(), _lastMultiSelectedTabRef: null, _clearMultiSelectionLocked: false, _clearMultiSelectionLockedOnce: false, _multiSelectChangeStarted: false, _multiSelectChangeAdditions: new Set(), _multiSelectChangeRemovals: new Set(), _multiSelectChangeSelected: false, /** * Tab close requests are ignored if the window is closing anyway, * e.g. when holding Ctrl+W. */ _windowIsClosing: false, preloadedBrowser: null, /** * This defines a proxy which allows us to access browsers by * index without actually creating a full array of browsers. */ browsers: new Proxy([], { has: (target, name) => { if (typeof name == "string" && Number.isInteger(parseInt(name))) { return name in gBrowser.tabs; } return false; }, get: (target, name) => { if (name == "length") { return gBrowser.tabs.length; } if (typeof name == "string" && Number.isInteger(parseInt(name))) { if (!(name in gBrowser.tabs)) { return undefined; } return gBrowser.tabs[name].linkedBrowser; } return target[name]; }, }), /** * List of browsers whose docshells must be active in order for print preview * to work. */ _printPreviewBrowsers: new Set(), _switcher: null, _soundPlayingAttrRemovalTimer: 0, _hoverTabTimer: null, _featureCallout: null, _featureCalloutPanelId: null, get tabContainer() { delete this.tabContainer; return (this.tabContainer = document.getElementById("tabbrowser-tabs")); }, get tabs() { return this.tabContainer.allTabs; }, get tabbox() { delete this.tabbox; return (this.tabbox = document.getElementById("tabbrowser-tabbox")); }, get tabpanels() { delete this.tabpanels; return (this.tabpanels = document.getElementById("tabbrowser-tabpanels")); }, addEventListener(...args) { this.tabpanels.addEventListener(...args); }, removeEventListener(...args) { this.tabpanels.removeEventListener(...args); }, dispatchEvent(...args) { return this.tabpanels.dispatchEvent(...args); }, get visibleTabs() { return this.tabContainer._getVisibleTabs(); }, get _numPinnedTabs() { for (var i = 0; i < this.tabs.length; i++) { if (!this.tabs[i].pinned) { break; } } return i; }, set selectedTab(val) { if ( gSharedTabWarning.willShowSharedTabWarning(val) || document.documentElement.hasAttribute("window-modal-open") || (gNavToolbox.collapsed && !this._allowTabChange) ) { return; } // Update the tab this.tabbox.selectedTab = val; }, get selectedTab() { return this._selectedTab; }, get selectedBrowser() { return this._selectedBrowser; }, get featureCallout() { return this._featureCallout; }, set featureCallout(val) { this._featureCallout = val; }, get instantiateFeatureCalloutTour() { return this._instantiateFeatureCalloutTour; }, get featureCalloutPanelId() { return this._featureCalloutPanelId; }, _instantiateFeatureCalloutTour(browser, panelId) { this._featureCalloutPanelId = panelId; const { FeatureCallout } = ChromeUtils.importESModule( "resource:///modules/FeatureCallout.sys.mjs" ); // Note - once we have additional browser chrome messages, // only use PDF.js pref value when navigating to PDF viewer this._featureCallout = new FeatureCallout({ win: window, browser, prefName: "browser.pdfjs.feature-tour", page: "chrome", theme: { preset: "pdfjs", simulateContent: true }, }); }, _setupInitialBrowserAndTab() { // See browser.js for the meaning of window.arguments. // Bug 1485961 covers making this more sane. let userContextId = window.arguments && window.arguments[5]; let openWindowInfo = window.docShell.treeOwner .QueryInterface(Ci.nsIInterfaceRequestor) .getInterface(Ci.nsIAppWindow).initialOpenWindowInfo; if (!openWindowInfo && window.arguments && window.arguments[11]) { openWindowInfo = window.arguments[11]; } let tabArgument = gBrowserInit.getTabToAdopt(); // If we have a tab argument with browser, we use its remoteType. Otherwise, // if e10s is disabled or there's a parent process opener (e.g. parent // process about: page) for the content tab, we use a parent // process remoteType. Otherwise, we check the URI to determine // what to do - if there isn't one, we default to the default remote type. // // When adopting a tab, we'll also use that tab's browsingContextGroupId, // if available, to ensure we don't spawn a new process. let remoteType; let initialBrowsingContextGroupId; if (tabArgument && tabArgument.hasAttribute("usercontextid")) { // The window's first argument is a tab if and only if we are swapping tabs. // We must set the browser's usercontextid so that the newly created remote // tab child has the correct usercontextid. userContextId = parseInt(tabArgument.getAttribute("usercontextid"), 10); } if (tabArgument && tabArgument.linkedBrowser) { remoteType = tabArgument.linkedBrowser.remoteType; initialBrowsingContextGroupId = tabArgument.linkedBrowser.browsingContext?.group.id; } else if (openWindowInfo) { userContextId = openWindowInfo.originAttributes.userContextId; if (openWindowInfo.isRemote) { remoteType = E10SUtils.DEFAULT_REMOTE_TYPE; } else { remoteType = E10SUtils.NOT_REMOTE; } } else { let uriToLoad = gBrowserInit.uriToLoadPromise; if (uriToLoad && Array.isArray(uriToLoad)) { uriToLoad = uriToLoad[0]; // we only care about the first item } if (uriToLoad && typeof uriToLoad == "string") { let oa = E10SUtils.predictOriginAttributes({ window, userContextId, }); remoteType = E10SUtils.getRemoteTypeForURI( uriToLoad, gMultiProcessBrowser, gFissionBrowser, E10SUtils.DEFAULT_REMOTE_TYPE, null, oa ); } else { // If we reach here, we don't have the url to load. This means that // `uriToLoad` is most likely a promise which is waiting on SessionStore // initialization. We can't delay setting up the browser here, as that // would mean that `gBrowser.selectedBrowser` might not always exist, // which is the current assumption. // In this case we default to the privileged about process as that's // the best guess we can make, and we'll likely need it eventually. remoteType = E10SUtils.PRIVILEGEDABOUT_REMOTE_TYPE; } } let createOptions = { uriIsAboutBlank: false, userContextId, initialBrowsingContextGroupId, remoteType, openWindowInfo, }; let browser = this.createBrowser(createOptions); browser.setAttribute("primary", "true"); if (gBrowserAllowScriptsToCloseInitialTabs) { browser.setAttribute("allowscriptstoclose", "true"); } browser.droppedLinkHandler = handleDroppedLink; browser.loadURI = URILoadingWrapper.loadURI.bind( URILoadingWrapper, browser ); browser.fixupAndLoadURIString = URILoadingWrapper.fixupAndLoadURIString.bind( URILoadingWrapper, browser ); let uniqueId = this._generateUniquePanelID(); let panel = this.getPanel(browser); panel.id = uniqueId; this.tabpanels.appendChild(panel); let tab = this.tabs[0]; tab.linkedPanel = uniqueId; this._selectedTab = tab; this._selectedBrowser = browser; tab.permanentKey = browser.permanentKey; tab._tPos = 0; tab._fullyOpen = true; tab.linkedBrowser = browser; if (userContextId) { tab.setAttribute("usercontextid", userContextId); ContextualIdentityService.setTabStyle(tab); } this._tabForBrowser.set(browser, tab); this._appendStatusPanel(); // This is the initial browser, so it's usually active; the default is false // so we have to update it: browser.docShellIsActive = this.shouldActivateDocShell(browser); // Hook the browser up with a progress listener. let tabListener = new TabProgressListener(tab, browser, true, false); let filter = Cc[ "@mozilla.org/appshell/component/browser-status-filter;1" ].createInstance(Ci.nsIWebProgress); filter.addProgressListener(tabListener, Ci.nsIWebProgress.NOTIFY_ALL); this._tabListeners.set(tab, tabListener); this._tabFilters.set(tab, filter); browser.webProgress.addProgressListener( filter, Ci.nsIWebProgress.NOTIFY_ALL ); }, /** * BEGIN FORWARDED BROWSER PROPERTIES. IF YOU ADD A PROPERTY TO THE BROWSER ELEMENT * MAKE SURE TO ADD IT HERE AS WELL. */ get canGoBack() { return this.selectedBrowser.canGoBack; }, get canGoForward() { return this.selectedBrowser.canGoForward; }, goBack(requireUserInteraction) { return this.selectedBrowser.goBack(requireUserInteraction); }, goForward(requireUserInteraction) { return this.selectedBrowser.goForward(requireUserInteraction); }, reload() { return this.selectedBrowser.reload(); }, reloadWithFlags(aFlags) { return this.selectedBrowser.reloadWithFlags(aFlags); }, stop() { return this.selectedBrowser.stop(); }, /** * throws exception for unknown schemes */ loadURI(uri, params) { return this.selectedBrowser.loadURI(uri, params); }, /** * throws exception for unknown schemes */ fixupAndLoadURIString(uriString, params) { return this.selectedBrowser.fixupAndLoadURIString(uriString, params); }, gotoIndex(aIndex) { return this.selectedBrowser.gotoIndex(aIndex); }, get currentURI() { return this.selectedBrowser.currentURI; }, get finder() { return this.selectedBrowser.finder; }, get docShell() { return this.selectedBrowser.docShell; }, get webNavigation() { return this.selectedBrowser.webNavigation; }, get webProgress() { return this.selectedBrowser.webProgress; }, get contentWindow() { return this.selectedBrowser.contentWindow; }, get sessionHistory() { return this.selectedBrowser.sessionHistory; }, get markupDocumentViewer() { return this.selectedBrowser.markupDocumentViewer; }, get contentDocument() { return this.selectedBrowser.contentDocument; }, get contentTitle() { return this.selectedBrowser.contentTitle; }, get contentPrincipal() { return this.selectedBrowser.contentPrincipal; }, get securityUI() { return this.selectedBrowser.securityUI; }, set fullZoom(val) { this.selectedBrowser.fullZoom = val; }, get fullZoom() { return this.selectedBrowser.fullZoom; }, set textZoom(val) { this.selectedBrowser.textZoom = val; }, get textZoom() { return this.selectedBrowser.textZoom; }, get isSyntheticDocument() { return this.selectedBrowser.isSyntheticDocument; }, set userTypedValue(val) { this.selectedBrowser.userTypedValue = val; }, get userTypedValue() { return this.selectedBrowser.userTypedValue; }, _setFindbarData() { // Ensure we know what the find bar key is in the content process: let { sharedData } = Services.ppmm; if (!sharedData.has("Findbar:Shortcut")) { let keyEl = document.getElementById("key_find"); let mods = keyEl .getAttribute("modifiers") .replace( /accel/i, AppConstants.platform == "macosx" ? "meta" : "control" ); sharedData.set("Findbar:Shortcut", { key: keyEl.getAttribute("key"), shiftKey: mods.includes("shift"), ctrlKey: mods.includes("control"), altKey: mods.includes("alt"), metaKey: mods.includes("meta"), }); } }, isFindBarInitialized(aTab) { return (aTab || this.selectedTab)._findBar != undefined; }, /** * Get the already constructed findbar */ getCachedFindBar(aTab = this.selectedTab) { return aTab._findBar; }, /** * Get the findbar, and create it if it doesn't exist. * @return the find bar (or null if the window or tab is closed/closing in the interim). */ async getFindBar(aTab = this.selectedTab) { let findBar = this.getCachedFindBar(aTab); if (findBar) { return findBar; } // Avoid re-entrancy by caching the promise we're about to return. if (!aTab._pendingFindBar) { aTab._pendingFindBar = this._createFindBar(aTab); } return aTab._pendingFindBar; }, /** * Create a findbar instance. * @param aTab the tab to create the find bar for. * @return the created findbar, or null if the window or tab is closed/closing. */ async _createFindBar(aTab) { let findBar = document.createXULElement("findbar"); let browser = this.getBrowserForTab(aTab); browser.parentNode.insertAdjacentElement("afterend", findBar); await new Promise(r => requestAnimationFrame(r)); delete aTab._pendingFindBar; if (window.closed || aTab.closing) { return null; } findBar.browser = browser; findBar._findField.value = this._lastFindValue; aTab._findBar = findBar; let event = document.createEvent("Events"); event.initEvent("TabFindInitialized", true, false); aTab.dispatchEvent(event); return findBar; }, _appendStatusPanel() { this.selectedBrowser.insertAdjacentElement("afterend", StatusPanel.panel); }, _updateTabBarForPinnedTabs() { this.tabContainer._unlockTabSizing(); this.tabContainer._positionPinnedTabs(); this.tabContainer._setPositionalAttributes(); this.tabContainer._updateCloseButtons(); }, _notifyPinnedStatus(aTab) { // browsingContext is expected to not be defined on discarded tabs. if (aTab.linkedBrowser.browsingContext) { aTab.linkedBrowser.browsingContext.isAppTab = aTab.pinned; } let event = document.createEvent("Events"); event.initEvent(aTab.pinned ? "TabPinned" : "TabUnpinned", true, false); aTab.dispatchEvent(event); }, pinTab(aTab) { if (aTab.pinned) { return; } this.showTab(aTab); this.moveTabTo(aTab, this._numPinnedTabs); aTab.setAttribute("pinned", "true"); this._updateTabBarForPinnedTabs(); this._notifyPinnedStatus(aTab); }, unpinTab(aTab) { if (!aTab.pinned) { return; } this.moveTabTo(aTab, this._numPinnedTabs - 1); aTab.removeAttribute("pinned"); aTab.style.marginInlineStart = ""; aTab._pinnedUnscrollable = false; this._updateTabBarForPinnedTabs(); this._notifyPinnedStatus(aTab); }, previewTab(aTab, aCallback) { let currentTab = this.selectedTab; try { // Suppress focus, ownership and selected tab changes this._previewMode = true; this.selectedTab = aTab; aCallback(); } finally { this.selectedTab = currentTab; this._previewMode = false; } }, syncThrobberAnimations(aTab) { aTab.ownerGlobal.promiseDocumentFlushed(() => { if (!aTab.container) { return; } const animations = Array.from( aTab.container.getElementsByTagName("tab") ) .map(tab => { const throbber = tab.throbber; return throbber ? throbber.getAnimations({ subtree: true }) : []; }) .reduce((a, b) => a.concat(b)) .filter( anim => CSSAnimation.isInstance(anim) && (anim.animationName === "tab-throbber-animation" || anim.animationName === "tab-throbber-animation-rtl") && anim.playState === "running" ); // Synchronize with the oldest running animation, if any. const firstStartTime = Math.min( ...animations.map(anim => anim.startTime === null ? Infinity : anim.startTime ) ); if (firstStartTime === Infinity) { return; } requestAnimationFrame(() => { for (let animation of animations) { // If |animation| has been cancelled since this rAF callback // was scheduled we don't want to set its startTime since // that would restart it. We check for a cancelled animation // by looking for a null currentTime rather than checking // the playState, since reading the playState of // a CSSAnimation object will flush style. if (animation.currentTime !== null) { animation.startTime = firstStartTime; } } }); }); }, getBrowserAtIndex(aIndex) { return this.browsers[aIndex]; }, getBrowserForOuterWindowID(aID) { for (let b of this.browsers) { if (b.outerWindowID == aID) { return b; } } return null; }, getTabForBrowser(aBrowser) { return this._tabForBrowser.get(aBrowser); }, getPanel(aBrowser) { return this.getBrowserContainer(aBrowser).parentNode; }, getBrowserContainer(aBrowser) { return (aBrowser || this.selectedBrowser).parentNode.parentNode; }, getTabNotificationDeck() { if (!this._tabNotificationDeck) { let template = document.getElementById( "tab-notification-deck-template" ); template.replaceWith(template.content); this._tabNotificationDeck = document.getElementById( "tab-notification-deck" ); } return this._tabNotificationDeck; }, _nextNotificationBoxId: 0, getNotificationBox(aBrowser) { let browser = aBrowser || this.selectedBrowser; if (!browser._notificationBox) { browser._notificationBox = new MozElements.NotificationBox(element => { element.setAttribute("notificationside", "top"); element.setAttribute( "name", `tab-notification-box-${this._nextNotificationBoxId++}` ); this.getTabNotificationDeck().append(element); if (browser == this.selectedBrowser) { this._updateVisibleNotificationBox(browser); } }); } return browser._notificationBox; }, readNotificationBox(aBrowser) { let browser = aBrowser || this.selectedBrowser; return browser._notificationBox || null; }, _updateVisibleNotificationBox(aBrowser) { if (!this._tabNotificationDeck) { // If the deck hasn't been created we don't need to create it here. return; } let notificationBox = this.readNotificationBox(aBrowser); this.getTabNotificationDeck().selectedViewName = notificationBox ? notificationBox.stack.getAttribute("name") : ""; }, getTabModalPromptBox(aBrowser) { let browser = aBrowser || this.selectedBrowser; if (!browser.tabModalPromptBox) { browser.tabModalPromptBox = new TabModalPromptBox(browser); } return browser.tabModalPromptBox; }, getTabDialogBox(aBrowser) { if (!aBrowser) { throw new Error("aBrowser is required"); } if (!aBrowser.tabDialogBox) { aBrowser.tabDialogBox = new TabDialogBox(aBrowser); } return aBrowser.tabDialogBox; }, getTabFromAudioEvent(aEvent) { if (!aEvent.isTrusted) { return null; } var browser = aEvent.originalTarget; var tab = this.getTabForBrowser(browser); return tab; }, _callProgressListeners( aBrowser, aMethod, aArguments, aCallGlobalListeners = true, aCallTabsListeners = true ) { var rv = true; function callListeners(listeners, args) { for (let p of listeners) { if (aMethod in p) { try { if (!p[aMethod].apply(p, args)) { rv = false; } } catch (e) { // don't inhibit other listeners console.error(e); } } } } aBrowser = aBrowser || this.selectedBrowser; if (aCallGlobalListeners && aBrowser == this.selectedBrowser) { callListeners(this.mProgressListeners, aArguments); } if (aCallTabsListeners) { aArguments.unshift(aBrowser); callListeners(this.mTabsProgressListeners, aArguments); } return rv; }, /** * Sets an icon for the tab if the URI is defined in FAVICON_DEFAULTS. */ setDefaultIcon(aTab, aURI) { if (aURI && aURI.spec in FAVICON_DEFAULTS) { this.setIcon(aTab, FAVICON_DEFAULTS[aURI.spec]); } }, setIcon( aTab, aIconURL = "", aOriginalURL = aIconURL, aLoadingPrincipal = null ) { let makeString = url => (url instanceof Ci.nsIURI ? url.spec : url); aIconURL = makeString(aIconURL); aOriginalURL = makeString(aOriginalURL); let LOCAL_PROTOCOLS = ["chrome:", "about:", "resource:", "data:"]; if ( aIconURL && !aLoadingPrincipal && !LOCAL_PROTOCOLS.some(protocol => aIconURL.startsWith(protocol)) ) { console.error( `Attempt to set a remote URL ${aIconURL} as a tab icon without a loading principal.` ); return; } let browser = this.getBrowserForTab(aTab); browser.mIconURL = aIconURL; if (aIconURL != aTab.getAttribute("image")) { if (aIconURL) { if (aLoadingPrincipal) { aTab.setAttribute("iconloadingprincipal", aLoadingPrincipal); } else { aTab.removeAttribute("iconloadingprincipal"); } aTab.setAttribute("image", aIconURL); } else { aTab.removeAttribute("image"); aTab.removeAttribute("iconloadingprincipal"); } this._tabAttrModified(aTab, ["image"]); } // The aOriginalURL argument is currently only used by tests. this._callProgressListeners(browser, "onLinkIconAvailable", [ aIconURL, aOriginalURL, ]); }, getIcon(aTab) { let browser = aTab ? this.getBrowserForTab(aTab) : this.selectedBrowser; return browser.mIconURL; }, setPageInfo(aURL, aDescription, aPreviewImage) { if (aURL) { let pageInfo = { url: aURL, description: aDescription, previewImageURL: aPreviewImage, }; PlacesUtils.history.update(pageInfo).catch(console.error); } }, getWindowTitleForBrowser(aBrowser) { let docElement = document.documentElement; let title = ""; // If location bar is hidden and the URL type supports a host, // add the scheme and host to the title to prevent spoofing. // XXX https://bugzilla.mozilla.org/show_bug.cgi?id=22183#c239 try { if (docElement.getAttribute("chromehidden").includes("location")) { const uri = Services.io.createExposableURI(aBrowser.currentURI); let prefix = uri.prePath; if (uri.scheme == "about") { prefix = uri.spec; } else if (uri.scheme == "moz-extension") { const ext = WebExtensionPolicy.getByHostname(uri.host); if (ext && ext.name) { let extensionLabel = document.getElementById( "urlbar-label-extension" ); prefix = `${extensionLabel.value} (${ext.name})`; } } title = prefix + " - "; } } catch (e) { // ignored } if (docElement.hasAttribute("titlepreface")) { title += docElement.getAttribute("titlepreface"); } let tab = this.getTabForBrowser(aBrowser); if (tab._labelIsContentTitle) { // Strip out any null bytes in the content title, since the // underlying widget implementations of nsWindow::SetTitle pass // null-terminated strings to system APIs. title += tab.getAttribute("label").replace(/\0/g, ""); } let dataSuffix = docElement.getAttribute("privatebrowsingmode") == "temporary" ? "Private" : "Default"; if (title) { // We're using a function rather than just using `title` as the // new substring to avoid `$$`, `$'` etc. having a special // meaning to `replace`. // See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_string_as_a_parameter // and the documentation for functions for more info about this. return docElement.dataset["contentTitle" + dataSuffix].replace( "CONTENTTITLE", () => title ); } return docElement.dataset["title" + dataSuffix]; }, updateTitlebar() { document.title = this.getWindowTitleForBrowser(this.selectedBrowser); }, updateCurrentBrowser(aForceUpdate) { let newBrowser = this.getBrowserAtIndex(this.tabContainer.selectedIndex); if (this.selectedBrowser == newBrowser && !aForceUpdate) { return; } let newTab = this.getTabForBrowser(newBrowser); if ( this._featureCallout && this._featureCalloutPanelId !== newTab.linkedPanel ) { this._featureCallout.endTour(true); this._featureCallout = null; } // For now, only check for Feature Callout messages // when viewing PDFs. Later, we can expand this to check // for callout messages on every change of tab location. if ( !this._featureCallout && newBrowser.contentPrincipal.originNoSuffix === "resource://pdf.js" ) { this._instantiateFeatureCalloutTour(newBrowser, newTab.linkedPanel); window.gBrowser.featureCallout.showFeatureCallout(); } if (!aForceUpdate) { TelemetryStopwatch.start("FX_TAB_SWITCH_UPDATE_MS"); if (gMultiProcessBrowser) { this._asyncTabSwitching = true; this._getSwitcher().requestTab(newTab); this._asyncTabSwitching = false; } document.commandDispatcher.lock(); } let oldTab = this.selectedTab; // Preview mode should not reset the owner if (!this._previewMode && !oldTab.selected) { oldTab.owner = null; } let lastRelatedTab = this._lastRelatedTabMap.get(oldTab); if (lastRelatedTab) { if (!lastRelatedTab.selected) { lastRelatedTab.owner = null; } } this._lastRelatedTabMap = new WeakMap(); let oldBrowser = this.selectedBrowser; if (!gMultiProcessBrowser) { oldBrowser.removeAttribute("primary"); oldBrowser.docShellIsActive = false; newBrowser.setAttribute("primary", "true"); newBrowser.docShellIsActive = !document.hidden; } if (gURLBar) { oldBrowser._urlbarSelectionStart = gURLBar.selectionStart; oldBrowser._urlbarSelectionEnd = gURLBar.selectionEnd; } this._selectedBrowser = newBrowser; this._selectedTab = newTab; this.showTab(newTab); this._appendStatusPanel(); this._updateVisibleNotificationBox(newBrowser); let oldBrowserPopupsBlocked = oldBrowser.popupBlocker.getBlockedPopupCount(); let newBrowserPopupsBlocked = newBrowser.popupBlocker.getBlockedPopupCount(); if (oldBrowserPopupsBlocked != newBrowserPopupsBlocked) { newBrowser.popupBlocker.updateBlockedPopupsUI(); } // Update the URL bar. let webProgress = newBrowser.webProgress; this._callProgressListeners( null, "onLocationChange", [webProgress, null, newBrowser.currentURI, 0, true], true, false ); let securityUI = newBrowser.securityUI; if (securityUI) { this._callProgressListeners( null, "onSecurityChange", [webProgress, null, securityUI.state], true, false ); // Include the true final argument to indicate that this event is // simulated (instead of being observed by the webProgressListener). this._callProgressListeners( null, "onContentBlockingEvent", [webProgress, null, newBrowser.getContentBlockingEvents(), true], true, false ); } let listener = this._tabListeners.get(newTab); if (listener && listener.mStateFlags) { this._callProgressListeners( null, "onUpdateCurrentBrowser", [ listener.mStateFlags, listener.mStatus, listener.mMessage, listener.mTotalProgress, ], true, false ); } if (!this._previewMode) { newTab.recordTimeFromUnloadToReload(); newTab.updateLastAccessed(); oldTab.updateLastAccessed(); let oldFindBar = oldTab._findBar; if ( oldFindBar && oldFindBar.findMode == oldFindBar.FIND_NORMAL && !oldFindBar.hidden ) { this._lastFindValue = oldFindBar._findField.value; } this.updateTitlebar(); newTab.removeAttribute("titlechanged"); newTab.attention = false; // The tab has been selected, it's not unselected anymore. // (1) Call the current tab's finishUnselectedTabHoverTimer() // to save a telemetry record. // (2) Call the current browser's unselectedTabHover() with false // to dispatch an event. newTab.finishUnselectedTabHoverTimer(); newBrowser.unselectedTabHover(false); } // If the new tab is busy, and our current state is not busy, then // we need to fire a start to all progress listeners. if (newTab.hasAttribute("busy") && !this._isBusy) { this._isBusy = true; this._callProgressListeners( null, "onStateChange", [ webProgress, null, Ci.nsIWebProgressListener.STATE_START | Ci.nsIWebProgressListener.STATE_IS_NETWORK, 0, ], true, false ); } // If the new tab is not busy, and our current state is busy, then // we need to fire a stop to all progress listeners. if (!newTab.hasAttribute("busy") && this._isBusy) { this._isBusy = false; this._callProgressListeners( null, "onStateChange", [ webProgress, null, Ci.nsIWebProgressListener.STATE_STOP | Ci.nsIWebProgressListener.STATE_IS_NETWORK, 0, ], true, false ); } // TabSelect events are suppressed during preview mode to avoid confusing extensions and other bits of code // that might rely upon the other changes suppressed. // Focus is suppressed in the event that the main browser window is minimized - focusing a tab would restore the window if (!this._previewMode) { // We've selected the new tab, so go ahead and notify listeners. let event = new CustomEvent("TabSelect", { bubbles: true, cancelable: false, detail: { previousTab: oldTab, }, }); newTab.dispatchEvent(event); this._tabAttrModified(oldTab, ["selected"]); this._tabAttrModified(newTab, ["selected"]); this.readNotificationBox(newBrowser)?.shown(); this._startMultiSelectChange(); this._multiSelectChangeSelected = true; this.clearMultiSelectedTabs(); if (this._multiSelectChangeAdditions.size) { // Some tab has been multiselected just before switching tabs. // The tab that was selected at that point should also be multiselected. this.addToMultiSelectedTabs(oldTab); } if (oldBrowser != newBrowser && oldBrowser.getInPermitUnload) { oldBrowser.getInPermitUnload(inPermitUnload => { if (!inPermitUnload) { return; } // Since the user is switching away from a tab that has // a beforeunload prompt active, we remove the prompt. // This prevents confusing user flows like the following: // 1. User attempts to close Firefox // 2. User switches tabs (ingoring a beforeunload prompt) // 3. User returns to tab, presses "Leave page" let promptBox = this.getTabModalPromptBox(oldBrowser); let prompts = promptBox.listPrompts(); // There might not be any prompts here if the tab was closed // while in an onbeforeunload prompt, which will have // destroyed aforementioned prompt already, so check there's // something to remove, first: if (prompts.length) { // NB: This code assumes that the beforeunload prompt // is the top-most prompt on the tab. prompts[prompts.length - 1].abortPrompt(); } }); } if (!gMultiProcessBrowser) { this._adjustFocusBeforeTabSwitch(oldTab, newTab); this._adjustFocusAfterTabSwitch(newTab); gURLBar.afterTabSwitchFocusChange(); } } updateUserContextUIIndicator(); gPermissionPanel.updateSharingIndicator(); // Enable touch events to start a native dragging // session to allow the user to easily drag the selected tab. // This is currently only supported on Windows. oldTab.removeAttribute("touchdownstartsdrag"); newTab.setAttribute("touchdownstartsdrag", "true"); if (!gMultiProcessBrowser) { this.tabContainer._setPositionalAttributes(); document.commandDispatcher.unlock(); let event = new CustomEvent("TabSwitchDone", { bubbles: true, cancelable: true, }); this.dispatchEvent(event); } if (!aForceUpdate) { TelemetryStopwatch.finish("FX_TAB_SWITCH_UPDATE_MS"); } }, _adjustFocusBeforeTabSwitch(oldTab, newTab) { if (this._previewMode) { return; } let oldBrowser = oldTab.linkedBrowser; let newBrowser = newTab.linkedBrowser; oldBrowser._urlbarFocused = gURLBar && gURLBar.focused; if (this._asyncTabSwitching) { newBrowser._userTypedValueAtBeforeTabSwitch = newBrowser.userTypedValue; } if (this.isFindBarInitialized(oldTab)) { let findBar = this.getCachedFindBar(oldTab); oldTab._findBarFocused = !findBar.hidden && findBar._findField.getAttribute("focused") == "true"; } let activeEl = document.activeElement; // If focus is on the old tab, move it to the new tab. if (activeEl == oldTab) { newTab.focus(); } else if ( gMultiProcessBrowser && activeEl != newBrowser && activeEl != newTab ) { // In e10s, if focus isn't already in the tabstrip or on the new browser, // and the new browser's previous focus wasn't in the url bar but focus is // there now, we need to adjust focus further. let keepFocusOnUrlBar = newBrowser && newBrowser._urlbarFocused && gURLBar && gURLBar.focused; if (!keepFocusOnUrlBar) { // Clear focus so that _adjustFocusAfterTabSwitch can detect if // some element has been focused and respect that. document.activeElement.blur(); } } }, _adjustFocusAfterTabSwitch(newTab) { // Don't steal focus from the tab bar. if (document.activeElement == newTab) { return; } let newBrowser = this.getBrowserForTab(newTab); if (newBrowser.hasAttribute("tabDialogShowing")) { newBrowser.tabDialogBox.focus(); return; } if (newBrowser.hasAttribute("tabmodalPromptShowing")) { // If there's a tabmodal prompt showing, focus it. let prompts = newBrowser.tabModalPromptBox.listPrompts(); let prompt = prompts[prompts.length - 1]; // @tabmodalPromptShowing is also set for other tab modal prompts // (e.g. the Payment Request dialog) so there may not be a . // Bug 1492814 will implement this for the Payment Request dialog. if (prompt) { prompt.Dialog.setDefaultFocus(); return; } } // Focus the location bar if it was previously focused for that tab. // In full screen mode, only bother making the location bar visible // if the tab is a blank one. if (newBrowser._urlbarFocused && gURLBar) { let selectURL = () => { if (this._asyncTabSwitching) { // Set _awaitingSetURI flag to suppress popup notification // explicitly while tab switching asynchronously. newBrowser._awaitingSetURI = true; // The onLocationChange event called in updateCurrentBrowser() will // be captured in browser.js, then it calls gURLBar.setURI(). In case // of that doing processing of here before doing above processing, // the selection status that gURLBar.select() does will be releasing // by gURLBar.setURI(). To resolve it, we call gURLBar.select() after // finishing gURLBar.setURI(). const currentActiveElement = document.activeElement; gURLBar.inputField.addEventListener( "SetURI", () => { delete newBrowser._awaitingSetURI; // If the user happened to type into the URL bar for this browser // by the time we got here, focusing will cause the text to be // selected which could cause them to overwrite what they've // already typed in. let userTypedValueAtBeforeTabSwitch = newBrowser._userTypedValueAtBeforeTabSwitch; delete newBrowser._userTypedValueAtBeforeTabSwitch; if ( newBrowser.userTypedValue && newBrowser.userTypedValue != userTypedValueAtBeforeTabSwitch ) { return; } if (currentActiveElement != document.activeElement) { return; } gURLBar.setSelectionRange( newBrowser._urlbarSelectionStart, newBrowser._urlbarSelectionEnd ); }, { once: true } ); } else { gURLBar.setSelectionRange( newBrowser._urlbarSelectionStart, newBrowser._urlbarSelectionEnd ); } }; // This inDOMFullscreen attribute indicates that the page has something // such as a video in fullscreen mode. Opening a new tab will cancel // fullscreen mode, so we need to wait for that to happen and then // select the url field. if (window.document.documentElement.hasAttribute("inDOMFullscreen")) { window.addEventListener("MozDOMFullscreen:Exited", selectURL, { once: true, wantsUntrusted: false, }); return; } if (!window.fullScreen || newTab.isEmpty) { selectURL(); return; } } // Focus the find bar if it was previously focused for that tab. if ( gFindBarInitialized && !gFindBar.hidden && this.selectedTab._findBarFocused ) { gFindBar._findField.focus(); return; } // Don't focus the content area if something has been focused after the // tab switch was initiated. if (gMultiProcessBrowser && document.activeElement != document.body) { return; } // We're now committed to focusing the content area. let fm = Services.focus; let focusFlags = fm.FLAG_NOSCROLL; if (!gMultiProcessBrowser) { let newFocusedElement = fm.getFocusedElementForWindow( window.content, true, {} ); // for anchors, use FLAG_SHOWRING so that it is clear what link was // last clicked when switching back to that tab if ( newFocusedElement && (HTMLAnchorElement.isInstance(newFocusedElement) || newFocusedElement.getAttributeNS( "http://www.w3.org/1999/xlink", "type" ) == "simple") ) { focusFlags |= fm.FLAG_SHOWRING; } } fm.setFocus(newBrowser, focusFlags); }, _tabAttrModified(aTab, aChanged) { if (aTab.closing) { return; } let event = new CustomEvent("TabAttrModified", { bubbles: true, cancelable: false, detail: { changed: aChanged, }, }); aTab.dispatchEvent(event); }, resetBrowserSharing(aBrowser) { let tab = this.getTabForBrowser(aBrowser); if (!tab) { return; } // If WebRTC was used, leave object to enable tracking of grace periods. tab._sharingState = tab._sharingState?.webRTC ? { webRTC: {} } : {}; tab.removeAttribute("sharing"); this._tabAttrModified(tab, ["sharing"]); if (aBrowser == this.selectedBrowser) { gPermissionPanel.updateSharingIndicator(); } }, updateBrowserSharing(aBrowser, aState) { let tab = this.getTabForBrowser(aBrowser); if (!tab) { return; } if (tab._sharingState == null) { tab._sharingState = {}; } tab._sharingState = Object.assign(tab._sharingState, aState); if ("webRTC" in aState) { if (tab._sharingState.webRTC?.sharing) { if (tab._sharingState.webRTC.paused) { tab.removeAttribute("sharing"); } else { tab.setAttribute("sharing", aState.webRTC.sharing); } } else { tab.removeAttribute("sharing"); } this._tabAttrModified(tab, ["sharing"]); } if (aBrowser == this.selectedBrowser) { gPermissionPanel.updateSharingIndicator(); } }, getTabSharingState(aTab) { // Normalize the state object for consumers (ie.extensions). let state = Object.assign( {}, aTab._sharingState && aTab._sharingState.webRTC ); return { camera: !!state.camera, microphone: !!state.microphone, screen: state.screen && state.screen.replace("Paused", ""), }; }, setInitialTabTitle(aTab, aTitle, aOptions = {}) { // Convert some non-content title (actually a url) to human readable title if (!aOptions.isContentTitle && isBlankPageURL(aTitle)) { aTitle = this.tabContainer.emptyTabTitle; } if (aTitle) { if (!aTab.getAttribute("label")) { aTab._labelIsInitialTitle = true; } this._setTabLabel(aTab, aTitle, aOptions); } }, _dataURLRegEx: /^data:[^,]+;base64,/i, setTabTitle(aTab) { var browser = this.getBrowserForTab(aTab); var title = browser.contentTitle; if (aTab.hasAttribute("customizemode")) { title = this.tabLocalization.formatValueSync( "tabbrowser-customizemode-tab-title" ); } // Don't replace an initially set label with the URL while the tab // is loading. if (aTab._labelIsInitialTitle) { if (!title) { return false; } delete aTab._labelIsInitialTitle; } let isURL = false; let isContentTitle = !!title; if (!title) { // See if we can use the URI as the title. if (browser.currentURI.displaySpec) { try { title = Services.io.createExposableURI( browser.currentURI ).displaySpec; } catch (ex) { title = browser.currentURI.displaySpec; } } if (title && !isBlankPageURL(title)) { isURL = true; if (title.length <= 500 || !this._dataURLRegEx.test(title)) { // Try to unescape not-ASCII URIs using the current character set. try { let characterSet = browser.characterSet; title = Services.textToSubURI.unEscapeNonAsciiURI( characterSet, title ); } catch (ex) { /* Do nothing. */ } } } else { // No suitable URI? Fall back to our untitled string. title = this.tabContainer.emptyTabTitle; } } return this._setTabLabel(aTab, title, { isContentTitle, isURL }); }, // While an auth prompt from a base domain different than the current sites is open, we do not want to show the tab title of the current site, // but of the origin that is requesting authentication. // This is to prevent possible auth spoofing scenarios. // See bug 791594 for reference. setTabLabelForAuthPrompts(aTab, aLabel) { return this._setTabLabel(aTab, aLabel); }, _setTabLabel(aTab, aLabel, { beforeTabOpen, isContentTitle, isURL } = {}) { if (!aLabel || aLabel.includes("about:reader?")) { return false; } // If it's a long data: URI that uses base64 encoding, truncate to a // reasonable length rather than trying to display the entire thing, // which can hang or crash the browser. // We can't shorten arbitrary URIs like this, as bidi etc might mean // we need the trailing characters for display. But a base64-encoded // data-URI is plain ASCII, so this is OK for tab-title display. // (See bug 1408854.) if (isURL && aLabel.length > 500 && this._dataURLRegEx.test(aLabel)) { aLabel = aLabel.substring(0, 500) + "\u2026"; } aTab._fullLabel = aLabel; if (!isContentTitle) { // Remove protocol and "www." if (!("_regex_shortenURLForTabLabel" in this)) { this._regex_shortenURLForTabLabel = /^[^:]+:\/\/(?:www\.)?/; } aLabel = aLabel.replace(this._regex_shortenURLForTabLabel, ""); } aTab._labelIsContentTitle = isContentTitle; if (aTab.getAttribute("label") == aLabel) { return false; } let dwu = window.windowUtils; let isRTL = dwu.getDirectionFromText(aLabel) == Ci.nsIDOMWindowUtils.DIRECTION_RTL; aTab.setAttribute("label", aLabel); aTab.setAttribute("labeldirection", isRTL ? "rtl" : "ltr"); aTab.toggleAttribute("labelendaligned", isRTL != (document.dir == "rtl")); // Dispatch TabAttrModified event unless we're setting the label // before the TabOpen event was dispatched. if (!beforeTabOpen) { this._tabAttrModified(aTab, ["label"]); } if (aTab.selected) { this.updateTitlebar(); } return true; }, loadTabs( aURIs, { allowInheritPrincipal, allowThirdPartyFixup, inBackground, newIndex, postDatas, replace, targetTab, triggeringPrincipal, csp, userContextId, fromExternal, } = {} ) { if (!aURIs.length) { return; } // The tab selected after this new tab is closed (i.e. the new tab's // "owner") is the next adjacent tab (i.e. not the previously viewed tab) // when several urls are opened here (i.e. closing the first should select // the next of many URLs opened) or if the pref to have UI links opened in // the background is set (i.e. the link is not being opened modally) // // i.e. // Number of URLs Load UI Links in BG Focus Last Viewed? // == 1 false YES // == 1 true NO // > 1 false/true NO var multiple = aURIs.length > 1; var owner = multiple || inBackground ? null : this.selectedTab; var firstTabAdded = null; var targetTabIndex = -1; if (typeof newIndex != "number") { newIndex = -1; } // When bulk opening tabs, such as from a bookmark folder, we want to insertAfterCurrent // if necessary, but we also will set the bulkOrderedOpen flag so that the bookmarks // open in the same order they are in the folder. if ( multiple && newIndex < 0 && Services.prefs.getBoolPref("browser.tabs.insertAfterCurrent") ) { newIndex = this.selectedTab._tPos + 1; } if (replace) { let browser; if (targetTab) { browser = this.getBrowserForTab(targetTab); targetTabIndex = targetTab._tPos; } else { browser = this.selectedBrowser; targetTabIndex = this.tabContainer.selectedIndex; } let flags = LOAD_FLAGS_NONE; if (allowThirdPartyFixup) { flags |= LOAD_FLAGS_ALLOW_THIRD_PARTY_FIXUP | LOAD_FLAGS_FIXUP_SCHEME_TYPOS; } if (!allowInheritPrincipal) { flags |= LOAD_FLAGS_DISALLOW_INHERIT_PRINCIPAL; } if (fromExternal) { flags |= LOAD_FLAGS_FROM_EXTERNAL; } try { browser.fixupAndLoadURIString(aURIs[0], { flags, postData: postDatas && postDatas[0], triggeringPrincipal, csp, }); } catch (e) { // Ignore failure in case a URI is wrong, so we can continue // opening the next ones. } } else { let params = { allowInheritPrincipal, ownerTab: owner, skipAnimation: multiple, allowThirdPartyFixup, postData: postDatas && postDatas[0], userContextId, triggeringPrincipal, bulkOrderedOpen: multiple, csp, fromExternal, }; if (newIndex > -1) { params.index = newIndex; } firstTabAdded = this.addTab(aURIs[0], params); if (newIndex > -1) { targetTabIndex = firstTabAdded._tPos; } } let tabNum = targetTabIndex; for (let i = 1; i < aURIs.length; ++i) { let params = { allowInheritPrincipal, skipAnimation: true, allowThirdPartyFixup, postData: postDatas && postDatas[i], userContextId, triggeringPrincipal, bulkOrderedOpen: true, csp, fromExternal, }; if (targetTabIndex > -1) { params.index = ++tabNum; } this.addTab(aURIs[i], params); } if (firstTabAdded && !inBackground) { this.selectedTab = firstTabAdded; } }, updateBrowserRemoteness(aBrowser, { newFrameloader, remoteType } = {}) { let isRemote = aBrowser.getAttribute("remote") == "true"; // We have to be careful with this here, as the "no remote type" is null, // not a string. Make sure to check only for undefined, since null is // allowed. if (remoteType === undefined) { throw new Error("Remote type must be set!"); } let shouldBeRemote = remoteType !== E10SUtils.NOT_REMOTE; if (!gMultiProcessBrowser && shouldBeRemote) { throw new Error( "Cannot switch to remote browser in a window " + "without the remote tabs load context." ); } // Abort if we're not going to change anything let oldRemoteType = aBrowser.remoteType; if ( isRemote == shouldBeRemote && !newFrameloader && (!isRemote || oldRemoteType == remoteType) ) { return false; } let tab = this.getTabForBrowser(aBrowser); // aBrowser needs to be inserted now if it hasn't been already. this._insertBrowser(tab); let evt = document.createEvent("Events"); evt.initEvent("BeforeTabRemotenessChange", true, false); tab.dispatchEvent(evt); let wasActive = document.activeElement == aBrowser; // Unhook our progress listener. let filter = this._tabFilters.get(tab); let listener = this._tabListeners.get(tab); aBrowser.webProgress.removeProgressListener(filter); filter.removeProgressListener(listener); // We'll be creating a new listener, so destroy the old one. listener.destroy(); let oldDroppedLinkHandler = aBrowser.droppedLinkHandler; let oldUserTypedValue = aBrowser.userTypedValue; let hadStartedLoad = aBrowser.didStartLoadSinceLastUserTyping(); // Change the "remote" attribute. // Make sure the browser is destroyed so it unregisters from observer notifications aBrowser.destroy(); if (shouldBeRemote) { aBrowser.setAttribute("remote", "true"); aBrowser.setAttribute("remoteType", remoteType); } else { aBrowser.setAttribute("remote", "false"); aBrowser.removeAttribute("remoteType"); } // This call actually switches out our frameloaders. Do this as late as // possible before rebuilding the browser, as we'll need the new browser // state set up completely first. aBrowser.changeRemoteness({ remoteType, }); // Once we have new frameloaders, this call sets the browser back up. aBrowser.construct(); aBrowser.userTypedValue = oldUserTypedValue; if (hadStartedLoad) { aBrowser.urlbarChangeTracker.startedLoad(); } aBrowser.droppedLinkHandler = oldDroppedLinkHandler; // This shouldn't really be necessary, however, this has the side effect // of sending MozLayerTreeReady / MozLayerTreeCleared events for remote // frames, which the tab switcher depends on. // // eslint-disable-next-line no-self-assign aBrowser.docShellIsActive = aBrowser.docShellIsActive; // Create a new tab progress listener for the new browser we just injected, // since tab progress listeners have logic for handling the initial about:blank // load listener = new TabProgressListener(tab, aBrowser, true, false); this._tabListeners.set(tab, listener); filter.addProgressListener(listener, Ci.nsIWebProgress.NOTIFY_ALL); // Restore the progress listener. aBrowser.webProgress.addProgressListener( filter, Ci.nsIWebProgress.NOTIFY_ALL ); // Restore the securityUI state. let securityUI = aBrowser.securityUI; let state = securityUI ? securityUI.state : Ci.nsIWebProgressListener.STATE_IS_INSECURE; this._callProgressListeners( aBrowser, "onSecurityChange", [aBrowser.webProgress, null, state], true, false ); let event = aBrowser.getContentBlockingEvents(); // Include the true final argument to indicate that this event is // simulated (instead of being observed by the webProgressListener). this._callProgressListeners( aBrowser, "onContentBlockingEvent", [aBrowser.webProgress, null, event, true], true, false ); if (shouldBeRemote) { // Switching the browser to be remote will connect to a new child // process so the browser can no longer be considered to be // crashed. tab.removeAttribute("crashed"); // we call updatetabIndicatorAttr here, rather than _tabAttrModified, so as // to be consistent with how "crashed" attribute changes are handled elsewhere this.tabContainer.updateTabIndicatorAttr(tab); } if (wasActive) { aBrowser.focus(); } // If the findbar has been initialised, reset its browser reference. if (this.isFindBarInitialized(tab)) { this.getCachedFindBar(tab).browser = aBrowser; } evt = document.createEvent("Events"); evt.initEvent("TabRemotenessChange", true, false); tab.dispatchEvent(evt); return true; }, updateBrowserRemotenessByURL(aBrowser, aURL, aOptions = {}) { if (!gMultiProcessBrowser) { return this.updateBrowserRemoteness(aBrowser, { remoteType: E10SUtils.NOT_REMOTE, }); } let oldRemoteType = aBrowser.remoteType; let oa = E10SUtils.predictOriginAttributes({ browser: aBrowser }); aOptions.remoteType = E10SUtils.getRemoteTypeForURI( aURL, gMultiProcessBrowser, gFissionBrowser, oldRemoteType, aBrowser.currentURI, oa ); // If this URL can't load in the current browser then flip it to the // correct type. if (oldRemoteType != aOptions.remoteType || aOptions.newFrameloader) { return this.updateBrowserRemoteness(aBrowser, aOptions); } return false; }, createBrowser({ isPreloadBrowser, name, openWindowInfo, remoteType, initialBrowsingContextGroupId, uriIsAboutBlank, userContextId, skipLoad, initiallyActive, } = {}) { let b = document.createXULElement("browser"); // Use the JSM global to create the permanentKey, so that if the // permanentKey is held by something after this window closes, it // doesn't keep the window alive. b.permanentKey = new (Cu.getGlobalForObject(Services).Object)(); // Ensure that SessionStore has flushed any session history state from the // content process before we this browser's remoteness. if (!Services.appinfo.sessionHistoryInParent) { b.prepareToChangeRemoteness = () => SessionStore.prepareToChangeRemoteness(b); b.afterChangeRemoteness = switchId => { let tab = this.getTabForBrowser(b); SessionStore.finishTabRemotenessChange(tab, switchId); return true; }; } const defaultBrowserAttributes = { contextmenu: "contentAreaContextMenu", message: "true", messagemanagergroup: "browsers", tooltip: "aHTMLTooltip", type: "content", }; for (let attribute in defaultBrowserAttributes) { b.setAttribute(attribute, defaultBrowserAttributes[attribute]); } if (gMultiProcessBrowser || remoteType) { b.setAttribute("maychangeremoteness", "true"); } if (!initiallyActive) { b.setAttribute("initiallyactive", "false"); } if (userContextId) { b.setAttribute("usercontextid", userContextId); } if (remoteType) { b.setAttribute("remoteType", remoteType); b.setAttribute("remote", "true"); } if (!isPreloadBrowser) { b.setAttribute("autocompletepopup", "PopupAutoComplete"); } /* * This attribute is meant to describe if the browser is the * preloaded browser. When the preloaded browser is created, the * 'preloadedState' attribute for that browser is set to "preloaded", and * when a new tab is opened, and it is time to show that preloaded * browser, the 'preloadedState' attribute for that browser is removed. * * See more details on Bug 1420285. */ if (isPreloadBrowser) { b.setAttribute("preloadedState", "preloaded"); } // Ensure that the browser will be created in a specific initial // BrowsingContextGroup. This may change the process selection behaviour // of the newly created browser, and is often used in combination with // "remoteType" to ensure that the initial about:blank load occurs // within the same process as another window. if (initialBrowsingContextGroupId) { b.setAttribute( "initialBrowsingContextGroupId", initialBrowsingContextGroupId ); } // Propagate information about the opening content window to the browser. if (openWindowInfo) { b.openWindowInfo = openWindowInfo; } // This will be used by gecko to control the name of the opened // window. if (name) { // XXX: The `name` property is special in HTML and XUL. Should // we use a different attribute name for this? b.setAttribute("name", name); } let notificationbox = document.createXULElement("notificationbox"); notificationbox.setAttribute("notificationside", "top"); let stack = document.createXULElement("stack"); stack.className = "browserStack"; stack.appendChild(b); let browserContainer = document.createXULElement("vbox"); browserContainer.className = "browserContainer"; browserContainer.appendChild(notificationbox); browserContainer.appendChild(stack); let browserSidebarContainer = document.createXULElement("hbox"); browserSidebarContainer.className = "browserSidebarContainer"; browserSidebarContainer.appendChild(browserContainer); // Prevent the superfluous initial load of a blank document // if we're going to load something other than about:blank. if (!uriIsAboutBlank || skipLoad) { b.setAttribute("nodefaultsrc", "true"); } return b; }, _createLazyBrowser(aTab) { let browser = aTab.linkedBrowser; let names = this._browserBindingProperties; for (let i = 0; i < names.length; i++) { let name = names[i]; let getter; let setter; switch (name) { case "audioMuted": getter = () => aTab.hasAttribute("muted"); break; case "contentTitle": getter = () => SessionStore.getLazyTabValue(aTab, "title"); break; case "currentURI": getter = () => { // Avoid recreating the same nsIURI object over and over again... if (browser._cachedCurrentURI) { return browser._cachedCurrentURI; } let url = SessionStore.getLazyTabValue(aTab, "url") || "about:blank"; return (browser._cachedCurrentURI = Services.io.newURI(url)); }; break; case "didStartLoadSinceLastUserTyping": getter = () => () => false; break; case "fullZoom": case "textZoom": getter = () => 1; break; case "tabHasCustomZoom": getter = () => false; break; case "getTabBrowser": getter = () => () => this; break; case "isRemoteBrowser": getter = () => browser.getAttribute("remote") == "true"; break; case "permitUnload": getter = () => () => ({ permitUnload: true }); break; case "reload": case "reloadWithFlags": getter = () => params => { // Wait for load handler to be instantiated before // initializing the reload. aTab.addEventListener( "SSTabRestoring", () => { browser[name](params); }, { once: true } ); gBrowser._insertBrowser(aTab); }; break; case "remoteType": getter = () => { let url = SessionStore.getLazyTabValue(aTab, "url") || "about:blank"; // Avoid recreating the same nsIURI object over and over again... let uri; if (browser._cachedCurrentURI) { uri = browser._cachedCurrentURI; } else { uri = browser._cachedCurrentURI = Services.io.newURI(url); } let oa = E10SUtils.predictOriginAttributes({ browser, userContextId: aTab.getAttribute("usercontextid"), }); return E10SUtils.getRemoteTypeForURI( url, gMultiProcessBrowser, gFissionBrowser, undefined, uri, oa ); }; break; case "userTypedValue": case "userTypedClear": getter = () => SessionStore.getLazyTabValue(aTab, name); break; default: getter = () => { if (AppConstants.NIGHTLY_BUILD) { let message = `[bug 1345098] Lazy browser prematurely inserted via '${name}' property access:\n`; Services.console.logStringMessage(message + new Error().stack); } this._insertBrowser(aTab); return browser[name]; }; setter = value => { if (AppConstants.NIGHTLY_BUILD) { let message = `[bug 1345098] Lazy browser prematurely inserted via '${name}' property access:\n`; Services.console.logStringMessage(message + new Error().stack); } this._insertBrowser(aTab); return (browser[name] = value); }; } Object.defineProperty(browser, name, { get: getter, set: setter, configurable: true, enumerable: true, }); } }, _insertBrowser(aTab, aInsertedOnTabCreation) { "use strict"; // If browser is already inserted or window is closed don't do anything. if (aTab.linkedPanel || window.closed) { return; } let browser = aTab.linkedBrowser; // If browser is a lazy browser, delete the substitute properties. if (this._browserBindingProperties[0] in browser) { for (let name of this._browserBindingProperties) { delete browser[name]; } } let { uriIsAboutBlank, usingPreloadedContent } = aTab._browserParams; delete aTab._browserParams; delete browser._cachedCurrentURI; let panel = this.getPanel(browser); let uniqueId = this._generateUniquePanelID(); panel.id = uniqueId; aTab.linkedPanel = uniqueId; // Inject the into the DOM if necessary. if (!panel.parentNode) { // NB: this appendChild call causes us to run constructors for the // browser element, which fires off a bunch of notifications. Some // of those notifications can cause code to run that inspects our // state, so it is important that the tab element is fully // initialized by this point. this.tabpanels.appendChild(panel); } // wire up a progress listener for the new browser object. let tabListener = new TabProgressListener( aTab, browser, uriIsAboutBlank, usingPreloadedContent ); const filter = Cc[ "@mozilla.org/appshell/component/browser-status-filter;1" ].createInstance(Ci.nsIWebProgress); filter.addProgressListener(tabListener, Ci.nsIWebProgress.NOTIFY_ALL); browser.webProgress.addProgressListener( filter, Ci.nsIWebProgress.NOTIFY_ALL ); this._tabListeners.set(aTab, tabListener); this._tabFilters.set(aTab, filter); browser.droppedLinkHandler = handleDroppedLink; browser.loadURI = URILoadingWrapper.loadURI.bind( URILoadingWrapper, browser ); browser.fixupAndLoadURIString = URILoadingWrapper.fixupAndLoadURIString.bind( URILoadingWrapper, browser ); // Most of the time, we start our browser's docShells out as inactive, // and then maintain activeness in the tab switcher. Preloaded about:newtab's // are already created with their docShell's as inactive, but then explicitly // render their layers to ensure that we can switch to them quickly. We avoid // setting docShellIsActive to false again in this case, since that'd cause // the layers for the preloaded tab to be dropped, and we'd see a flash // of empty content instead. // // So for all browsers except for the preloaded case, we set the browser // docShell to inactive. if (!usingPreloadedContent) { browser.docShellIsActive = false; } // If we transitioned from one browser to two browsers, we need to set // hasSiblings=false on both the existing browser and the new browser. if (this.tabs.length == 2) { this.tabs[0].linkedBrowser.browsingContext.hasSiblings = true; this.tabs[1].linkedBrowser.browsingContext.hasSiblings = true; } else { aTab.linkedBrowser.browsingContext.hasSiblings = this.tabs.length > 1; } if (aTab.userContextId) { browser.setAttribute("usercontextid", aTab.userContextId); } browser.browsingContext.isAppTab = aTab.pinned; // We don't want to update the container icon and identifier if // this is not the selected browser. if (aTab.selected) { updateUserContextUIIndicator(); } // Only fire this event if the tab is already in the DOM // and will be handled by a listener. if (aTab.isConnected) { var evt = new CustomEvent("TabBrowserInserted", { bubbles: true, detail: { insertedOnTabCreation: aInsertedOnTabCreation }, }); aTab.dispatchEvent(evt); } }, _mayDiscardBrowser(aTab, aForceDiscard) { let browser = aTab.linkedBrowser; let action = aForceDiscard ? "unload" : "dontUnload"; if ( !aTab || aTab.selected || aTab.closing || this._windowIsClosing || !browser.isConnected || !browser.isRemoteBrowser || !browser.permitUnload(action).permitUnload ) { return false; } return true; }, discardBrowser(aTab, aForceDiscard) { "use strict"; let browser = aTab.linkedBrowser; if (!this._mayDiscardBrowser(aTab, aForceDiscard)) { return false; } // Reset sharing state. if (aTab._sharingState) { this.resetBrowserSharing(browser); } webrtcUI.forgetStreamsFromBrowserContext(browser.browsingContext); // Set browser parameters for when browser is restored. Also remove // listeners and set up lazy restore data in SessionStore. This must // be done before browser is destroyed and removed from the document. aTab._browserParams = { uriIsAboutBlank: browser.currentURI.spec == "about:blank", remoteType: browser.remoteType, usingPreloadedContent: false, }; SessionStore.resetBrowserToLazyState(aTab); // Remove the tab's filter and progress listener. let filter = this._tabFilters.get(aTab); let listener = this._tabListeners.get(aTab); browser.webProgress.removeProgressListener(filter); filter.removeProgressListener(listener); listener.destroy(); this._tabListeners.delete(aTab); this._tabFilters.delete(aTab); // Reset the findbar and remove it if it is attached to the tab. if (aTab._findBar) { aTab._findBar.close(true); aTab._findBar.remove(); delete aTab._findBar; } // Remove potentially stale attributes. let attributesToRemove = [ "activemedia-blocked", "busy", "pendingicon", "progress", "soundplaying", ]; let removedAttributes = []; for (let attr of attributesToRemove) { if (aTab.hasAttribute(attr)) { removedAttributes.push(attr); aTab.removeAttribute(attr); } } if (removedAttributes.length) { this._tabAttrModified(aTab, removedAttributes); } browser.destroy(); this.getPanel(browser).remove(); aTab.removeAttribute("linkedpanel"); this._createLazyBrowser(aTab); let evt = new CustomEvent("TabBrowserDiscarded", { bubbles: true }); aTab.dispatchEvent(evt); return true; }, /** * Loads a tab with a default null principal unless specified */ addWebTab(aURI, params = {}) { if (!params.triggeringPrincipal) { params.triggeringPrincipal = Services.scriptSecurityManager.createNullPrincipal({ userContextId: params.userContextId, }); } if (params.triggeringPrincipal.isSystemPrincipal) { throw new Error( "System principal should never be passed into addWebTab()" ); } return this.addTab(aURI, params); }, addAdjacentNewTab(tab) { Services.obs.notifyObservers( { wrappedJSObject: new Promise(resolve => { this.selectedTab = this.addTrustedTab(BROWSER_NEW_TAB_URL, { index: tab._tPos + 1, userContextId: tab.userContextId, }); resolve(this.selectedBrowser); }), }, "browser-open-newtab-start" ); }, /** * Must only be used sparingly for content that came from Chrome context * If in doubt use addWebTab */ addTrustedTab(aURI, params = {}) { params.triggeringPrincipal = Services.scriptSecurityManager.getSystemPrincipal(); return this.addTab(aURI, params); }, /** * @returns {object} * The new tab. The return value will be null if the tab couldn't be * created; this shouldn't normally happen, and an error will be logged * to the console if it does. */ addTab( uriString, { allowInheritPrincipal, allowThirdPartyFixup, bulkOrderedOpen, charset, createLazyBrowser, disableTRR, eventDetail, focusUrlBar, forceNotRemote, forceAllowDataURI, fromExternal, inBackground = true, index, lazyTabTitle, name, noInitialLabel, openWindowInfo, openerBrowser, originPrincipal, originStoragePrincipal, ownerTab, pinned, postData, preferredRemoteType, referrerInfo, relatedToCurrent, initialBrowsingContextGroupId, skipAnimation, skipBackgroundNotify, triggeringPrincipal, userContextId, csp, skipLoad = createLazyBrowser, insertTab = true, globalHistoryOptions, triggeringRemoteType, } = {} ) { // all callers of addTab that pass a params object need to pass // a valid triggeringPrincipal. if (!triggeringPrincipal) { throw new Error( "Required argument triggeringPrincipal missing within addTab" ); } if (!UserInteraction.running("browser.tabs.opening", window)) { UserInteraction.start("browser.tabs.opening", "initting", window); } // If we're opening a foreground tab, set the owner by default. ownerTab ??= inBackground ? null : this.selectedTab; // Don't use document.l10n.setAttributes because the FTL file is loaded // lazily and we won't be able to resolve the string. document .getElementById("History:UndoCloseTab") .setAttribute("data-l10n-args", JSON.stringify({ tabCount: 1 })); // if we're adding tabs, we're past interrupt mode, ditch the owner if (this.selectedTab.owner) { this.selectedTab.owner = null; } // Find the tab that opened this one, if any. This is used for // determining positioning, and inherited attributes such as the // user context ID. // // If we have a browser opener (which is usually the browser // element from a remote window.open() call), use that. // // Otherwise, if the tab is related to the current tab (e.g., // because it was opened by a link click), use the selected tab as // the owner. If referrerInfo is set, and we don't have an // explicit relatedToCurrent arg, we assume that the tab is // related to the current tab, since referrerURI is null or // undefined if the tab is opened from an external application or // bookmark (i.e. somewhere other than an existing tab). if (relatedToCurrent == null) { relatedToCurrent = !!(referrerInfo && referrerInfo.originalReferrer); } let openerTab = (openerBrowser && this.getTabForBrowser(openerBrowser)) || (relatedToCurrent && this.selectedTab); // When overflowing, new tabs are scrolled into view smoothly, which // doesn't go well together with the width transition. So we skip the // transition in that case. let animate = !skipAnimation && !pinned && this.tabContainer.getAttribute("overflow") != "true" && !gReduceMotion; let uriInfo = this._determineURIToLoad(uriString, createLazyBrowser); let { uri, uriIsAboutBlank, lazyBrowserURI } = uriInfo; // Have to overwrite this if we're lazy-loading. Should go away // with bug 1818777. ({ uriString } = uriInfo); let usingPreloadedContent = false; let b, t; try { t = this._createTab({ uriString, animate, userContextId, openerTab, createLazyBrowser, skipAnimation, pinned, noInitialLabel, skipBackgroundNotify, }); if (insertTab) { // insert the tab into the tab container in the correct position this._insertTabAtIndex(t, { index, ownerTab, openerTab, pinned, bulkOrderedOpen, }); } ({ browser: b, usingPreloadedContent } = this._createBrowserForTab(t, { uriString, uri, preferredRemoteType, openerBrowser, uriIsAboutBlank, referrerInfo, forceNotRemote, name, initialBrowsingContextGroupId, openWindowInfo, skipLoad, })); if (focusUrlBar) { b._urlbarFocused = true; } // If the caller opts in, create a lazy browser. if (createLazyBrowser) { this._createLazyBrowser(t); if (lazyBrowserURI) { // Lazy browser must be explicitly registered so tab will appear as // a switch-to-tab candidate in autocomplete. this.UrlbarProviderOpenTabs.registerOpenTab( lazyBrowserURI.spec, t.userContextId, PrivateBrowsingUtils.isWindowPrivate(window) ); b.registeredOpenURI = lazyBrowserURI; } // If we're not inserting the tab into the DOM, we can't set the tab // state meaningfully. Session restore (the only caller who does this) // will have to do this work itself later, when the tabs have been // inserted. if (insertTab) { SessionStore.setTabState(t, { entries: [ { url: lazyBrowserURI?.spec || "about:blank", title: lazyTabTitle, triggeringPrincipal_base64: E10SUtils.serializePrincipal(triggeringPrincipal), }, ], // Make sure to store the userContextId associated to the lazy tab // otherwise it would be created as a default tab when recreated on a // session restore (See Bug 1819794). userContextId, }); } } else { this._insertBrowser(t, true); // If we were called by frontend and don't have openWindowInfo, // but we were opened from another browser, set the cross group // opener ID: if (openerBrowser && !openWindowInfo) { b.browsingContext.setCrossGroupOpener( openerBrowser.browsingContext ); } } } catch (e) { console.error("Failed to create tab"); console.error(e); t?.remove(); if (t?.linkedBrowser) { this._tabFilters.delete(t); this._tabListeners.delete(t); this.getPanel(t.linkedBrowser).remove(); } return null; } if (insertTab) { // Fire a TabOpen event this._fireTabOpen(t, eventDetail); this._kickOffBrowserLoad(b, { uri, uriString, usingPreloadedContent, triggeringPrincipal, originPrincipal, originStoragePrincipal, uriIsAboutBlank, allowInheritPrincipal, allowThirdPartyFixup, fromExternal, disableTRR, forceAllowDataURI, skipLoad, referrerInfo, charset, postData, csp, globalHistoryOptions, triggeringRemoteType, }); } // This field is updated regardless if we actually animate // since it's important that we keep this count correct in all cases. this.tabAnimationsInProgress++; if (animate) { requestAnimationFrame(function () { // kick the animation off t.setAttribute("fadein", "true"); }); } // Additionally send pinned tab events if (pinned) { this._notifyPinnedStatus(t); } gSharedTabWarning.tabAdded(t); if (!inBackground) { this.selectedTab = t; } return t; }, _determineURIToLoad(uriString, createLazyBrowser) { uriString = uriString || "about:blank"; let aURIObject = null; try { aURIObject = Services.io.newURI(uriString); } catch (ex) { /* we'll try to fix up this URL later */ } let lazyBrowserURI; if (createLazyBrowser && uriString != "about:blank") { lazyBrowserURI = aURIObject; uriString = "about:blank"; } let uriIsAboutBlank = uriString == "about:blank"; return { uri: aURIObject, uriIsAboutBlank, lazyBrowserURI, uriString }; }, _createTab({ uriString, userContextId, openerTab, createLazyBrowser, skipAnimation, pinned, noInitialLabel, skipBackgroundNotify, animate, }) { var t = document.createXULElement("tab", { is: "tabbrowser-tab" }); // Tag the tab as being created so extension code can ignore events // prior to TabOpen. t.initializingTab = true; t.openerTab = openerTab; // Related tab inherits current tab's user context unless a different // usercontextid is specified if (userContextId == null && openerTab) { userContextId = openerTab.getAttribute("usercontextid") || 0; } if (!noInitialLabel) { if (isBlankPageURL(uriString)) { t.setAttribute("label", this.tabContainer.emptyTabTitle); } else { // Set URL as label so that the tab isn't empty initially. this.setInitialTabTitle(t, uriString, { beforeTabOpen: true, isURL: true, }); } } if (userContextId) { t.setAttribute("usercontextid", userContextId); ContextualIdentityService.setTabStyle(t); } if (skipBackgroundNotify) { t.setAttribute("skipbackgroundnotify", true); } if (pinned) { t.setAttribute("pinned", "true"); } t.classList.add("tabbrowser-tab"); this.tabContainer._unlockTabSizing(); if (!animate) { UserInteraction.update("browser.tabs.opening", "not-animated", window); t.setAttribute("fadein", "true"); // Call _handleNewTab asynchronously as it needs to know if the // new tab is selected. setTimeout( function (tabContainer) { tabContainer._handleNewTab(t); }, 0, this.tabContainer ); } else { UserInteraction.update("browser.tabs.opening", "animated", window); } return t; }, _createBrowserForTab( tab, { uriString, uri, name, preferredRemoteType, openerBrowser, uriIsAboutBlank, referrerInfo, forceNotRemote, initialBrowsingContextGroupId, openWindowInfo, skipLoad, } ) { // If we don't have a preferred remote type, and we have a remote // opener, use the opener's remote type. if (!preferredRemoteType && openerBrowser) { preferredRemoteType = openerBrowser.remoteType; } let { userContextId } = tab; var oa = E10SUtils.predictOriginAttributes({ window, userContextId }); // If URI is about:blank and we don't have a preferred remote type, // then we need to use the referrer, if we have one, to get the // correct remote type for the new tab. if ( uriIsAboutBlank && !preferredRemoteType && referrerInfo && referrerInfo.originalReferrer ) { preferredRemoteType = E10SUtils.getRemoteTypeForURI( referrerInfo.originalReferrer.spec, gMultiProcessBrowser, gFissionBrowser, E10SUtils.DEFAULT_REMOTE_TYPE, null, oa ); } let remoteType = forceNotRemote ? E10SUtils.NOT_REMOTE : E10SUtils.getRemoteTypeForURI( uriString, gMultiProcessBrowser, gFissionBrowser, preferredRemoteType, null, oa ); let b, usingPreloadedContent = false; // If we open a new tab with the newtab URL in the default // userContext, check if there is a preloaded browser ready. if (uriString == BROWSER_NEW_TAB_URL && !userContextId) { b = NewTabPagePreloading.getPreloadedBrowser(window); if (b) { usingPreloadedContent = true; } } if (!b) { // No preloaded browser found, create one. b = this.createBrowser({ remoteType, uriIsAboutBlank, userContextId, initialBrowsingContextGroupId, openWindowInfo, name, skipLoad, }); } tab.linkedBrowser = b; this._tabForBrowser.set(b, tab); tab.permanentKey = b.permanentKey; tab._browserParams = { uriIsAboutBlank, remoteType, usingPreloadedContent, }; // Hack to ensure that the about:newtab, and about:welcome favicon is loaded // instantaneously, to avoid flickering and improve perceived performance. this.setDefaultIcon(tab, uri); return { browser: b, usingPreloadedContent }; }, _kickOffBrowserLoad( browser, { uri, uriString, usingPreloadedContent, triggeringPrincipal, originPrincipal, originStoragePrincipal, uriIsAboutBlank, allowInheritPrincipal, allowThirdPartyFixup, fromExternal, disableTRR, forceAllowDataURI, skipLoad, referrerInfo, charset, postData, csp, globalHistoryOptions, triggeringRemoteType, } ) { if ( !usingPreloadedContent && originPrincipal && originStoragePrincipal && uriString ) { let { URI_INHERITS_SECURITY_CONTEXT } = Ci.nsIProtocolHandler; // Unless we know for sure we're not inheriting principals, // force the about:blank viewer to have the right principal: if (!uri || doGetProtocolFlags(uri) & URI_INHERITS_SECURITY_CONTEXT) { browser.createAboutBlankContentViewer( originPrincipal, originStoragePrincipal ); } } // If we didn't swap docShells with a preloaded browser // then let's just continue loading the page normally. if ( !usingPreloadedContent && (!uriIsAboutBlank || !allowInheritPrincipal) && !skipLoad ) { // pretend the user typed this so it'll be available till // the document successfully loads if (uriString && !gInitialPages.includes(uriString)) { browser.userTypedValue = uriString; } let flags = LOAD_FLAGS_NONE; if (allowThirdPartyFixup) { flags |= LOAD_FLAGS_ALLOW_THIRD_PARTY_FIXUP | LOAD_FLAGS_FIXUP_SCHEME_TYPOS; } if (fromExternal) { flags |= LOAD_FLAGS_FROM_EXTERNAL; } else if (!triggeringPrincipal.isSystemPrincipal) { // XXX this code must be reviewed and changed when bug 1616353 // lands. flags |= LOAD_FLAGS_FIRST_LOAD; } if (!allowInheritPrincipal) { flags |= LOAD_FLAGS_DISALLOW_INHERIT_PRINCIPAL; } if (disableTRR) { flags |= LOAD_FLAGS_DISABLE_TRR; } if (forceAllowDataURI) { flags |= LOAD_FLAGS_FORCE_ALLOW_DATA_URI; } try { browser.fixupAndLoadURIString(uriString, { flags, triggeringPrincipal, referrerInfo, charset, postData, csp, globalHistoryOptions, triggeringRemoteType, }); } catch (ex) { console.error(ex); } } }, createTabsForSessionRestore(restoreTabsLazily, selectTab, tabDataList) { let tabs = []; let tabsFragment = document.createDocumentFragment(); let tabToSelect = null; let hiddenTabs = new Map(); let shouldUpdateForPinnedTabs = false; // We create each tab and browser, but only insert them // into a document fragment so that we can insert them all // together. This prevents synch reflow for each tab // insertion. for (var i = 0; i < tabDataList.length; i++) { let tabData = tabDataList[i]; let userContextId = tabData.userContextId; let select = i == selectTab - 1; let tab; let tabWasReused = false; // Re-use existing selected tab if possible to avoid the overhead of // selecting a new tab. if ( select && this.selectedTab.userContextId == userContextId && !SessionStore.isTabRestoring(this.selectedTab) ) { tabWasReused = true; tab = this.selectedTab; if (!tabData.pinned) { this.unpinTab(tab); } else { this.pinTab(tab); } } // Add a new tab if needed. if (!tab) { let createLazyBrowser = restoreTabsLazily && !select && !tabData.pinned; let url = "about:blank"; if (tabData.entries?.length) { let activeIndex = (tabData.index || tabData.entries.length) - 1; // Ensure the index is in bounds. activeIndex = Math.min(activeIndex, tabData.entries.length - 1); activeIndex = Math.max(activeIndex, 0); url = tabData.entries[activeIndex].url; } let preferredRemoteType = E10SUtils.getRemoteTypeForURI( url, gMultiProcessBrowser, gFissionBrowser, E10SUtils.DEFAULT_REMOTE_TYPE, null, E10SUtils.predictOriginAttributes({ window, userContextId }) ); // If we're creating a lazy browser, let tabbrowser know the future // URI because progress listeners won't get onLocationChange // notification before the browser is inserted. // // Setting noInitialLabel is a perf optimization. Rendering tab labels // would make resizing the tabs more expensive as we're adding them. // Each tab will get its initial label set in restoreTab. tab = this.addTrustedTab(createLazyBrowser ? url : "about:blank", { createLazyBrowser, skipAnimation: true, noInitialLabel: true, userContextId, skipBackgroundNotify: true, bulkOrderedOpen: true, insertTab: false, skipLoad: true, preferredRemoteType, }); if (select) { tabToSelect = tab; } } tabs.push(tab); if (tabData.pinned) { // Calling `pinTab` calls `moveTabTo`, which assumes the tab is // inserted in the DOM. If the tab is not yet in the DOM, // just insert it in the right place from the start. if (!tab.parentNode) { tab._tPos = this._numPinnedTabs; this.tabContainer.insertBefore(tab, this.tabs[this._numPinnedTabs]); tab.setAttribute("pinned", "true"); this.tabContainer._invalidateCachedTabs(); // Then ensure all the tab open/pinning information is sent. this._fireTabOpen(tab, {}); this._notifyPinnedStatus(tab); // Once we're done adding all tabs, _updateTabBarForPinnedTabs // needs calling: shouldUpdateForPinnedTabs = true; } } else { if (tab.hidden) { tab.hidden = true; hiddenTabs.set(tab, tabData.extData && tabData.extData.hiddenBy); } tabsFragment.appendChild(tab); if (tabWasReused) { this.tabContainer._invalidateCachedTabs(); } } tab.initialize(); } // inject the new DOM nodes this.tabContainer.appendChild(tabsFragment); for (let [tab, hiddenBy] of hiddenTabs) { let event = document.createEvent("Events"); event.initEvent("TabHide", true, false); tab.dispatchEvent(event); if (hiddenBy) { SessionStore.setCustomTabValue(tab, "hiddenBy", hiddenBy); } } this.tabContainer._invalidateCachedTabs(); if (shouldUpdateForPinnedTabs) { this._updateTabBarForPinnedTabs(); } // We need to wait until after all tabs have been appended to the DOM // to remove the old selected tab. if (tabToSelect) { let leftoverTab = this.selectedTab; this.selectedTab = tabToSelect; this.removeTab(leftoverTab); } if (tabs.length > 1 || !tabs[0].selected) { this._updateTabsAfterInsert(); this.tabContainer._setPositionalAttributes(); TabBarVisibility.update(); for (let tab of tabs) { // If tabToSelect is a tab, we didn't reuse the selected tab. if (tabToSelect || !tab.selected) { // Fire a TabOpen event for all unpinned tabs, except reused selected // tabs. if (!tab.pinned) { this._fireTabOpen(tab, {}); } // Fire a TabBrowserInserted event on all tabs that have a connected, // real browser, except for reused selected tabs. if (tab.linkedPanel) { var evt = new CustomEvent("TabBrowserInserted", { bubbles: true, detail: { insertedOnTabCreation: true }, }); tab.dispatchEvent(evt); } } } } return tabs; }, moveTabsToStart(contextTab) { let tabs = contextTab.multiselected ? this.selectedTabs : [contextTab]; // Walk the array in reverse order so the tabs are kept in order. for (let i = tabs.length - 1; i >= 0; i--) { let tab = tabs[i]; if (tab._tPos > 0) { this.moveTabTo(tab, 0); } } }, moveTabsToEnd(contextTab) { let tabs = contextTab.multiselected ? this.selectedTabs : [contextTab]; for (let tab of tabs) { if (tab._tPos < this.tabs.length - 1) { this.moveTabTo(tab, this.tabs.length - 1); } } }, warnAboutClosingTabs(tabsToClose, aCloseTabs, aSource) { if (tabsToClose <= 1) { return true; } const pref = aCloseTabs == this.closingTabsEnum.ALL ? "browser.tabs.warnOnClose" : "browser.tabs.warnOnCloseOtherTabs"; var shouldPrompt = Services.prefs.getBoolPref(pref); if (!shouldPrompt) { return true; } const maxTabsUndo = Services.prefs.getIntPref( "browser.sessionstore.max_tabs_undo" ); if ( aCloseTabs != this.closingTabsEnum.ALL && tabsToClose <= maxTabsUndo ) { return true; } // Our prompt to close this window is most important, so replace others. gDialogBox.replaceDialogIfOpen(); var ps = Services.prompt; // default to true: if it were false, we wouldn't get this far var warnOnClose = { value: true }; // focus the window before prompting. // this will raise any minimized window, which will // make it obvious which window the prompt is for and will // solve the problem of windows "obscuring" the prompt. // see bug #350299 for more details window.focus(); const [title, button, checkbox] = this.tabLocalization.formatValuesSync([ { id: "tabbrowser-confirm-close-tabs-title", args: { tabCount: tabsToClose }, }, { id: "tabbrowser-confirm-close-tabs-button" }, { id: "tabbrowser-confirm-close-tabs-checkbox" }, ]); let flags = ps.BUTTON_TITLE_IS_STRING * ps.BUTTON_POS_0 + ps.BUTTON_TITLE_CANCEL * ps.BUTTON_POS_1; let checkboxLabel = aCloseTabs == this.closingTabsEnum.ALL ? checkbox : null; var buttonPressed = ps.confirmEx( window, title, null, flags, button, null, null, checkboxLabel, warnOnClose ); Services.telemetry.setEventRecordingEnabled("close_tab_warning", true); let closeTabEnumKey = Object.entries(this.closingTabsEnum) .find(([k, v]) => v == aCloseTabs)?.[0] ?.toLowerCase() || "some"; let warnCheckbox = warnOnClose.value ? "checked" : "unchecked"; if (!checkboxLabel) { warnCheckbox = "not-present"; } let sessionWillBeRestored = Services.prefs.getIntPref("browser.startup.page") == 3 || Services.prefs.getBoolPref("browser.sessionstore.resume_session_once"); let closesWindow = aCloseTabs == this.closingTabsEnum.ALL; Services.telemetry.recordEvent( "close_tab_warning", "shown", closesWindow ? "window" : "tabs", null, { source: aSource || `close-${closeTabEnumKey}-tabs`, button: buttonPressed == 0 ? "close" : "cancel", warn_checkbox: warnCheckbox, closing_tabs: "" + tabsToClose, closing_wins: "" + +closesWindow, // ("1" or "0", depending on the value) // This value doesn't really apply to whether this warning // gets shown, but having pings be consistent (and perhaps // being able to see trends for users with/without sessionrestore) // seems useful: will_restore: sessionWillBeRestored ? "yes" : "no", } ); var reallyClose = buttonPressed == 0; // don't set the pref unless they press OK and it's false if ( aCloseTabs == this.closingTabsEnum.ALL && reallyClose && !warnOnClose.value ) { Services.prefs.setBoolPref(pref, false); } return reallyClose; }, /** * This determines where the tab should be inserted within the tabContainer */ _insertTabAtIndex( tab, { index, ownerTab, openerTab, pinned, bulkOrderedOpen } = {} ) { // If this new tab is owned by another, assert that relationship if (ownerTab) { tab.owner = ownerTab; } // Ensure we have an index if one was not provided. if (typeof index != "number") { // Move the new tab after another tab if needed, to the end otherwise. index = Infinity; if ( !bulkOrderedOpen && ((openerTab && Services.prefs.getBoolPref( "browser.tabs.insertRelatedAfterCurrent" )) || Services.prefs.getBoolPref("browser.tabs.insertAfterCurrent")) ) { let lastRelatedTab = openerTab && this._lastRelatedTabMap.get(openerTab); let previousTab = lastRelatedTab || openerTab || this.selectedTab; if (!previousTab.hidden) { index = previousTab._tPos + 1; } else if (previousTab == FirefoxViewHandler.tab) { index = 0; } if (lastRelatedTab) { lastRelatedTab.owner = null; } else if (openerTab) { tab.owner = openerTab; } // Always set related map if opener exists. if (openerTab) { this._lastRelatedTabMap.set(openerTab, tab); } } } // Ensure index is within bounds. if (pinned) { index = Math.max(index, 0); index = Math.min(index, this._numPinnedTabs); } else { index = Math.max(index, this._numPinnedTabs); index = Math.min(index, this.tabs.length); } let tabAfter = this.tabs[index] || null; this.tabContainer._invalidateCachedTabs(); // Prevent a flash of unstyled content by setting up the tab content // and inherited attributes before appending it (see Bug 1592054): tab.initialize(); this.tabContainer.insertBefore(tab, tabAfter); if (tabAfter) { this._updateTabsAfterInsert(); } else { tab._tPos = index; } if (pinned) { this._updateTabBarForPinnedTabs(); } this.tabContainer._setPositionalAttributes(); TabBarVisibility.update(); }, /** * Dispatch a new tab event. This should be called when things are in a * consistent state, such that listeners of this event can again open * or close tabs. */ _fireTabOpen(tab, eventDetail) { delete tab.initializingTab; let evt = new CustomEvent("TabOpen", { bubbles: true, detail: eventDetail || {}, }); tab.dispatchEvent(evt); }, getTabsToTheStartFrom(aTab) { let tabsToStart = []; if (aTab.hidden) { return tabsToStart; } let tabs = this.visibleTabs; for (let i = 0; i < tabs.length; ++i) { if (tabs[i] == aTab) { break; } // Ignore pinned tabs. if (tabs[i].pinned) { continue; } // In a multi-select context, select all unselected tabs // starting from the context tab. if (aTab.multiselected && tabs[i].multiselected) { continue; } tabsToStart.push(tabs[i]); } return tabsToStart; }, getTabsToTheEndFrom(aTab) { let tabsToEnd = []; if (aTab.hidden) { return tabsToEnd; } let tabs = this.visibleTabs; for (let i = tabs.length - 1; i >= 0; --i) { if (tabs[i] == aTab) { break; } // Ignore pinned tabs. if (tabs[i].pinned) { continue; } // In a multi-select context, select all unselected tabs // starting from the context tab. if (aTab.multiselected && tabs[i].multiselected) { continue; } tabsToEnd.push(tabs[i]); } return tabsToEnd; }, /** * In a multi-select context, the tabs (except pinned tabs) that are located to the * left of the leftmost selected tab will be removed. */ removeTabsToTheStartFrom(aTab) { let tabs = this.getTabsToTheStartFrom(aTab); if ( !this.warnAboutClosingTabs(tabs.length, this.closingTabsEnum.TO_START) ) { return; } this.removeTabs(tabs); }, /** * In a multi-select context, the tabs (except pinned tabs) that are located to the * right of the rightmost selected tab will be removed. */ removeTabsToTheEndFrom(aTab) { let tabs = this.getTabsToTheEndFrom(aTab); if ( !this.warnAboutClosingTabs(tabs.length, this.closingTabsEnum.TO_END) ) { return; } this.removeTabs(tabs); }, /** * In a multi-select context, all unpinned and unselected tabs are removed. * Otherwise all unpinned tabs except aTab are removed. * * @param aTab * The tab we will skip removing * @param aParams * An optional set of parameters that will be passed to the * removeTabs function. */ removeAllTabsBut(aTab, aParams) { let tabsToRemove = []; if (aTab && aTab.multiselected) { tabsToRemove = this.visibleTabs.filter( tab => !tab.multiselected && !tab.pinned ); } else { tabsToRemove = this.visibleTabs.filter( tab => tab != aTab && !tab.pinned ); } if ( !this.warnAboutClosingTabs( tabsToRemove.length, this.closingTabsEnum.OTHER ) ) { return; } this.removeTabs(tabsToRemove, aParams); }, removeMultiSelectedTabs() { let selectedTabs = this.selectedTabs; if ( !this.warnAboutClosingTabs( selectedTabs.length, this.closingTabsEnum.MULTI_SELECTED ) ) { return; } this.removeTabs(selectedTabs); }, /** * @typedef {object} _startRemoveTabsReturnValue * @property {Promise} beforeUnloadComplete * A promise that is resolved once all the beforeunload handlers have been * called. * @property {object[]} tabsWithBeforeUnloadPrompt * An array of tabs with unload prompts that need to be handled. * @property {object} [lastToClose] * The last tab to be closed, if appropriate. */ /** * Starts to remove tabs from the UI: checking for beforeunload handlers, * closing tabs where possible and triggering running of the unload handlers. * * @param {object[]} tabs * The set of tabs to remove. * @param {object} options * @param {boolean} options.animate * Whether or not to animate closing. * @param {boolean} options.suppressWarnAboutClosingWindow * This will supress the warning about closing a window with the last tab. * @param {boolean} options.skipPermitUnload * Skips the before unload checks for the tabs. Only set this to true when * using it in tandem with `runBeforeUnloadForTabs`. * @param {boolean} options.skipRemoves * Skips actually removing the tabs. The beforeunload handlers still run. * @returns {_startRemoveTabsReturnValue} */ _startRemoveTabs( tabs, { animate, suppressWarnAboutClosingWindow, skipPermitUnload, skipRemoves } ) { // Note: if you change any of the unload algorithm, consider also // changing `runBeforeUnloadForTabs` above. let tabsWithBeforeUnloadPrompt = []; let tabsWithoutBeforeUnload = []; let beforeUnloadPromises = []; let lastToClose; for (let tab of tabs) { if (!skipRemoves) { tab._closedInGroup = true; } if (!skipRemoves && tab.selected) { lastToClose = tab; let toBlurTo = this._findTabToBlurTo(lastToClose, tabs); if (toBlurTo) { this._getSwitcher().warmupTab(toBlurTo); } } else if (!skipPermitUnload && this._hasBeforeUnload(tab)) { TelemetryStopwatch.start("FX_TAB_CLOSE_PERMIT_UNLOAD_TIME_MS", tab); // We need to block while calling permitUnload() because it // processes the event queue and may lead to another removeTab() // call before permitUnload() returns. tab._pendingPermitUnload = true; beforeUnloadPromises.push( // To save time, we first run the beforeunload event listeners in all // content processes in parallel. Tabs that would have shown a prompt // will be handled again later. tab.linkedBrowser.asyncPermitUnload("dontUnload").then( ({ permitUnload }) => { tab._pendingPermitUnload = false; TelemetryStopwatch.finish( "FX_TAB_CLOSE_PERMIT_UNLOAD_TIME_MS", tab ); if (tab.closing) { // The tab was closed by the user while we were in permitUnload, don't // attempt to close it a second time. } else if (permitUnload) { if (!skipRemoves) { // OK to close without prompting, do it immediately. this.removeTab(tab, { animate, prewarmed: true, skipPermitUnload: true, }); } } else { // We will need to prompt, queue it so it happens sequentially. tabsWithBeforeUnloadPrompt.push(tab); } }, err => { console.error("error while calling asyncPermitUnload", err); tab._pendingPermitUnload = false; TelemetryStopwatch.finish( "FX_TAB_CLOSE_PERMIT_UNLOAD_TIME_MS", tab ); } ) ); } else { tabsWithoutBeforeUnload.push(tab); } } // Now that all the beforeunload IPCs have been sent to content processes, // we can queue unload messages for all the tabs without beforeunload listeners. // Doing this first would cause content process main threads to be busy and delay // beforeunload responses, which would be user-visible. if (!skipRemoves) { for (let tab of tabsWithoutBeforeUnload) { this.removeTab(tab, { animate, prewarmed: true, skipPermitUnload, }); } } return { beforeUnloadComplete: Promise.all(beforeUnloadPromises), tabsWithBeforeUnloadPrompt, lastToClose, }; }, /** * Runs the before unload handler for the provided tabs, waiting for them * to complete. * * This can be used in tandem with removeTabs to allow any before unload * prompts to happen before any tab closures. This should only be used * in the case where any prompts need to happen before other items before * the actual tabs are closed. * * When using this function alongside removeTabs, specify the `skipUnload` * option to removeTabs. * * @param {object[]} tabs * An array of tabs to remove. * @returns {Promise} * Returns true if the unload has been blocked by the user. False if tabs * may be subsequently closed. */ async runBeforeUnloadForTabs(tabs) { try { let { beforeUnloadComplete, tabsWithBeforeUnloadPrompt } = this._startRemoveTabs(tabs, { animate: false, suppressWarnAboutClosingWindow: false, skipPermitUnload: false, skipRemoves: true, }); await beforeUnloadComplete; // Now run again sequentially the beforeunload listeners that will result in a prompt. for (let tab of tabsWithBeforeUnloadPrompt) { tab._pendingPermitUnload = true; let { permitUnload } = this.getBrowserForTab(tab).permitUnload(); tab._pendingPermitUnload = false; if (!permitUnload) { return true; } } } catch (e) { console.error(e); } return false; }, /** * Removes multiple tabs from the tab browser. * * @param {object[]} tabs * The set of tabs to remove. * @param {object} [options] * @param {boolean} [options.animate] * Whether or not to animate closing, defaults to true. * @param {boolean} [options.suppressWarnAboutClosingWindow] * This will supress the warning about closing a window with the last tab. * @param {boolean} [options.skipPermitUnload] * Skips the before unload checks for the tabs. Only set this to true when * using it in tandem with `runBeforeUnloadForTabs`. */ removeTabs( tabs, { animate = true, suppressWarnAboutClosingWindow = false, skipPermitUnload = false, } = {} ) { // When 'closeWindowWithLastTab' pref is enabled, closing all tabs // can be considered equivalent to closing the window. if ( this.tabs.length == tabs.length && Services.prefs.getBoolPref("browser.tabs.closeWindowWithLastTab") ) { window.closeWindow( true, suppressWarnAboutClosingWindow ? null : window.warnAboutClosingWindow, "close-last-tab" ); return; } SessionStore.resetLastClosedTabCount(window); this._clearMultiSelectionLocked = true; // Guarantee that _clearMultiSelectionLocked lock gets released. try { let { beforeUnloadComplete, tabsWithBeforeUnloadPrompt, lastToClose } = this._startRemoveTabs(tabs, { animate, suppressWarnAboutClosingWindow, skipPermitUnload, skipRemoves: false, }); // Wait for all the beforeunload events to have been processed by content processes. // The permitUnload() promise will, alas, not call its resolution // callbacks after the browser window the promise lives in has closed, // so we have to check for that case explicitly. let done = false; beforeUnloadComplete.then(() => { done = true; }); Services.tm.spinEventLoopUntilOrQuit( "tabbrowser.js:removeTabs", () => done || window.closed ); if (!done) { return; } let aParams = { animate, prewarmed: true, skipPermitUnload, }; // Now run again sequentially the beforeunload listeners that will result in a prompt. for (let tab of tabsWithBeforeUnloadPrompt) { this.removeTab(tab, aParams); if (!tab.closing) { // If we abort the closing of the tab. tab._closedInGroup = false; } } // Avoid changing the selected browser several times by removing it, // if appropriate, lastly. if (lastToClose) { this.removeTab(lastToClose, aParams); } } catch (e) { console.error(e); } this._clearMultiSelectionLocked = false; this._avoidSingleSelectedTab(); // Don't use document.l10n.setAttributes because the FTL file is loaded // lazily and we won't be able to resolve the string. document.getElementById("History:UndoCloseTab").setAttribute( "data-l10n-args", JSON.stringify({ tabCount: SessionStore.getLastClosedTabCount(window), }) ); }, removeCurrentTab(aParams) { this.removeTab(this.selectedTab, aParams); }, removeTab( aTab, { animate, triggeringEvent, skipPermitUnload, closeWindowWithLastTab, prewarmed, } = {} ) { if (UserInteraction.running("browser.tabs.opening", window)) { UserInteraction.finish("browser.tabs.opening", window); } // Telemetry stopwatches may already be running if removeTab gets // called again for an already closing tab. if ( !TelemetryStopwatch.running("FX_TAB_CLOSE_TIME_ANIM_MS", aTab) && !TelemetryStopwatch.running("FX_TAB_CLOSE_TIME_NO_ANIM_MS", aTab) ) { // Speculatevely start both stopwatches now. We'll cancel one of // the two later depending on whether we're animating. TelemetryStopwatch.start("FX_TAB_CLOSE_TIME_ANIM_MS", aTab); TelemetryStopwatch.start("FX_TAB_CLOSE_TIME_NO_ANIM_MS", aTab); } // Handle requests for synchronously removing an already // asynchronously closing tab. if (!animate && aTab.closing) { this._endRemoveTab(aTab); return; } let isLastTab = !aTab.hidden && this.visibleTabs.length == 1; // We have to sample the tab width now, since _beginRemoveTab might // end up modifying the DOM in such a way that aTab gets a new // frame created for it (for example, by updating the visually selected // state). let tabWidth = window.windowUtils.getBoundsWithoutFlushing(aTab).width; if ( !this._beginRemoveTab(aTab, { closeWindowFastpath: true, skipPermitUnload, closeWindowWithLastTab, prewarmed, }) ) { TelemetryStopwatch.cancel("FX_TAB_CLOSE_TIME_ANIM_MS", aTab); TelemetryStopwatch.cancel("FX_TAB_CLOSE_TIME_NO_ANIM_MS", aTab); return; } let lockTabSizing = !aTab.pinned && !aTab.hidden && aTab._fullyOpen && triggeringEvent?.mozInputSource == MouseEvent.MOZ_SOURCE_MOUSE && triggeringEvent?.target.closest(".tabbrowser-tab"); if (lockTabSizing) { this.tabContainer._lockTabSizing(aTab, tabWidth); } else { this.tabContainer._unlockTabSizing(); } if ( !animate /* the caller didn't opt in */ || gReduceMotion || isLastTab || aTab.pinned || aTab.hidden || this._removingTabs.size > 3 /* don't want lots of concurrent animations */ || aTab.getAttribute("fadein") != "true" /* fade-in transition hasn't been triggered yet */ || tabWidth == 0 /* fade-in transition hasn't moved yet */ ) { // We're not animating, so we can cancel the animation stopwatch. TelemetryStopwatch.cancel("FX_TAB_CLOSE_TIME_ANIM_MS", aTab); this._endRemoveTab(aTab); return; } // We're animating, so we can cancel the non-animation stopwatch. TelemetryStopwatch.cancel("FX_TAB_CLOSE_TIME_NO_ANIM_MS", aTab); aTab.style.maxWidth = ""; // ensure that fade-out transition happens aTab.removeAttribute("fadein"); aTab.removeAttribute("bursting"); setTimeout( function (tab, tabbrowser) { if ( tab.container && window.getComputedStyle(tab).maxWidth == "0.1px" ) { console.assert( false, "Giving up waiting for the tab closing animation to finish (bug 608589)" ); tabbrowser._endRemoveTab(tab); } }, 3000, aTab, this ); }, _hasBeforeUnload(aTab) { let browser = aTab.linkedBrowser; if (browser.isRemoteBrowser && browser.frameLoader) { return browser.hasBeforeUnload; } return false; }, _beginRemoveTab( aTab, { adoptedByTab, closeWindowWithLastTab, closeWindowFastpath, skipPermitUnload, prewarmed, } = {} ) { if (aTab.closing || this._windowIsClosing) { return false; } var browser = this.getBrowserForTab(aTab); if ( !skipPermitUnload && !adoptedByTab && aTab.linkedPanel && !aTab._pendingPermitUnload && (!browser.isRemoteBrowser || this._hasBeforeUnload(aTab)) ) { if (!prewarmed) { let blurTab = this._findTabToBlurTo(aTab); if (blurTab) { this.warmupTab(blurTab); } } TelemetryStopwatch.start("FX_TAB_CLOSE_PERMIT_UNLOAD_TIME_MS", aTab); // We need to block while calling permitUnload() because it // processes the event queue and may lead to another removeTab() // call before permitUnload() returns. aTab._pendingPermitUnload = true; let { permitUnload } = browser.permitUnload(); aTab._pendingPermitUnload = false; TelemetryStopwatch.finish("FX_TAB_CLOSE_PERMIT_UNLOAD_TIME_MS", aTab); // If we were closed during onbeforeunload, we return false now // so we don't (try to) close the same tab again. Of course, we // also stop if the unload was cancelled by the user: if (aTab.closing || !permitUnload) { return false; } } // this._switcher would normally cover removing a tab from this // cache, but we may not have one at this time. let tabCacheIndex = this._tabLayerCache.indexOf(aTab); if (tabCacheIndex != -1) { this._tabLayerCache.splice(tabCacheIndex, 1); } // Delay hiding the the active tab if we're screen sharing. // See Bug 1642747. let screenShareInActiveTab = aTab == this.selectedTab && aTab._sharingState?.webRTC?.screen; if (!screenShareInActiveTab) { this._blurTab(aTab); } var closeWindow = false; var newTab = false; if (!aTab.hidden && this.visibleTabs.length == 1) { closeWindow = closeWindowWithLastTab != null ? closeWindowWithLastTab : !window.toolbar.visible || Services.prefs.getBoolPref("browser.tabs.closeWindowWithLastTab"); if (closeWindow) { // We've already called beforeunload on all the relevant tabs if we get here, // so avoid calling it again: window.skipNextCanClose = true; } // Closing the tab and replacing it with a blank one is notably slower // than closing the window right away. If the caller opts in, take // the fast path. if (closeWindow && closeWindowFastpath && !this._removingTabs.size) { // This call actually closes the window, unless the user // cancels the operation. We are finished here in both cases. this._windowIsClosing = window.closeWindow( true, window.warnAboutClosingWindow, "close-last-tab" ); return false; } newTab = true; } aTab._endRemoveArgs = [closeWindow, newTab]; // swapBrowsersAndCloseOther will take care of closing the window without animation. if (closeWindow && adoptedByTab) { // Remove the tab's filter and progress listener to avoid leaking. if (aTab.linkedPanel) { const filter = this._tabFilters.get(aTab); browser.webProgress.removeProgressListener(filter); const listener = this._tabListeners.get(aTab); filter.removeProgressListener(listener); listener.destroy(); this._tabListeners.delete(aTab); this._tabFilters.delete(aTab); } return true; } if (!aTab._fullyOpen) { // If the opening tab animation hasn't finished before we start closing the // tab, decrement the animation count since _handleNewTab will not get called. this.tabAnimationsInProgress--; } this.tabAnimationsInProgress++; // Mute audio immediately to improve perceived speed of tab closure. if (!adoptedByTab && aTab.hasAttribute("soundplaying")) { // Don't persist the muted state as this wasn't a user action. // This lets undo-close-tab return it to an unmuted state. aTab.linkedBrowser.mute(true); } aTab.closing = true; this._removingTabs.add(aTab); this.tabContainer._invalidateCachedTabs(); // Invalidate hovered tab state tracking for this closing tab. aTab._mouseleave(); if (newTab) { this.addTrustedTab(BROWSER_NEW_TAB_URL, { skipAnimation: true, }); } else { TabBarVisibility.update(); } // Splice this tab out of any lines of succession before any events are // dispatched. this.replaceInSuccession(aTab, aTab.successor); this.setSuccessor(aTab, null); // We're committed to closing the tab now. // Dispatch a notification. // We dispatch it before any teardown so that event listeners can // inspect the tab that's about to close. let evt = new CustomEvent("TabClose", { bubbles: true, detail: { adoptedBy: adoptedByTab }, }); aTab.dispatchEvent(evt); if (this.tabs.length == 2) { // We're closing one of our two open tabs, inform the other tab that its // sibling is going away. for (let tab of this.tabs) { let bc = tab.linkedBrowser.browsingContext; if (bc) { bc.hasSiblings = false; } } } let notificationBox = this.readNotificationBox(browser); notificationBox?._stack?.remove(); if (aTab.linkedPanel) { if (!adoptedByTab && !gMultiProcessBrowser) { // Prevent this tab from showing further dialogs, since we're closing it browser.contentWindow.windowUtils.disableDialogs(); } // Remove the tab's filter and progress listener. const filter = this._tabFilters.get(aTab); browser.webProgress.removeProgressListener(filter); const listener = this._tabListeners.get(aTab); filter.removeProgressListener(listener); listener.destroy(); } if (browser.registeredOpenURI && !adoptedByTab) { let userContextId = browser.getAttribute("usercontextid") || 0; this.UrlbarProviderOpenTabs.unregisterOpenTab( browser.registeredOpenURI.spec, userContextId, PrivateBrowsingUtils.isWindowPrivate(window) ); delete browser.registeredOpenURI; } // We are no longer the primary content area. browser.removeAttribute("primary"); // Remove this tab as the owner of any other tabs, since it's going away. for (let tab of this.tabs) { if ("owner" in tab && tab.owner == aTab) { // |tab| is a child of the tab we're removing, make it an orphan tab.owner = null; } } return true; }, _endRemoveTab(aTab) { if (!aTab || !aTab._endRemoveArgs) { return; } var [aCloseWindow, aNewTab] = aTab._endRemoveArgs; aTab._endRemoveArgs = null; if (this._windowIsClosing) { aCloseWindow = false; aNewTab = false; } this.tabAnimationsInProgress--; this._lastRelatedTabMap = new WeakMap(); // update the UI early for responsiveness aTab.collapsed = true; this._blurTab(aTab); this._removingTabs.delete(aTab); if (aCloseWindow) { this._windowIsClosing = true; for (let tab of this._removingTabs) { this._endRemoveTab(tab); } } else if (!this._windowIsClosing) { if (aNewTab) { gURLBar.select(); } // workaround for bug 345399 this.tabContainer.arrowScrollbox._updateScrollButtonsDisabledState(); } // We're going to remove the tab and the browser now. this._tabFilters.delete(aTab); this._tabListeners.delete(aTab); var browser = this.getBrowserForTab(aTab); if (aTab.linkedPanel) { // Because of the fact that we are setting JS properties on // the browser elements, and we have code in place // to preserve the JS objects for any elements that have // JS properties set on them, the browser element won't be // destroyed until the document goes away. So we force a // cleanup ourselves. // This has to happen before we remove the child since functions // like `getBrowserContainer` expect the browser to be parented. browser.destroy(); } var wasPinned = aTab.pinned; // Remove the tab ... aTab.remove(); this.tabContainer._invalidateCachedTabs(); // Update hashiddentabs if this tab was hidden. if (aTab.hidden) { this.tabContainer._updateHiddenTabsStatus(); } // ... and fix up the _tPos properties immediately. for (let i = aTab._tPos; i < this.tabs.length; i++) { this.tabs[i]._tPos = i; } if (!this._windowIsClosing) { if (wasPinned) { this.tabContainer._positionPinnedTabs(); } // update tab close buttons state this.tabContainer._updateCloseButtons(); setTimeout( function (tabs) { tabs._lastTabClosedByMouse = false; }, 0, this.tabContainer ); } // update tab positional properties and attributes this.selectedTab._selected = true; this.tabContainer._setPositionalAttributes(); // Removing the panel requires fixing up selectedPanel immediately // (see below), which would be hindered by the potentially expensive // browser removal. So we remove the browser and the panel in two // steps. var panel = this.getPanel(browser); // In the multi-process case, it's possible an asynchronous tab switch // is still underway. If so, then it's possible that the last visible // browser is the one we're in the process of removing. There's the // risk of displaying preloaded browsers that are at the end of the // deck if we remove the browser before the switch is complete, so // we alert the switcher in order to show a spinner instead. if (this._switcher) { this._switcher.onTabRemoved(aTab); } // This will unload the document. An unload handler could remove // dependant tabs, so it's important that the tabbrowser is now in // a consistent state (tab removed, tab positions updated, etc.). browser.remove(); // Release the browser in case something is erroneously holding a // reference to the tab after its removal. this._tabForBrowser.delete(aTab.linkedBrowser); aTab.linkedBrowser = null; panel.remove(); // closeWindow might wait an arbitrary length of time if we're supposed // to warn about closing the window, so we'll just stop the tab close // stopwatches here instead. TelemetryStopwatch.finish( "FX_TAB_CLOSE_TIME_ANIM_MS", aTab, true /* aCanceledOkay */ ); TelemetryStopwatch.finish( "FX_TAB_CLOSE_TIME_NO_ANIM_MS", aTab, true /* aCanceledOkay */ ); if (aCloseWindow) { this._windowIsClosing = closeWindow( true, window.warnAboutClosingWindow, "close-last-tab" ); } }, /** * Handles opening a new tab with mouse middleclick. * @param node * @param event * The click event */ handleNewTabMiddleClick(node, event) { // We should be using the disabled property here instead of the attribute, // but some elements that this function is used with don't support it (e.g. // menuitem). if (node.getAttribute("disabled") == "true") { return; } // Do nothing if (event.button == 1) { BrowserOpenTab({ event }); // Stop the propagation of the click event, to prevent the event from being // handled more than once. // E.g. see https://bugzilla.mozilla.org/show_bug.cgi?id=1657992#c4 event.stopPropagation(); event.preventDefault(); } }, /** * Finds the tab that we will blur to if we blur aTab. * @param aTab * The tab we would blur * @param aExcludeTabs * Tabs to exclude from our search (i.e., because they are being * closed along with aTab) */ _findTabToBlurTo(aTab, aExcludeTabs = []) { if (!aTab.selected) { return null; } if (FirefoxViewHandler.tab) { aExcludeTabs.push(FirefoxViewHandler.tab); } let excludeTabs = new Set(aExcludeTabs); // If this tab has a successor, it should be selectable, since // hiding or closing a tab removes that tab as a successor. if (aTab.successor && !excludeTabs.has(aTab.successor)) { return aTab.successor; } if ( aTab.owner && !aTab.owner.hidden && !aTab.owner.closing && !excludeTabs.has(aTab.owner) && Services.prefs.getBoolPref("browser.tabs.selectOwnerOnClose") ) { return aTab.owner; } // Switch to a visible tab unless there aren't any others remaining let remainingTabs = this.visibleTabs; let numTabs = remainingTabs.length; if (numTabs == 0 || (numTabs == 1 && remainingTabs[0] == aTab)) { remainingTabs = Array.prototype.filter.call( this.tabs, tab => !tab.closing && !excludeTabs.has(tab) ); } // Try to find a remaining tab that comes after the given tab let tab = this.tabContainer.findNextTab(aTab, { direction: 1, filter: _tab => remainingTabs.includes(_tab), }); if (!tab) { tab = this.tabContainer.findNextTab(aTab, { direction: -1, filter: _tab => remainingTabs.includes(_tab), }); } return tab; }, _blurTab(aTab) { this.selectedTab = this._findTabToBlurTo(aTab); }, /** * @returns {boolean} * False if swapping isn't permitted, true otherwise. */ swapBrowsersAndCloseOther(aOurTab, aOtherTab) { // Do not allow transfering a private tab to a non-private window // and vice versa. if ( PrivateBrowsingUtils.isWindowPrivate(window) != PrivateBrowsingUtils.isWindowPrivate(aOtherTab.ownerGlobal) ) { return false; } // Do not allow transfering a useRemoteSubframes tab to a // non-useRemoteSubframes window and vice versa. if (gFissionBrowser != aOtherTab.ownerGlobal.gFissionBrowser) { return false; } let ourBrowser = this.getBrowserForTab(aOurTab); let otherBrowser = aOtherTab.linkedBrowser; // Can't swap between chrome and content processes. if (ourBrowser.isRemoteBrowser != otherBrowser.isRemoteBrowser) { return false; } // Keep the userContextId if set on other browser if (otherBrowser.hasAttribute("usercontextid")) { ourBrowser.setAttribute( "usercontextid", otherBrowser.getAttribute("usercontextid") ); } // That's gBrowser for the other window, not the tab's browser! var remoteBrowser = aOtherTab.ownerGlobal.gBrowser; var isPending = aOtherTab.hasAttribute("pending"); let otherTabListener = remoteBrowser._tabListeners.get(aOtherTab); let stateFlags = 0; if (otherTabListener) { stateFlags = otherTabListener.mStateFlags; } // Expedite the removal of the icon if it was already scheduled. if (aOtherTab._soundPlayingAttrRemovalTimer) { clearTimeout(aOtherTab._soundPlayingAttrRemovalTimer); aOtherTab._soundPlayingAttrRemovalTimer = 0; aOtherTab.removeAttribute("soundplaying"); remoteBrowser._tabAttrModified(aOtherTab, ["soundplaying"]); } // First, start teardown of the other browser. Make sure to not // fire the beforeunload event in the process. Close the other // window if this was its last tab. if ( !remoteBrowser._beginRemoveTab(aOtherTab, { adoptedByTab: aOurTab, closeWindowWithLastTab: true, }) ) { return false; } // If this is the last tab of the window, hide the window // immediately without animation before the docshell swap, to avoid // about:blank being painted. let [closeWindow] = aOtherTab._endRemoveArgs; if (closeWindow) { let win = aOtherTab.ownerGlobal; win.windowUtils.suppressAnimation(true); // Only suppressing window animations isn't enough to avoid // an empty content area being painted. let baseWin = win.docShell.treeOwner.QueryInterface(Ci.nsIBaseWindow); baseWin.visibility = false; } let modifiedAttrs = []; if (aOtherTab.hasAttribute("muted")) { aOurTab.setAttribute("muted", "true"); aOurTab.muteReason = aOtherTab.muteReason; // For non-lazy tabs, mute() must be called. if (aOurTab.linkedPanel) { ourBrowser.mute(); } modifiedAttrs.push("muted"); } if (aOtherTab.hasAttribute("soundplaying")) { aOurTab.setAttribute("soundplaying", "true"); modifiedAttrs.push("soundplaying"); } if (aOtherTab.hasAttribute("usercontextid")) { aOurTab.setUserContextId(aOtherTab.getAttribute("usercontextid")); modifiedAttrs.push("usercontextid"); } if (aOtherTab.hasAttribute("sharing")) { aOurTab.setAttribute("sharing", aOtherTab.getAttribute("sharing")); modifiedAttrs.push("sharing"); aOurTab._sharingState = aOtherTab._sharingState; webrtcUI.swapBrowserForNotification(otherBrowser, ourBrowser); } if (aOtherTab.hasAttribute("pictureinpicture")) { aOurTab.setAttribute("pictureinpicture", true); modifiedAttrs.push("pictureinpicture"); let event = new CustomEvent("TabSwapPictureInPicture", { detail: aOurTab, }); aOtherTab.dispatchEvent(event); } SitePermissions.copyTemporaryPermissions(otherBrowser, ourBrowser); // If the other tab is pending (i.e. has not been restored, yet) // then do not switch docShells but retrieve the other tab's state // and apply it to our tab. if (isPending) { // Tag tab so that the extension framework can ignore tab events that // are triggered amidst the tab/browser restoration process // (TabHide, TabPinned, TabUnpinned, "muted" attribute changes, etc.). aOurTab.initializingTab = true; delete ourBrowser._cachedCurrentURI; SessionStore.setTabState(aOurTab, SessionStore.getTabState(aOtherTab)); delete aOurTab.initializingTab; // Make sure to unregister any open URIs. this._swapRegisteredOpenURIs(ourBrowser, otherBrowser); } else { // Workarounds for bug 458697 // Icon might have been set on DOMLinkAdded, don't override that. if (!ourBrowser.mIconURL && otherBrowser.mIconURL) { this.setIcon(aOurTab, otherBrowser.mIconURL); } var isBusy = aOtherTab.hasAttribute("busy"); if (isBusy) { aOurTab.setAttribute("busy", "true"); modifiedAttrs.push("busy"); if (aOurTab.selected) { this._isBusy = true; } } this._swapBrowserDocShells(aOurTab, otherBrowser, stateFlags); } // Unregister the previously opened URI if (otherBrowser.registeredOpenURI) { let userContextId = otherBrowser.getAttribute("usercontextid") || 0; this.UrlbarProviderOpenTabs.unregisterOpenTab( otherBrowser.registeredOpenURI.spec, userContextId, PrivateBrowsingUtils.isWindowPrivate(window) ); delete otherBrowser.registeredOpenURI; } // Handle findbar data (if any) let otherFindBar = aOtherTab._findBar; if (otherFindBar && otherFindBar.findMode == otherFindBar.FIND_NORMAL) { let oldValue = otherFindBar._findField.value; let wasHidden = otherFindBar.hidden; let ourFindBarPromise = this.getFindBar(aOurTab); ourFindBarPromise.then(ourFindBar => { if (!ourFindBar) { return; } ourFindBar._findField.value = oldValue; if (!wasHidden) { ourFindBar.onFindCommand(); } }); } // Finish tearing down the tab that's going away. if (closeWindow) { aOtherTab.ownerGlobal.close(); } else { remoteBrowser._endRemoveTab(aOtherTab); } this.setTabTitle(aOurTab); // If the tab was already selected (this happens in the scenario // of replaceTabWithWindow), notify onLocationChange, etc. if (aOurTab.selected) { this.updateCurrentBrowser(true); } if (modifiedAttrs.length) { this._tabAttrModified(aOurTab, modifiedAttrs); } return true; }, swapBrowsers(aOurTab, aOtherTab) { let otherBrowser = aOtherTab.linkedBrowser; let otherTabBrowser = otherBrowser.getTabBrowser(); // We aren't closing the other tab so, we also need to swap its tablisteners. let filter = otherTabBrowser._tabFilters.get(aOtherTab); let tabListener = otherTabBrowser._tabListeners.get(aOtherTab); otherBrowser.webProgress.removeProgressListener(filter); filter.removeProgressListener(tabListener); // Perform the docshell swap through the common mechanism. this._swapBrowserDocShells(aOurTab, otherBrowser); // Restore the listeners for the swapped in tab. tabListener = new otherTabBrowser.ownerGlobal.TabProgressListener( aOtherTab, otherBrowser, false, false ); otherTabBrowser._tabListeners.set(aOtherTab, tabListener); const notifyAll = Ci.nsIWebProgress.NOTIFY_ALL; filter.addProgressListener(tabListener, notifyAll); otherBrowser.webProgress.addProgressListener(filter, notifyAll); }, _swapBrowserDocShells(aOurTab, aOtherBrowser, aStateFlags) { // aOurTab's browser needs to be inserted now if it hasn't already. this._insertBrowser(aOurTab); // Unhook our progress listener const filter = this._tabFilters.get(aOurTab); let tabListener = this._tabListeners.get(aOurTab); let ourBrowser = this.getBrowserForTab(aOurTab); ourBrowser.webProgress.removeProgressListener(filter); filter.removeProgressListener(tabListener); // Make sure to unregister any open URIs. this._swapRegisteredOpenURIs(ourBrowser, aOtherBrowser); let remoteBrowser = aOtherBrowser.ownerGlobal.gBrowser; // If switcher is active, it will intercept swap events and // react as needed. if (!this._switcher) { aOtherBrowser.docShellIsActive = this.shouldActivateDocShell(ourBrowser); } // Swap the docshells ourBrowser.swapDocShells(aOtherBrowser); // Swap permanentKey properties. let ourPermanentKey = ourBrowser.permanentKey; ourBrowser.permanentKey = aOtherBrowser.permanentKey; aOtherBrowser.permanentKey = ourPermanentKey; aOurTab.permanentKey = ourBrowser.permanentKey; if (remoteBrowser) { let otherTab = remoteBrowser.getTabForBrowser(aOtherBrowser); if (otherTab) { otherTab.permanentKey = aOtherBrowser.permanentKey; } } // Restore the progress listener tabListener = new TabProgressListener( aOurTab, ourBrowser, false, false, aStateFlags ); this._tabListeners.set(aOurTab, tabListener); const notifyAll = Ci.nsIWebProgress.NOTIFY_ALL; filter.addProgressListener(tabListener, notifyAll); ourBrowser.webProgress.addProgressListener(filter, notifyAll); }, _swapRegisteredOpenURIs(aOurBrowser, aOtherBrowser) { // Swap the registeredOpenURI properties of the two browsers let tmp = aOurBrowser.registeredOpenURI; delete aOurBrowser.registeredOpenURI; if (aOtherBrowser.registeredOpenURI) { aOurBrowser.registeredOpenURI = aOtherBrowser.registeredOpenURI; delete aOtherBrowser.registeredOpenURI; } if (tmp) { aOtherBrowser.registeredOpenURI = tmp; } }, reloadMultiSelectedTabs() { this.reloadTabs(this.selectedTabs); }, reloadTabs(tabs) { for (let tab of tabs) { try { this.getBrowserForTab(tab).reload(); } catch (e) { // ignore failure to reload so others will be reloaded } } }, reloadTab(aTab) { let browser = this.getBrowserForTab(aTab); // Reset temporary permissions on the current tab. This is done here // because we only want to reset permissions on user reload. SitePermissions.clearTemporaryBlockPermissions(browser); // Also reset DOS mitigations for the basic auth prompt on reload. delete browser.authPromptAbuseCounter; gIdentityHandler.hidePopup(); gPermissionPanel.hidePopup(); browser.reload(); }, addProgressListener(aListener) { if (arguments.length != 1) { console.error( "gBrowser.addProgressListener was " + "called with a second argument, " + "which is not supported. See bug " + "608628. Call stack: ", new Error().stack ); } this.mProgressListeners.push(aListener); }, removeProgressListener(aListener) { this.mProgressListeners = this.mProgressListeners.filter( l => l != aListener ); }, addTabsProgressListener(aListener) { this.mTabsProgressListeners.push(aListener); }, removeTabsProgressListener(aListener) { this.mTabsProgressListeners = this.mTabsProgressListeners.filter( l => l != aListener ); }, getBrowserForTab(aTab) { return aTab.linkedBrowser; }, showOnlyTheseTabs(aTabs) { for (let tab of this.tabs) { if (!aTabs.includes(tab)) { this.hideTab(tab); } else { this.showTab(tab); } } this.tabContainer._updateHiddenTabsStatus(); this.tabContainer._handleTabSelect(true); }, showTab(aTab) { if (!aTab.hidden || aTab == FirefoxViewHandler.tab) { return; } aTab.removeAttribute("hidden"); this.tabContainer._invalidateCachedVisibleTabs(); this.tabContainer._updateCloseButtons(); this.tabContainer._updateHiddenTabsStatus(); this.tabContainer._setPositionalAttributes(); let event = document.createEvent("Events"); event.initEvent("TabShow", true, false); aTab.dispatchEvent(event); SessionStore.deleteCustomTabValue(aTab, "hiddenBy"); }, hideTab(aTab, aSource) { if ( aTab.hidden || aTab.pinned || aTab.selected || aTab.closing || // Tabs that are sharing the screen, microphone or camera cannot be hidden. aTab._sharingState?.webRTC?.sharing ) { return; } aTab.setAttribute("hidden", "true"); this.tabContainer._invalidateCachedVisibleTabs(); this.tabContainer._updateCloseButtons(); this.tabContainer._updateHiddenTabsStatus(); this.tabContainer._setPositionalAttributes(); // Splice this tab out of any lines of succession before any events are // dispatched. this.replaceInSuccession(aTab, aTab.successor); this.setSuccessor(aTab, null); let event = document.createEvent("Events"); event.initEvent("TabHide", true, false); aTab.dispatchEvent(event); if (aSource) { SessionStore.setCustomTabValue(aTab, "hiddenBy", aSource); } }, selectTabAtIndex(aIndex, aEvent) { let tabs = this.visibleTabs; // count backwards for aIndex < 0 if (aIndex < 0) { aIndex += tabs.length; // clamp at index 0 if still negative. if (aIndex < 0) { aIndex = 0; } } else if (aIndex >= tabs.length) { // clamp at right-most tab if out of range. aIndex = tabs.length - 1; } this.selectedTab = tabs[aIndex]; if (aEvent) { aEvent.preventDefault(); aEvent.stopPropagation(); } }, /** * Moves a tab to a new browser window, unless it's already the only tab * in the current window, in which case this will do nothing. */ replaceTabWithWindow(aTab, aOptions) { if (this.tabs.length == 1) { return null; } var options = "chrome,dialog=no,all"; for (var name in aOptions) { options += "," + name + "=" + aOptions[name]; } if (PrivateBrowsingUtils.isWindowPrivate(window)) { options += ",private=1"; } // Play the tab closing animation to give immediate feedback while // waiting for the new window to appear. // content area when the docshells are swapped. if (!gReduceMotion) { aTab.style.maxWidth = ""; // ensure that fade-out transition happens aTab.removeAttribute("fadein"); } // tell a new window to take the "dropped" tab return window.openDialog( AppConstants.BROWSER_CHROME_URL, "_blank", options, aTab ); }, /** * Move contextTab (or selected tabs in a mutli-select context) * to a new browser window, unless it is (they are) already the only tab(s) * in the current window, in which case this will do nothing. */ replaceTabsWithWindow(contextTab, aOptions = {}) { let tabs; if (contextTab.multiselected) { tabs = this.selectedTabs; } else { tabs = [contextTab]; } if (this.tabs.length == tabs.length) { return null; } if (tabs.length == 1) { return this.replaceTabWithWindow(tabs[0], aOptions); } // Play the closing animation for all selected tabs to give // immediate feedback while waiting for the new window to appear. if (!gReduceMotion) { for (let tab of tabs) { tab.style.maxWidth = ""; // ensure that fade-out transition happens tab.removeAttribute("fadein"); } } // Create a new window and make it adopt the tabs, preserving their relative order. // The initial tab of the new window will be selected, so it should adopt the // selected tab of the original window, if applicable, or else the first moving tab. // This avoids tab-switches in the new window, preserving tab laziness. // However, to avoid multiple tab-switches in the original window, the other tabs // should be adopted before the selected one. let { selectedTab } = gBrowser; if (!tabs.includes(selectedTab)) { selectedTab = tabs[0]; } let win = this.replaceTabWithWindow(selectedTab, aOptions); win.addEventListener( "before-initial-tab-adopted", () => { let index = 0; for (let tab of tabs) { if (tab !== selectedTab) { const newTab = win.gBrowser.adoptTab(tab, index); if (!newTab) { // The adoption failed. Restore "fadein" and don't increase the index. tab.setAttribute("fadein", "true"); continue; } } ++index; } // Restore tab selection let winVisibleTabs = win.gBrowser.visibleTabs; let winTabLength = winVisibleTabs.length; win.gBrowser.addRangeToMultiSelectedTabs( winVisibleTabs[0], winVisibleTabs[winTabLength - 1] ); win.gBrowser.lockClearMultiSelectionOnce(); }, { once: true } ); return win; }, _updateTabsAfterInsert() { for (let i = 0; i < this.tabs.length; i++) { this.tabs[i]._tPos = i; this.tabs[i]._selected = false; } // If we're in the midst of an async tab switch while calling // moveTabTo, we can get into a case where _visuallySelected // is set to true on two different tabs. // // What we want to do in moveTabTo is to remove logical selection // from all tabs, and then re-add logical selection to selectedTab // (and visual selection as well if we're not running with e10s, which // setting _selected will do automatically). // // If we're running with e10s, then the visual selection will not // be changed, which is fine, since if we weren't in the midst of a // tab switch, the previously visually selected tab should still be // correct, and if we are in the midst of a tab switch, then the async // tab switcher will set the visually selected tab once the tab switch // has completed. this.selectedTab._selected = true; }, moveTabTo(aTab, aIndex, aKeepRelatedTabs) { var oldPosition = aTab._tPos; if (oldPosition == aIndex) { return; } // Don't allow mixing pinned and unpinned tabs. if (aTab.pinned) { aIndex = Math.min(aIndex, this._numPinnedTabs - 1); } else { aIndex = Math.max(aIndex, this._numPinnedTabs); } if (oldPosition == aIndex) { return; } if (!aKeepRelatedTabs) { this._lastRelatedTabMap = new WeakMap(); } let wasFocused = document.activeElement == this.selectedTab; aIndex = aIndex < aTab._tPos ? aIndex : aIndex + 1; let neighbor = this.tabs[aIndex] || null; this.tabContainer._invalidateCachedTabs(); this.tabContainer.insertBefore(aTab, neighbor); this._updateTabsAfterInsert(); if (wasFocused) { this.selectedTab.focus(); } this.tabContainer._handleTabSelect(true); if (aTab.pinned) { this.tabContainer._positionPinnedTabs(); } this.tabContainer._setPositionalAttributes(); var evt = document.createEvent("UIEvents"); evt.initUIEvent("TabMove", true, false, window, oldPosition); aTab.dispatchEvent(evt); }, moveTabForward() { let nextTab = this.tabContainer.findNextTab(this.selectedTab, { direction: 1, filter: tab => !tab.hidden, }); if (nextTab) { this.moveTabTo(this.selectedTab, nextTab._tPos); } else if (this.arrowKeysShouldWrap) { this.moveTabToStart(); } }, /** * Adopts a tab from another browser window, and inserts it at aIndex * * @returns {object} * The new tab in the current window, null if the tab couldn't be adopted. */ adoptTab(aTab, aIndex, aSelectTab) { // Swap the dropped tab with a new one we create and then close // it in the other window (making it seem to have moved between // windows). We also ensure that the tab we create to swap into has // the same remote type and process as the one we're swapping in. // This makes sure we don't get a short-lived process for the new tab. let linkedBrowser = aTab.linkedBrowser; let createLazyBrowser = !aTab.linkedPanel; let params = { eventDetail: { adoptedTab: aTab }, preferredRemoteType: linkedBrowser.remoteType, initialBrowsingContextGroupId: linkedBrowser.browsingContext?.group.id, skipAnimation: true, index: aIndex, createLazyBrowser, }; let numPinned = this._numPinnedTabs; if (aIndex < numPinned || (aTab.pinned && aIndex == numPinned)) { params.pinned = true; } if (aTab.hasAttribute("usercontextid")) { // new tab must have the same usercontextid as the old one params.userContextId = aTab.getAttribute("usercontextid"); } let newTab = this.addWebTab("about:blank", params); let newBrowser = this.getBrowserForTab(newTab); aTab.container._finishAnimateTabMove(); if (!createLazyBrowser) { // Stop the about:blank load. newBrowser.stop(); // Make sure it has a docshell. newBrowser.docShell; } if (!this.swapBrowsersAndCloseOther(newTab, aTab)) { // Swapping wasn't permitted. Bail out. this.removeTab(newTab); return null; } if (aSelectTab) { this.selectedTab = newTab; } return newTab; }, moveTabBackward() { let previousTab = this.tabContainer.findNextTab(this.selectedTab, { direction: -1, filter: tab => !tab.hidden, }); if (previousTab) { this.moveTabTo(this.selectedTab, previousTab._tPos); } else if (this.arrowKeysShouldWrap) { this.moveTabToEnd(); } }, moveTabToStart() { let tabPos = this.selectedTab._tPos; if (tabPos > 0) { this.moveTabTo(this.selectedTab, 0); } }, moveTabToEnd() { let tabPos = this.selectedTab._tPos; if (tabPos < this.browsers.length - 1) { this.moveTabTo(this.selectedTab, this.browsers.length - 1); } }, moveTabOver(aEvent) { if ( (!RTL_UI && aEvent.keyCode == KeyEvent.DOM_VK_RIGHT) || (RTL_UI && aEvent.keyCode == KeyEvent.DOM_VK_LEFT) ) { this.moveTabForward(); } else { this.moveTabBackward(); } }, /** * @param aTab * Can be from a different window as well * @param aRestoreTabImmediately * Can defer loading of the tab contents * @param aOptions * The new index of the tab */ duplicateTab(aTab, aRestoreTabImmediately, aOptions) { return SessionStore.duplicateTab( window, aTab, 0, aRestoreTabImmediately, aOptions ); }, addToMultiSelectedTabs(aTab) { if (aTab.multiselected) { return; } aTab.setAttribute("multiselected", "true"); aTab.setAttribute("aria-selected", "true"); this._multiSelectedTabsSet.add(aTab); this._startMultiSelectChange(); if (this._multiSelectChangeRemovals.has(aTab)) { this._multiSelectChangeRemovals.delete(aTab); } else { this._multiSelectChangeAdditions.add(aTab); } }, /** * Adds two given tabs and all tabs between them into the (multi) selected tabs collection */ addRangeToMultiSelectedTabs(aTab1, aTab2) { if (aTab1 == aTab2) { return; } const tabs = this.visibleTabs; const indexOfTab1 = tabs.indexOf(aTab1); const indexOfTab2 = tabs.indexOf(aTab2); const [lowerIndex, higherIndex] = indexOfTab1 < indexOfTab2 ? [Math.max(0, indexOfTab1), indexOfTab2] : [Math.max(0, indexOfTab2), indexOfTab1]; for (let i = lowerIndex; i <= higherIndex; i++) { this.addToMultiSelectedTabs(tabs[i]); } }, removeFromMultiSelectedTabs(aTab) { if (!aTab.multiselected) { return; } aTab.removeAttribute("multiselected"); aTab.removeAttribute("aria-selected"); this._multiSelectedTabsSet.delete(aTab); this._startMultiSelectChange(); if (this._multiSelectChangeAdditions.has(aTab)) { this._multiSelectChangeAdditions.delete(aTab); } else { this._multiSelectChangeRemovals.add(aTab); } }, clearMultiSelectedTabs() { if (this._clearMultiSelectionLocked) { if (this._clearMultiSelectionLockedOnce) { this._clearMultiSelectionLockedOnce = false; this._clearMultiSelectionLocked = false; } return; } if (this.multiSelectedTabsCount < 1) { return; } for (let tab of this.selectedTabs) { this.removeFromMultiSelectedTabs(tab); } this._lastMultiSelectedTabRef = null; }, selectAllTabs() { let visibleTabs = this.visibleTabs; gBrowser.addRangeToMultiSelectedTabs( visibleTabs[0], visibleTabs[visibleTabs.length - 1] ); }, allTabsSelected() { return ( this.visibleTabs.length == 1 || this.visibleTabs.every(t => t.multiselected) ); }, lockClearMultiSelectionOnce() { this._clearMultiSelectionLockedOnce = true; this._clearMultiSelectionLocked = true; }, unlockClearMultiSelection() { this._clearMultiSelectionLockedOnce = false; this._clearMultiSelectionLocked = false; }, /** * Remove a tab from the multiselection if it's the only one left there. * * In fact, some scenario may lead to only one single tab multi-selected, * this is something to avoid (Chrome does the same) * Consider 4 tabs A,B,C,D with A having the focus * 1. select C with Ctrl * 2. Right-click on B and "Close Tabs to The Right" * * Expected result * C and D closing * A being the only multi-selected tab, selection should be cleared * * * Single selected tab could even happen with a none-focused tab. * For exemple with the menu "Close other tabs", it could happen * with a multi-selected pinned tab. * For illustration, consider 4 tabs A,B,C,D with B active * 1. pin A and Ctrl-select it * 2. Ctrl-select C * 3. right-click on D and click "Close Other Tabs" * * Expected result * B and C closing * A[pinned] being the only multi-selected tab, selection should be cleared. */ _avoidSingleSelectedTab() { if (this.multiSelectedTabsCount == 1) { this.clearMultiSelectedTabs(); } }, _switchToNextMultiSelectedTab() { this._clearMultiSelectionLocked = true; // Guarantee that _clearMultiSelectionLocked lock gets released. try { let lastMultiSelectedTab = this.lastMultiSelectedTab; if (!lastMultiSelectedTab.selected) { this.selectedTab = lastMultiSelectedTab; } else { let selectedTabs = ChromeUtils.nondeterministicGetWeakSetKeys( this._multiSelectedTabsSet ).filter(this._mayTabBeMultiselected); this.selectedTab = selectedTabs.at(-1); } } catch (e) { console.error(e); } this._clearMultiSelectionLocked = false; }, set selectedTabs(tabs) { this.clearMultiSelectedTabs(); this.selectedTab = tabs[0]; if (tabs.length > 1) { for (let tab of tabs) { this.addToMultiSelectedTabs(tab); } } }, get selectedTabs() { let { selectedTab, _multiSelectedTabsSet } = this; let tabs = ChromeUtils.nondeterministicGetWeakSetKeys( _multiSelectedTabsSet ).filter(this._mayTabBeMultiselected); if ( (!_multiSelectedTabsSet.has(selectedTab) && this._mayTabBeMultiselected(selectedTab)) || !tabs.length ) { tabs.push(selectedTab); } return tabs.sort((a, b) => a._tPos > b._tPos); }, get multiSelectedTabsCount() { return ChromeUtils.nondeterministicGetWeakSetKeys( this._multiSelectedTabsSet ).filter(this._mayTabBeMultiselected).length; }, get lastMultiSelectedTab() { let tab = this._lastMultiSelectedTabRef ? this._lastMultiSelectedTabRef.get() : null; if (tab && tab.isConnected && this._multiSelectedTabsSet.has(tab)) { return tab; } let selectedTab = this.selectedTab; this.lastMultiSelectedTab = selectedTab; return selectedTab; }, set lastMultiSelectedTab(aTab) { this._lastMultiSelectedTabRef = Cu.getWeakReference(aTab); }, _mayTabBeMultiselected(aTab) { return aTab.isConnected && !aTab.closing && !aTab.hidden; }, _startMultiSelectChange() { if (!this._multiSelectChangeStarted) { this._multiSelectChangeStarted = true; Promise.resolve().then(() => this._endMultiSelectChange()); } }, _endMultiSelectChange() { let noticeable = false; let { selectedTab } = this; if (this._multiSelectChangeAdditions.size) { if (!selectedTab.multiselected) { this.addToMultiSelectedTabs(selectedTab); } noticeable = true; } if (this._multiSelectChangeRemovals.size) { if (this._multiSelectChangeRemovals.has(selectedTab)) { this._switchToNextMultiSelectedTab(); } this._avoidSingleSelectedTab(); noticeable = true; } this._multiSelectChangeStarted = false; if (noticeable || this._multiSelectChangeSelected) { this._multiSelectChangeSelected = false; this._multiSelectChangeAdditions.clear(); this._multiSelectChangeRemovals.clear(); if (noticeable) { this.tabContainer._setPositionalAttributes(); } this.dispatchEvent( new CustomEvent("TabMultiSelect", { bubbles: true }) ); } }, toggleMuteAudioOnMultiSelectedTabs(aTab) { let tabMuted = aTab.linkedBrowser.audioMuted; let tabsToToggle = this.selectedTabs.filter( tab => tab.linkedBrowser.audioMuted == tabMuted ); for (let tab of tabsToToggle) { tab.toggleMuteAudio(); } }, resumeDelayedMediaOnMultiSelectedTabs() { for (let tab of this.selectedTabs) { tab.resumeDelayedMedia(); } }, pinMultiSelectedTabs() { for (let tab of this.selectedTabs) { this.pinTab(tab); } }, unpinMultiSelectedTabs() { // The selectedTabs getter returns the tabs // in visual order. We need to unpin in reverse // order to maintain visual order. let selectedTabs = this.selectedTabs; for (let i = selectedTabs.length - 1; i >= 0; i--) { let tab = selectedTabs[i]; this.unpinTab(tab); } }, activateBrowserForPrintPreview(aBrowser) { this._printPreviewBrowsers.add(aBrowser); if (this._switcher) { this._switcher.activateBrowserForPrintPreview(aBrowser); } aBrowser.docShellIsActive = true; }, deactivatePrintPreviewBrowsers() { let browsers = this._printPreviewBrowsers; this._printPreviewBrowsers = new Set(); for (let browser of browsers) { browser.docShellIsActive = this.shouldActivateDocShell(browser); } }, /** * Returns true if a given browser's docshell should be active. */ shouldActivateDocShell(aBrowser) { if (this._switcher) { return this._switcher.shouldActivateDocShell(aBrowser); } return ( (aBrowser == this.selectedBrowser && !document.hidden) || this._printPreviewBrowsers.has(aBrowser) || this.PictureInPicture.isOriginatingBrowser(aBrowser) ); }, _getSwitcher() { if (!this._switcher) { this._switcher = new this.AsyncTabSwitcher(this); } return this._switcher; }, warmupTab(aTab) { if (gMultiProcessBrowser) { this._getSwitcher().warmupTab(aTab); } }, /** * _maybeRequestReplyFromRemoteContent may call * aEvent.requestReplyFromRemoteContent if necessary. * * @param aEvent The handling event. * @return true if the handler should wait a reply event. * false if the handle can handle the immediately. */ _maybeRequestReplyFromRemoteContent(aEvent) { if (aEvent.defaultPrevented) { return false; } // If the event target is a remote browser, and the event has not been // handled by the remote content yet, we should wait a reply event // from the content. if (aEvent.isWaitingReplyFromRemoteContent) { return true; // Somebody called requestReplyFromRemoteContent already. } if ( !aEvent.isReplyEventFromRemoteContent && aEvent.target?.isRemoteBrowser === true ) { aEvent.requestReplyFromRemoteContent(); return true; } return false; }, _handleKeyDownEvent(aEvent) { if (!aEvent.isTrusted) { // Don't let untrusted events mess with tabs. return; } // Skip this only if something has explicitly cancelled it. if (aEvent.defaultCancelled) { return; } // Skip if chrome code has cancelled this: if (aEvent.defaultPreventedByChrome) { return; } // Don't check if the event was already consumed because tab // navigation should always work for better user experience. switch (ShortcutUtils.getSystemActionForEvent(aEvent)) { case ShortcutUtils.TOGGLE_CARET_BROWSING: this._maybeRequestReplyFromRemoteContent(aEvent); return; case ShortcutUtils.MOVE_TAB_BACKWARD: this.moveTabBackward(); aEvent.preventDefault(); return; case ShortcutUtils.MOVE_TAB_FORWARD: this.moveTabForward(); aEvent.preventDefault(); return; case ShortcutUtils.CLOSE_TAB: if (gBrowser.multiSelectedTabsCount) { gBrowser.removeMultiSelectedTabs(); } else if (!this.selectedTab.pinned) { this.removeCurrentTab({ animate: true }); } aEvent.preventDefault(); } }, toggleCaretBrowsing() { const kPrefShortcutEnabled = "accessibility.browsewithcaret_shortcut.enabled"; const kPrefWarnOnEnable = "accessibility.warn_on_browsewithcaret"; const kPrefCaretBrowsingOn = "accessibility.browsewithcaret"; var isEnabled = Services.prefs.getBoolPref(kPrefShortcutEnabled); if (!isEnabled || this._awaitingToggleCaretBrowsingPrompt) { return; } // Toggle browse with caret mode var browseWithCaretOn = Services.prefs.getBoolPref( kPrefCaretBrowsingOn, false ); var warn = Services.prefs.getBoolPref(kPrefWarnOnEnable, true); if (warn && !browseWithCaretOn) { var checkValue = { value: false }; var promptService = Services.prompt; try { this._awaitingToggleCaretBrowsingPrompt = true; const [title, message, checkbox] = this.tabLocalization.formatValuesSync([ "tabbrowser-confirm-caretbrowsing-title", "tabbrowser-confirm-caretbrowsing-message", "tabbrowser-confirm-caretbrowsing-checkbox", ]); var buttonPressed = promptService.confirmEx( window, title, message, // Make "No" the default: promptService.STD_YES_NO_BUTTONS | promptService.BUTTON_POS_1_DEFAULT, null, null, null, checkbox, checkValue ); } catch (ex) { return; } finally { this._awaitingToggleCaretBrowsingPrompt = false; } if (buttonPressed != 0) { if (checkValue.value) { try { Services.prefs.setBoolPref(kPrefShortcutEnabled, false); } catch (ex) {} } return; } if (checkValue.value) { try { Services.prefs.setBoolPref(kPrefWarnOnEnable, false); } catch (ex) {} } } // Toggle the pref try { Services.prefs.setBoolPref(kPrefCaretBrowsingOn, !browseWithCaretOn); } catch (ex) {} }, _handleKeyPressEvent(aEvent) { if (!aEvent.isTrusted) { // Don't let untrusted events mess with tabs. return; } // Skip this only if something has explicitly cancelled it. if (aEvent.defaultCancelled) { return; } // Skip if chrome code has cancelled this: if (aEvent.defaultPreventedByChrome) { return; } switch (ShortcutUtils.getSystemActionForEvent(aEvent, { rtl: RTL_UI })) { case ShortcutUtils.TOGGLE_CARET_BROWSING: if ( aEvent.defaultPrevented || this._maybeRequestReplyFromRemoteContent(aEvent) ) { break; } this.toggleCaretBrowsing(); break; case ShortcutUtils.NEXT_TAB: if (AppConstants.platform == "macosx") { this.tabContainer.advanceSelectedTab(1, true); aEvent.preventDefault(); } break; case ShortcutUtils.PREVIOUS_TAB: if (AppConstants.platform == "macosx") { this.tabContainer.advanceSelectedTab(-1, true); aEvent.preventDefault(); } break; } }, getTabTooltip(tab, includeLabel = true) { let labelArray = []; if (includeLabel) { labelArray.push(tab._fullLabel || tab.getAttribute("label")); } if ( Services.prefs.getBoolPref( "browser.tabs.tooltipsShowPidAndActiveness", false ) ) { if (tab.linkedBrowser) { // Show the PIDs of the content process and remote subframe processes. let [contentPid, ...framePids] = E10SUtils.getBrowserPids( tab.linkedBrowser, gFissionBrowser ); if (contentPid) { if (framePids && framePids.length) { labelArray.push( `(pids ${contentPid}, ${framePids.sort().join(", ")})` ); } else { labelArray.push(`(pid ${contentPid})`); } } if (tab.linkedBrowser.docShellIsActive) { labelArray.push("[A]"); } } } let label = labelArray.join(" "); if (tab.userContextId) { const containerName = ContextualIdentityService.getUserContextLabel( tab.userContextId ); label = this.tabLocalization.formatValueSync( "tabbrowser-container-tab-title", { title: label, containerName } ); } labelArray = [label]; if (tab.soundPlaying) { let audioPlayingString = this.tabLocalization.formatValueSync( "tabbrowser-tab-audio-playing-description" ); labelArray.push(audioPlayingString); } return labelArray.join("\n"); }, createTooltip(event) { event.stopPropagation(); let tab = event.target.triggerNode?.closest("tab"); if (!tab) { event.preventDefault(); return; } const tooltip = event.target; tooltip.removeAttribute("data-l10n-id"); const tabCount = this.selectedTabs.includes(tab) ? this.selectedTabs.length : 1; if (tab.mOverCloseButton) { tooltip.label = ""; document.l10n.setAttributes(tooltip, "tabbrowser-close-tabs-tooltip", { tabCount, }); } else if (tab._overPlayingIcon) { let l10nId; const l10nArgs = { tabCount }; if (tab.selected) { l10nId = tab.linkedBrowser.audioMuted ? "tabbrowser-unmute-tab-audio-tooltip" : "tabbrowser-mute-tab-audio-tooltip"; const keyElem = document.getElementById("key_toggleMute"); l10nArgs.shortcut = ShortcutUtils.prettifyShortcut(keyElem); } else if (tab.hasAttribute("activemedia-blocked")) { l10nId = "tabbrowser-unblock-tab-audio-tooltip"; } else { l10nId = tab.linkedBrowser.audioMuted ? "tabbrowser-unmute-tab-audio-background-tooltip" : "tabbrowser-mute-tab-audio-background-tooltip"; } tooltip.label = ""; document.l10n.setAttributes(tooltip, l10nId, l10nArgs); } else { tooltip.label = this.getTabTooltip(tab, true); } }, handleEvent(aEvent) { switch (aEvent.type) { case "keydown": this._handleKeyDownEvent(aEvent); break; case "keypress": this._handleKeyPressEvent(aEvent); break; case "framefocusrequested": { let tab = this.getTabForBrowser(aEvent.target); if (!tab || tab == this.selectedTab) { // Let the focus manager try to do its thing by not calling // preventDefault(). It will still raise the window if appropriate. break; } this.selectedTab = tab; window.focus(); aEvent.preventDefault(); break; } case "visibilitychange": const inactive = document.hidden; if (!this._switcher) { this.selectedBrowser.preserveLayers(inactive); this.selectedBrowser.docShellIsActive = !inactive; } break; } }, observe(aSubject, aTopic, aData) { switch (aTopic) { case "contextual-identity-updated": { let identity = aSubject.wrappedJSObject; for (let tab of this.tabs) { if (tab.getAttribute("usercontextid") == identity.userContextId) { ContextualIdentityService.setTabStyle(tab); } } break; } } }, refreshBlocked(actor, browser, data) { // The data object is expected to contain the following properties: // - URI (string) // The URI that a page is attempting to refresh or redirect to. // - delay (int) // The delay (in milliseconds) before the page was going to // reload or redirect. // - sameURI (bool) // true if we're refreshing the page. false if we're redirecting. let notificationBox = this.getNotificationBox(browser); let notification = notificationBox.getNotificationWithValue("refresh-blocked"); let l10nId = data.sameURI ? "refresh-blocked-refresh-label" : "refresh-blocked-redirect-label"; if (notification) { notification.label = { "l10n-id": l10nId }; } else { const buttons = [ { "l10n-id": "refresh-blocked-allow", callback() { actor.sendAsyncMessage("RefreshBlocker:Refresh", data); }, }, ]; notificationBox.appendNotification( "refresh-blocked", { label: { "l10n-id": l10nId }, image: "chrome://browser/skin/notification-icons/popup.svg", priority: notificationBox.PRIORITY_INFO_MEDIUM, }, buttons ); } }, _generateUniquePanelID() { if (!this._uniquePanelIDCounter) { this._uniquePanelIDCounter = 0; } let outerID = window.docShell.outerWindowID; // We want panel IDs to be globally unique, that's why we include the // window ID. We switched to a monotonic counter as Date.now() lead // to random failures because of colliding IDs. return "panel-" + outerID + "-" + ++this._uniquePanelIDCounter; }, destroy() { this.tabContainer.destroy(); Services.obs.removeObserver(this, "contextual-identity-updated"); for (let tab of this.tabs) { let browser = tab.linkedBrowser; if (browser.registeredOpenURI) { let userContextId = browser.getAttribute("usercontextid") || 0; this.UrlbarProviderOpenTabs.unregisterOpenTab( browser.registeredOpenURI.spec, userContextId, PrivateBrowsingUtils.isWindowPrivate(window) ); delete browser.registeredOpenURI; } let filter = this._tabFilters.get(tab); if (filter) { browser.webProgress.removeProgressListener(filter); let listener = this._tabListeners.get(tab); if (listener) { filter.removeProgressListener(listener); listener.destroy(); } this._tabFilters.delete(tab); this._tabListeners.delete(tab); } } Services.els.removeSystemEventListener(document, "keydown", this, false); if (AppConstants.platform == "macosx") { Services.els.removeSystemEventListener( document, "keypress", this, false ); } document.removeEventListener("visibilitychange", this); window.removeEventListener("framefocusrequested", this); if (gMultiProcessBrowser) { if (this._switcher) { this._switcher.destroy(); } } }, _setupEventListeners() { this.tabpanels.addEventListener("select", event => { if (event.target == this.tabpanels) { this.updateCurrentBrowser(); } }); this.addEventListener("DOMWindowClose", event => { let browser = event.target; if (!browser.isRemoteBrowser) { if (!event.isTrusted) { // If the browser is not remote, then we expect the event to be trusted. // In the remote case, the DOMWindowClose event is captured in content, // a message is sent to the parent, and another DOMWindowClose event // is re-dispatched on the actual browser node. In that case, the event // won't be marked as trusted, since it's synthesized by JavaScript. return; } // In the parent-process browser case, it's possible that the browser // that fired DOMWindowClose is actually a child of another browser. We // want to find the top-most browser to determine whether or not this is // for a tab or not. The chromeEventHandler will be the top-most browser. browser = event.target.docShell.chromeEventHandler; } if (this.tabs.length == 1) { // We already did PermitUnload in the content process // for this tab (the only one in the window). So we don't // need to do it again for any tabs. window.skipNextCanClose = true; // In the parent-process browser case, the nsCloseEvent will actually take // care of tearing down the window, but we need to do this ourselves in the // content-process browser case. Doing so in both cases doesn't appear to // hurt. window.close(); return; } let tab = this.getTabForBrowser(browser); if (tab) { // Skip running PermitUnload since it already happened in // the content process. this.removeTab(tab, { skipPermitUnload: true }); // If we don't preventDefault on the DOMWindowClose event, then // in the parent-process browser case, we're telling the platform // to close the entire window. Calling preventDefault is our way of // saying we took care of this close request by closing the tab. event.preventDefault(); } }); this.addEventListener("pagetitlechanged", event => { let browser = event.target; let tab = this.getTabForBrowser(browser); if (!tab || tab.hasAttribute("pending")) { return; } // Ignore empty title changes on internal pages. This prevents the title // from changing while Fluent is populating the (initially-empty) title // element. if ( !browser.contentTitle && browser.contentPrincipal.isSystemPrincipal ) { return; } let titleChanged = this.setTabTitle(tab); if (titleChanged && !tab.selected && !tab.hasAttribute("busy")) { tab.setAttribute("titlechanged", "true"); } }); this.addEventListener( "DOMWillOpenModalDialog", event => { if (!event.isTrusted) { return; } let targetIsWindow = Window.isInstance(event.target); // We're about to open a modal dialog, so figure out for which tab: // If this is a same-process modal dialog, then we're given its DOM // window as the event's target. For remote dialogs, we're given the // browser, but that's in the originalTarget and not the target, // because it's across the tabbrowser's XBL boundary. let tabForEvent = targetIsWindow ? this.getTabForBrowser(event.target.docShell.chromeEventHandler) : this.getTabForBrowser(event.originalTarget); // Focus window for beforeunload dialog so it is seen but don't // steal focus from other applications. if ( event.detail && event.detail.tabPrompt && event.detail.inPermitUnload && Services.focus.activeWindow ) { window.focus(); } // Don't need to act if the tab is already selected or if there isn't // a tab for the event (e.g. for the webextensions options_ui remote // browsers embedded in the "about:addons" page): if (!tabForEvent || tabForEvent.selected) { return; } // We always switch tabs for beforeunload tab-modal prompts. if ( event.detail && event.detail.tabPrompt && !event.detail.inPermitUnload ) { let docPrincipal = targetIsWindow ? event.target.document.nodePrincipal : null; // At least one of these should/will be non-null: let promptPrincipal = event.detail.promptPrincipal || docPrincipal || tabForEvent.linkedBrowser.contentPrincipal; // For null principals, we bail immediately and don't show the checkbox: if (!promptPrincipal || promptPrincipal.isNullPrincipal) { tabForEvent.attention = true; return; } // For non-system/expanded principals without permission, we bail and show the checkbox. if (promptPrincipal.URI && !promptPrincipal.isSystemPrincipal) { let permission = Services.perms.testPermissionFromPrincipal( promptPrincipal, "focus-tab-by-prompt" ); if (permission != Services.perms.ALLOW_ACTION) { // Tell the prompt box we want to show the user a checkbox: let tabPrompt = Services.prefs.getBoolPref( "prompts.contentPromptSubDialog" ) ? this.getTabDialogBox(tabForEvent.linkedBrowser) : this.getTabModalPromptBox(tabForEvent.linkedBrowser); tabPrompt.onNextPromptShowAllowFocusCheckboxFor( promptPrincipal ); tabForEvent.attention = true; return; } } // ... so system and expanded principals, as well as permitted "normal" // URI-based principals, always get to steal focus for the tab when prompting. } // If permissions/origins dictate so, bring tab to the front. this.selectedTab = tabForEvent; }, true ); // When cancelling beforeunload tabmodal dialogs, reset the URL bar to // avoid spoofing risks. this.addEventListener( "DOMModalDialogClosed", event => { if ( !event.detail?.wasPermitUnload || event.detail.areLeaving || event.target.nodeName != "browser" ) { return; } event.target.userTypedValue = null; if (event.target == this.selectedBrowser) { gURLBar.setURI(); } }, true ); let onTabCrashed = event => { if (!event.isTrusted) { return; } let browser = event.originalTarget; if (!event.isTopFrame) { TabCrashHandler.onSubFrameCrash(browser, event.childID); return; } // Preloaded browsers do not actually have any tabs. If one crashes, // it should be released and removed. if (browser === this.preloadedBrowser) { NewTabPagePreloading.removePreloadedBrowser(window); return; } let isRestartRequiredCrash = event.type == "oop-browser-buildid-mismatch"; let icon = browser.mIconURL; let tab = this.getTabForBrowser(browser); if (this.selectedBrowser == browser) { TabCrashHandler.onSelectedBrowserCrash( browser, isRestartRequiredCrash ); } else { TabCrashHandler.onBackgroundBrowserCrash( browser, isRestartRequiredCrash ); } tab.removeAttribute("soundplaying"); this.setIcon(tab, icon); }; this.addEventListener("oop-browser-crashed", onTabCrashed); this.addEventListener("oop-browser-buildid-mismatch", onTabCrashed); this.addEventListener("DOMAudioPlaybackStarted", event => { var tab = this.getTabFromAudioEvent(event); if (!tab) { return; } clearTimeout(tab._soundPlayingAttrRemovalTimer); tab._soundPlayingAttrRemovalTimer = 0; let modifiedAttrs = []; if (tab.hasAttribute("soundplaying-scheduledremoval")) { tab.removeAttribute("soundplaying-scheduledremoval"); modifiedAttrs.push("soundplaying-scheduledremoval"); } if (!tab.hasAttribute("soundplaying")) { tab.setAttribute("soundplaying", true); modifiedAttrs.push("soundplaying"); } if (modifiedAttrs.length) { // Flush style so that the opacity takes effect immediately, in // case the media is stopped before the style flushes naturally. getComputedStyle(tab).opacity; } this._tabAttrModified(tab, modifiedAttrs); }); this.addEventListener("DOMAudioPlaybackStopped", event => { var tab = this.getTabFromAudioEvent(event); if (!tab) { return; } if (tab.hasAttribute("soundplaying")) { let removalDelay = Services.prefs.getIntPref( "browser.tabs.delayHidingAudioPlayingIconMS" ); tab.style.setProperty( "--soundplaying-removal-delay", `${removalDelay - 300}ms` ); tab.setAttribute("soundplaying-scheduledremoval", "true"); this._tabAttrModified(tab, ["soundplaying-scheduledremoval"]); tab._soundPlayingAttrRemovalTimer = setTimeout(() => { tab.removeAttribute("soundplaying-scheduledremoval"); tab.removeAttribute("soundplaying"); this._tabAttrModified(tab, [ "soundplaying", "soundplaying-scheduledremoval", ]); }, removalDelay); } }); this.addEventListener("DOMAudioPlaybackBlockStarted", event => { var tab = this.getTabFromAudioEvent(event); if (!tab) { return; } if (!tab.hasAttribute("activemedia-blocked")) { tab.setAttribute("activemedia-blocked", true); this._tabAttrModified(tab, ["activemedia-blocked"]); } }); this.addEventListener("DOMAudioPlaybackBlockStopped", event => { var tab = this.getTabFromAudioEvent(event); if (!tab) { return; } if (tab.hasAttribute("activemedia-blocked")) { tab.removeAttribute("activemedia-blocked"); this._tabAttrModified(tab, ["activemedia-blocked"]); let hist = Services.telemetry.getHistogramById( "TAB_AUDIO_INDICATOR_USED" ); hist.add(2 /* unblockByVisitingTab */); } }); this.addEventListener("GloballyAutoplayBlocked", event => { let browser = event.originalTarget; let tab = this.getTabForBrowser(browser); if (!tab) { return; } SitePermissions.setForPrincipal( browser.contentPrincipal, "autoplay-media", SitePermissions.BLOCK, SitePermissions.SCOPE_GLOBAL, browser ); }); let tabContextFTLInserter = () => { this.translateTabContextMenu(); this.tabContainer.removeEventListener( "contextmenu", tabContextFTLInserter, true ); this.tabContainer.removeEventListener( "mouseover", tabContextFTLInserter ); this.tabContainer.removeEventListener( "focus", tabContextFTLInserter, true ); }; this.tabContainer.addEventListener( "contextmenu", tabContextFTLInserter, true ); this.tabContainer.addEventListener("mouseover", tabContextFTLInserter); this.tabContainer.addEventListener("focus", tabContextFTLInserter, true); // Fired when Gecko has decided a element will change // remoteness. This allows persisting some state on this element across // process switches. this.addEventListener("WillChangeBrowserRemoteness", event => { let browser = event.originalTarget; let tab = this.getTabForBrowser(browser); if (!tab) { return; } // Dispatch the `BeforeTabRemotenessChange` event, allowing other code // to react to this tab's process switch. let evt = document.createEvent("Events"); evt.initEvent("BeforeTabRemotenessChange", true, false); tab.dispatchEvent(evt); let wasActive = document.activeElement == browser; // Unhook our progress listener. let filter = this._tabFilters.get(tab); let oldListener = this._tabListeners.get(tab); browser.webProgress.removeProgressListener(filter); filter.removeProgressListener(oldListener); let stateFlags = oldListener.mStateFlags; let requestCount = oldListener.mRequestCount; // We'll be creating a new listener, so destroy the old one. oldListener.destroy(); let oldDroppedLinkHandler = browser.droppedLinkHandler; let oldUserTypedValue = browser.userTypedValue; let hadStartedLoad = browser.didStartLoadSinceLastUserTyping(); let didChange = didChangeEvent => { browser.userTypedValue = oldUserTypedValue; if (hadStartedLoad) { browser.urlbarChangeTracker.startedLoad(); } browser.droppedLinkHandler = oldDroppedLinkHandler; // This shouldn't really be necessary, however, this has the side effect // of sending MozLayerTreeReady / MozLayerTreeCleared events for remote // frames, which the tab switcher depends on. // // eslint-disable-next-line no-self-assign browser.docShellIsActive = browser.docShellIsActive; // Create a new tab progress listener for the new browser we just // injected, since tab progress listeners have logic for handling the // initial about:blank load let listener = new TabProgressListener( tab, browser, false, false, stateFlags, requestCount ); this._tabListeners.set(tab, listener); filter.addProgressListener(listener, Ci.nsIWebProgress.NOTIFY_ALL); // Restore the progress listener. browser.webProgress.addProgressListener( filter, Ci.nsIWebProgress.NOTIFY_ALL ); let cbEvent = browser.getContentBlockingEvents(); // Include the true final argument to indicate that this event is // simulated (instead of being observed by the webProgressListener). this._callProgressListeners( browser, "onContentBlockingEvent", [browser.webProgress, null, cbEvent, true], true, false ); if (browser.isRemoteBrowser) { // Switching the browser to be remote will connect to a new child // process so the browser can no longer be considered to be // crashed. tab.removeAttribute("crashed"); gBrowser.tabContainer.updateTabIndicatorAttr(tab); } if (wasActive) { browser.focus(); } if (this.isFindBarInitialized(tab)) { this.getCachedFindBar(tab).browser = browser; } evt = document.createEvent("Events"); evt.initEvent("TabRemotenessChange", true, false); tab.dispatchEvent(evt); }; browser.addEventListener("DidChangeBrowserRemoteness", didChange, { once: true, }); }); this.addEventListener("pageinfo", event => { let browser = event.originalTarget; let tab = this.getTabForBrowser(browser); if (!tab) { return; } const { url, description, previewImageURL } = event.detail; this.setPageInfo(url, description, previewImageURL); }); }, translateTabContextMenu() { if (this._tabContextMenuTranslated) { return; } MozXULElement.insertFTLIfNeeded("browser/tabContextMenu.ftl"); // Un-lazify the l10n-ids now that the FTL file has been inserted. document .getElementById("tabContextMenu") .querySelectorAll("[data-lazy-l10n-id]") .forEach(el => { el.setAttribute("data-l10n-id", el.getAttribute("data-lazy-l10n-id")); el.removeAttribute("data-lazy-l10n-id"); }); this._tabContextMenuTranslated = true; }, setSuccessor(aTab, successorTab) { if (aTab.ownerGlobal != window) { throw new Error("Cannot set the successor of another window's tab"); } if (successorTab == aTab) { successorTab = null; } if (successorTab && successorTab.ownerGlobal != window) { throw new Error("Cannot set the successor to another window's tab"); } if (aTab.successor) { aTab.successor.predecessors.delete(aTab); } aTab.successor = successorTab; if (successorTab) { if (!successorTab.predecessors) { successorTab.predecessors = new Set(); } successorTab.predecessors.add(aTab); } }, /** * For all tabs with aTab as a successor, set the successor to aOtherTab * instead. */ replaceInSuccession(aTab, aOtherTab) { if (aTab.predecessors) { for (const predecessor of Array.from(aTab.predecessors)) { this.setSuccessor(predecessor, aOtherTab); } } }, /** * Get the triggering principal for the last navigation in the session history. */ _getTriggeringPrincipalFromHistory(aBrowser) { let sessionHistory = aBrowser?.browsingContext?.sessionHistory; if ( !sessionHistory || !sessionHistory.index || sessionHistory.count == 0 ) { return undefined; } let currentEntry = sessionHistory.getEntryAtIndex(sessionHistory.index); let triggeringPrincipal = currentEntry?.triggeringPrincipal; return triggeringPrincipal; }, clearRelatedTabs() { this._lastRelatedTabMap = new WeakMap(); }, }; /** * A web progress listener object definition for a given tab. */ class TabProgressListener { constructor( aTab, aBrowser, aStartsBlank, aWasPreloadedBrowser, aOrigStateFlags, aOrigRequestCount ) { let stateFlags = aOrigStateFlags || 0; // Initialize mStateFlags to non-zero e.g. when creating a progress // listener for preloaded browsers as there was no progress listener // around when the content started loading. If the content didn't // quite finish loading yet, mStateFlags will very soon be overridden // with the correct value and end up at STATE_STOP again. if (aWasPreloadedBrowser) { stateFlags = Ci.nsIWebProgressListener.STATE_STOP | Ci.nsIWebProgressListener.STATE_IS_REQUEST; } this.mTab = aTab; this.mBrowser = aBrowser; this.mBlank = aStartsBlank; // cache flags for correct status UI update after tab switching this.mStateFlags = stateFlags; this.mStatus = 0; this.mMessage = ""; this.mTotalProgress = 0; // count of open requests (should always be 0 or 1) this.mRequestCount = aOrigRequestCount || 0; } destroy() { delete this.mTab; delete this.mBrowser; } _callProgressListeners(...args) { args.unshift(this.mBrowser); return gBrowser._callProgressListeners.apply(gBrowser, args); } _shouldShowProgress(aRequest) { if (this.mBlank) { return false; } // Don't show progress indicators in tabs for about: URIs // pointing to local resources. if ( aRequest instanceof Ci.nsIChannel && aRequest.originalURI.schemeIs("about") ) { return false; } return true; } _isForInitialAboutBlank(aWebProgress, aStateFlags, aLocation) { if (!this.mBlank || !aWebProgress.isTopLevel) { return false; } // If the state has STATE_STOP, and no requests were in flight, then this // must be the initial "stop" for the initial about:blank document. if ( aStateFlags & Ci.nsIWebProgressListener.STATE_STOP && this.mRequestCount == 0 && !aLocation ) { return true; } let location = aLocation ? aLocation.spec : ""; return location == "about:blank"; } onProgressChange( aWebProgress, aRequest, aCurSelfProgress, aMaxSelfProgress, aCurTotalProgress, aMaxTotalProgress ) { this.mTotalProgress = aMaxTotalProgress ? aCurTotalProgress / aMaxTotalProgress : 0; if (!this._shouldShowProgress(aRequest)) { return; } if (this.mTotalProgress && this.mTab.hasAttribute("busy")) { this.mTab.setAttribute("progress", "true"); gBrowser._tabAttrModified(this.mTab, ["progress"]); } this._callProgressListeners("onProgressChange", [ aWebProgress, aRequest, aCurSelfProgress, aMaxSelfProgress, aCurTotalProgress, aMaxTotalProgress, ]); } onProgressChange64( aWebProgress, aRequest, aCurSelfProgress, aMaxSelfProgress, aCurTotalProgress, aMaxTotalProgress ) { return this.onProgressChange( aWebProgress, aRequest, aCurSelfProgress, aMaxSelfProgress, aCurTotalProgress, aMaxTotalProgress ); } /* eslint-disable complexity */ onStateChange(aWebProgress, aRequest, aStateFlags, aStatus) { if (!aRequest) { return; } let location, originalLocation; try { aRequest.QueryInterface(Ci.nsIChannel); location = aRequest.URI; originalLocation = aRequest.originalURI; } catch (ex) {} let ignoreBlank = this._isForInitialAboutBlank( aWebProgress, aStateFlags, location ); const { STATE_START, STATE_STOP, STATE_IS_NETWORK } = Ci.nsIWebProgressListener; // If we were ignoring some messages about the initial about:blank, and we // got the STATE_STOP for it, we'll want to pay attention to those messages // from here forward. Similarly, if we conclude that this state change // is one that we shouldn't be ignoring, then stop ignoring. if ( (ignoreBlank && aStateFlags & STATE_STOP && aStateFlags & STATE_IS_NETWORK) || (!ignoreBlank && this.mBlank) ) { this.mBlank = false; } if (aStateFlags & STATE_START && aStateFlags & STATE_IS_NETWORK) { this.mRequestCount++; if (aWebProgress.isTopLevel) { // Need to use originalLocation rather than location because things // like about:home and about:privatebrowsing arrive with nsIRequest // pointing to their resolved jar: or file: URIs. if ( !( originalLocation && gInitialPages.includes(originalLocation.spec) && originalLocation != "about:blank" && this.mBrowser.initialPageLoadedFromUserAction != originalLocation.spec && this.mBrowser.currentURI && this.mBrowser.currentURI.spec == "about:blank" ) ) { // Indicating that we started a load will allow the location // bar to be cleared when the load finishes. // In order to not overwrite user-typed content, we avoid it // (see if condition above) in a very specific case: // If the load is of an 'initial' page (e.g. about:privatebrowsing, // about:newtab, etc.), was not explicitly typed in the location // bar by the user, is not about:blank (because about:blank can be // loaded by websites under their principal), and the current // page in the browser is about:blank (indicating it is a newly // created or re-created browser, e.g. because it just switched // remoteness or is a new tab/window). this.mBrowser.urlbarChangeTracker.startedLoad(); // To improve the user experience and perceived performance when // opening links in new tabs, we show the url and tab title sooner, // but only if it's safe (from a phishing point of view) to do so, // thus there's no session history and the load starts from a // non-web-controlled blank page. if ( this.mBrowser.browsingContext.sessionHistory?.count === 0 && BrowserUIUtils.checkEmptyPageOrigin( this.mBrowser, originalLocation ) ) { gBrowser.setInitialTabTitle(this.mTab, originalLocation.spec, { isURL: true, }); this.mBrowser.browsingContext.nonWebControlledBlankURI = originalLocation; if (this.mTab.selected && !gBrowser.userTypedValue) { gURLBar.setURI(); } } } delete this.mBrowser.initialPageLoadedFromUserAction; // If the browser is loading it must not be crashed anymore this.mTab.removeAttribute("crashed"); gBrowser.tabContainer.updateTabIndicatorAttr(this.mTab); } if (this._shouldShowProgress(aRequest)) { if ( !(aStateFlags & Ci.nsIWebProgressListener.STATE_RESTORING) && aWebProgress && aWebProgress.isTopLevel ) { this.mTab.setAttribute("busy", "true"); gBrowser._tabAttrModified(this.mTab, ["busy"]); this.mTab._notselectedsinceload = !this.mTab.selected; gBrowser.syncThrobberAnimations(this.mTab); } if (this.mTab.selected) { gBrowser._isBusy = true; } } } else if (aStateFlags & STATE_STOP && aStateFlags & STATE_IS_NETWORK) { // since we (try to) only handle STATE_STOP of the last request, // the count of open requests should now be 0 this.mRequestCount = 0; let modifiedAttrs = []; if (this.mTab.hasAttribute("busy")) { this.mTab.removeAttribute("busy"); modifiedAttrs.push("busy"); // Only animate the "burst" indicating the page has loaded if // the top-level page is the one that finished loading. if ( aWebProgress.isTopLevel && !aWebProgress.isLoadingDocument && Components.isSuccessCode(aStatus) && !gBrowser.tabAnimationsInProgress && !gReduceMotion ) { if (this.mTab._notselectedsinceload) { this.mTab.setAttribute("notselectedsinceload", "true"); } else { this.mTab.removeAttribute("notselectedsinceload"); } this.mTab.setAttribute("bursting", "true"); } } if (this.mTab.hasAttribute("progress")) { this.mTab.removeAttribute("progress"); modifiedAttrs.push("progress"); } if (modifiedAttrs.length) { gBrowser._tabAttrModified(this.mTab, modifiedAttrs); } if (aWebProgress.isTopLevel) { let isSuccessful = Components.isSuccessCode(aStatus); if (!isSuccessful && !this.mTab.isEmpty) { // Restore the current document's location in case the // request was stopped (possibly from a content script) // before the location changed. this.mBrowser.userTypedValue = null; // When browser.tabs.documentchannel.parent-controlled pref and SHIP // are enabled and a load gets cancelled due to another one // starting, the error is NS_BINDING_CANCELLED_OLD_LOAD. // When these prefs are not enabled, the error is different and // that's why we still want to look at the isNavigating flag. // We could add a workaround and make sure that in the alternative // codepaths we would also omit the same error, but considering // how we will be enabling fission by default soon, we can keep // using isNavigating for now, and remove it when the // parent-controlled pref and SHIP are enabled by default. // Bug 1725716 has been filed to consider removing isNavigating // field alltogether. let isNavigating = this.mBrowser.isNavigating; if ( this.mTab.selected && aStatus != Cr.NS_BINDING_CANCELLED_OLD_LOAD && !isNavigating ) { gURLBar.setURI(); } } else if (isSuccessful) { this.mBrowser.urlbarChangeTracker.finishedLoad(); } } // If we don't already have an icon for this tab then clear the tab's // icon. Don't do this on the initial about:blank load to prevent // flickering. Don't clear the icon if we already set it from one of the // known defaults. Note we use the original URL since about:newtab // redirects to a prerendered page. if ( !this.mBrowser.mIconURL && !ignoreBlank && !(originalLocation.spec in FAVICON_DEFAULTS) ) { this.mTab.removeAttribute("image"); } // For keyword URIs clear the user typed value since they will be changed into real URIs if (location.scheme == "keyword") { this.mBrowser.userTypedValue = null; } if (this.mTab.selected) { gBrowser._isBusy = false; } } if (ignoreBlank) { this._callProgressListeners( "onUpdateCurrentBrowser", [aStateFlags, aStatus, "", 0], true, false ); } else { this._callProgressListeners( "onStateChange", [aWebProgress, aRequest, aStateFlags, aStatus], true, false ); } this._callProgressListeners( "onStateChange", [aWebProgress, aRequest, aStateFlags, aStatus], false ); if (aStateFlags & (STATE_START | STATE_STOP)) { // reset cached temporary values at beginning and end this.mMessage = ""; this.mTotalProgress = 0; } this.mStateFlags = aStateFlags; this.mStatus = aStatus; } /* eslint-enable complexity */ onLocationChange(aWebProgress, aRequest, aLocation, aFlags) { // OnLocationChange is called for both the top-level content // and the subframes. let topLevel = aWebProgress.isTopLevel; let isSameDocument = !!( aFlags & Ci.nsIWebProgressListener.LOCATION_CHANGE_SAME_DOCUMENT ); if (topLevel) { let isReload = !!( aFlags & Ci.nsIWebProgressListener.LOCATION_CHANGE_RELOAD ); let isErrorPage = !!( aFlags & Ci.nsIWebProgressListener.LOCATION_CHANGE_ERROR_PAGE ); // We need to clear the typed value // if the document failed to load, to make sure the urlbar reflects the // failed URI (particularly for SSL errors). However, don't clear the value // if the error page's URI is about:blank, because that causes complete // loss of urlbar contents for invalid URI errors (see bug 867957). // Another reason to clear the userTypedValue is if this was an anchor // navigation initiated by the user. // Finally, we do insert the URL if this is a same-document navigation // and the user cleared the URL manually. if ( this.mBrowser.didStartLoadSinceLastUserTyping() || (isErrorPage && aLocation.spec != "about:blank") || (isSameDocument && this.mBrowser.isNavigating) || (isSameDocument && !this.mBrowser.userTypedValue) ) { this.mBrowser.userTypedValue = null; } // If the tab has been set to "busy" outside the stateChange // handler below (e.g. by sessionStore.navigateAndRestore), and // the load results in an error page, it's possible that there // isn't any (STATE_IS_NETWORK & STATE_STOP) state to cause busy // attribute being removed. In this case we should remove the // attribute here. if (isErrorPage && this.mTab.hasAttribute("busy")) { this.mTab.removeAttribute("busy"); gBrowser._tabAttrModified(this.mTab, ["busy"]); } if (!isSameDocument) { // If the browser was playing audio, we should remove the playing state. if (this.mTab.hasAttribute("soundplaying")) { clearTimeout(this.mTab._soundPlayingAttrRemovalTimer); this.mTab._soundPlayingAttrRemovalTimer = 0; this.mTab.removeAttribute("soundplaying"); gBrowser._tabAttrModified(this.mTab, ["soundplaying"]); } // If the browser was previously muted, we should restore the muted state. if (this.mTab.hasAttribute("muted")) { this.mTab.linkedBrowser.mute(); } if (gBrowser.isFindBarInitialized(this.mTab)) { let findBar = gBrowser.getCachedFindBar(this.mTab); // Close the Find toolbar if we're in old-style TAF mode if (findBar.findMode != findBar.FIND_NORMAL) { findBar.close(); } } // Note that we're not updating for same-document loads, despite // the `title` argument to `history.pushState/replaceState`. For // context, see https://bugzilla.mozilla.org/show_bug.cgi?id=585653 // and https://github.com/whatwg/html/issues/2174 if (!isReload) { gBrowser.setTabTitle(this.mTab); } // Don't clear the favicon if this tab is in the pending // state, as SessionStore will have set the icon for us even // though we're pointed at an about:blank. Also don't clear it // if the tab is in customize mode, to keep the one set by // gCustomizeMode.setTab (bug 1551239). Also don't clear it // if onLocationChange was triggered by a pushState or a // replaceState (bug 550565) or a hash change (bug 408415). if ( !this.mTab.hasAttribute("pending") && !this.mTab.hasAttribute("customizemode") && aWebProgress.isLoadingDocument ) { // Removing the tab's image here causes flickering, wait until the // load is complete. this.mBrowser.mIconURL = null; } if (!isReload && aWebProgress.isLoadingDocument) { let triggerer = gBrowser._getTriggeringPrincipalFromHistory( this.mBrowser ); // Typing a url, searching or clicking a bookmark will load a new // document that is no longer tied to a navigation from the previous // content and will have a system principal as the triggerer. if (triggerer && triggerer.isSystemPrincipal) { // Reset the related tab map so that the next tab opened will be related // to this new document and not to tabs opened by the previous one. gBrowser.clearRelatedTabs(); } } if ( aRequest instanceof Ci.nsIChannel && !isBlankPageURL(aRequest.originalURI.spec) ) { this.mBrowser.originalURI = aRequest.originalURI; } } let userContextId = this.mBrowser.getAttribute("usercontextid") || 0; if (this.mBrowser.registeredOpenURI) { let uri = this.mBrowser.registeredOpenURI; gBrowser.UrlbarProviderOpenTabs.unregisterOpenTab( uri.spec, userContextId, PrivateBrowsingUtils.isWindowPrivate(window) ); delete this.mBrowser.registeredOpenURI; } if (!isBlankPageURL(aLocation.spec)) { gBrowser.UrlbarProviderOpenTabs.registerOpenTab( aLocation.spec, userContextId, PrivateBrowsingUtils.isWindowPrivate(window) ); this.mBrowser.registeredOpenURI = aLocation; } if (this.mTab != gBrowser.selectedTab) { let tabCacheIndex = gBrowser._tabLayerCache.indexOf(this.mTab); if (tabCacheIndex != -1) { gBrowser._tabLayerCache.splice(tabCacheIndex, 1); gBrowser._getSwitcher().cleanUpTabAfterEviction(this.mTab); } } else { if ( gBrowser.featureCallout && (gBrowser.featureCalloutPanelId !== gBrowser.selectedTab.linkedPanel || gBrowser.contentPrincipal.originNoSuffix !== "resource://pdf.js") ) { gBrowser.featureCallout.endTour(true); gBrowser.featureCallout = null; } // For now, only check for Feature Callout messages // when viewing PDFs. Later, we can expand this to check // for callout messages on every change of tab location. if ( !gBrowser.featureCallout && gBrowser.contentPrincipal.originNoSuffix === "resource://pdf.js" ) { gBrowser.instantiateFeatureCalloutTour( gBrowser.selectedBrowser, gBrowser.selectedTab.linkedPanel ); gBrowser.featureCallout.showFeatureCallout(); } } } if (!this.mBlank || this.mBrowser.hasContentOpener) { this._callProgressListeners("onLocationChange", [ aWebProgress, aRequest, aLocation, aFlags, ]); if (topLevel && !isSameDocument) { // Include the true final argument to indicate that this event is // simulated (instead of being observed by the webProgressListener). this._callProgressListeners("onContentBlockingEvent", [ aWebProgress, null, 0, true, ]); } } if (topLevel) { this.mBrowser.lastURI = aLocation; this.mBrowser.lastLocationChange = Date.now(); } } onStatusChange(aWebProgress, aRequest, aStatus, aMessage) { if (this.mBlank) { return; } this._callProgressListeners("onStatusChange", [ aWebProgress, aRequest, aStatus, aMessage, ]); this.mMessage = aMessage; } onSecurityChange(aWebProgress, aRequest, aState) { this._callProgressListeners("onSecurityChange", [ aWebProgress, aRequest, aState, ]); } onContentBlockingEvent(aWebProgress, aRequest, aEvent) { this._callProgressListeners("onContentBlockingEvent", [ aWebProgress, aRequest, aEvent, ]); } onRefreshAttempted(aWebProgress, aURI, aDelay, aSameURI) { return this._callProgressListeners("onRefreshAttempted", [ aWebProgress, aURI, aDelay, aSameURI, ]); } } TabProgressListener.prototype.QueryInterface = ChromeUtils.generateQI([ "nsIWebProgressListener", "nsIWebProgressListener2", "nsISupportsWeakReference", ]); let URILoadingWrapper = { _normalizeLoadURIOptions(browser, loadURIOptions) { if (!loadURIOptions.triggeringPrincipal) { throw new Error("Must load with a triggering Principal"); } if ( loadURIOptions.userContextId && loadURIOptions.userContextId != browser.getAttribute("usercontextid") ) { throw new Error("Cannot load with mismatched userContextId"); } loadURIOptions.loadFlags |= loadURIOptions.flags | LOAD_FLAGS_NONE; delete loadURIOptions.flags; loadURIOptions.hasValidUserGestureActivation ??= document.hasValidTransientUserGestureActivation; }, _loadFlagsToFixupFlags(browser, loadFlags) { // Attempt to perform URI fixup to see if we can handle this URI in chrome. let fixupFlags = Ci.nsIURIFixup.FIXUP_FLAG_NONE; if (loadFlags & LOAD_FLAGS_ALLOW_THIRD_PARTY_FIXUP) { fixupFlags |= Ci.nsIURIFixup.FIXUP_FLAG_ALLOW_KEYWORD_LOOKUP; } if (loadFlags & LOAD_FLAGS_FIXUP_SCHEME_TYPOS) { fixupFlags |= Ci.nsIURIFixup.FIXUP_FLAG_FIX_SCHEME_TYPOS; } if (PrivateBrowsingUtils.isBrowserPrivate(browser)) { fixupFlags |= Ci.nsIURIFixup.FIXUP_FLAG_PRIVATE_CONTEXT; } return fixupFlags; }, _fixupURIString(browser, uriString, loadURIOptions) { let fixupFlags = this._loadFlagsToFixupFlags( browser, loadURIOptions.loadFlags ); // XXXgijs: If we switch to loading the URI we return from this method, // rather than redoing fixup in docshell (see bug 1815509), we need to // ensure that the loadURIOptions have the fixup flag removed here for // loads where `uriString` already parses if just passed immediately // to `newURI`. // Right now this happens in nsDocShellLoadState code. try { let fixupInfo = Services.uriFixup.getFixupURIInfo( uriString, fixupFlags ); return fixupInfo.preferredURI; } catch (e) { // getFixupURIInfo may throw. Just return null, our caller will deal. } return null; }, /** * Handles URIs when we want to deal with them in chrome code rather than pass * them down to a content browser. This can avoid unnecessary process switching * for the browser. * @param aBrowser the browser that is attempting to load the URI * @param aUri the nsIURI that is being loaded * @returns true if the URI is handled, otherwise false */ _handleUriInChrome(aBrowser, aUri) { if (aUri.scheme == "file") { try { let mimeType = Cc["@mozilla.org/mime;1"] .getService(Ci.nsIMIMEService) .getTypeFromURI(aUri); if (mimeType == "application/x-xpinstall") { let systemPrincipal = Services.scriptSecurityManager.getSystemPrincipal(); AddonManager.getInstallForURL(aUri.spec, { telemetryInfo: { source: "file-url" }, }).then(install => { AddonManager.installAddonFromWebpage( mimeType, aBrowser, systemPrincipal, install ); }); return true; } } catch (e) { return false; } } return false; }, _updateTriggerMetadataForLoad( browser, uriString, { loadFlags, globalHistoryOptions } ) { if (globalHistoryOptions?.triggeringSponsoredURL) { try { // Browser may access URL after fixing it up, then store the URL into DB. // To match with it, fix the link up explicitly. const triggeringSponsoredURL = Services.uriFixup.getFixupURIInfo( globalHistoryOptions.triggeringSponsoredURL, this._loadFlagsToFixupFlags(browser, loadFlags) ).fixedURI.spec; browser.setAttribute( "triggeringSponsoredURL", triggeringSponsoredURL ); const time = globalHistoryOptions.triggeringSponsoredURLVisitTimeMS || Date.now(); browser.setAttribute("triggeringSponsoredURLVisitTimeMS", time); } catch (e) {} } if (globalHistoryOptions?.triggeringSearchEngine) { browser.setAttribute( "triggeringSearchEngine", globalHistoryOptions.triggeringSearchEngine ); browser.setAttribute("triggeringSearchEngineURL", uriString); } else { browser.removeAttribute("triggeringSearchEngine"); browser.removeAttribute("triggeringSearchEngineURL"); } }, // Both of these are used to override functions on browser-custom-element. fixupAndLoadURIString(browser, uriString, loadURIOptions = {}) { this._internalMaybeFixupLoadURI(browser, uriString, null, loadURIOptions); }, loadURI(browser, uri, loadURIOptions = {}) { this._internalMaybeFixupLoadURI(browser, "", uri, loadURIOptions); }, // A shared function used by both remote and non-remote browsers to // load a string URI or redirect it to the correct process. _internalMaybeFixupLoadURI(browser, uriString, uri, loadURIOptions) { this._normalizeLoadURIOptions(browser, loadURIOptions); // Some callers pass undefined/null when calling // loadURI/fixupAndLoadURIString. Just load about:blank instead: if (!uriString && !uri) { uri = Services.io.newURI("about:blank"); } // We need a URI in frontend code for checking various things. Ideally // we would then also pass that URI to webnav/browsingcontext code // for loading, but we historically haven't. Changing this would alter // fixup scenarios in some non-obvious cases. let startedWithURI = !!uri; if (!uri) { // Note: this may return null if we can't make a URI out of the input. uri = this._fixupURIString(browser, uriString, loadURIOptions); } if (uri && this._handleUriInChrome(browser, uri)) { // If we've handled the URI in chrome, then just return here. return; } this._updateTriggerMetadataForLoad( browser, uriString || uri.spec, loadURIOptions ); // XXX(nika): Is `browser.isNavigating` necessary anymore? // XXX(gijs): Unsure. But it mirrors docShell.isNavigating, but in the parent process // (and therefore imperfectly so). browser.isNavigating = true; try { // Should more generally prefer loadURI here - see bug 1815509. if (startedWithURI) { browser.webNavigation.loadURI(uri, loadURIOptions); } else { browser.webNavigation.fixupAndLoadURIString( uriString, loadURIOptions ); } } finally { browser.isNavigating = false; } }, }; } // end private scope for gBrowser var StatusPanel = { // This is useful for debugging (set to `true` in the interesting state for // the panel to remain in that state). _frozen: false, get panel() { delete this.panel; this.panel = document.getElementById("statuspanel"); this.panel.addEventListener( "transitionend", this._onTransitionEnd.bind(this) ); this.panel.addEventListener( "transitioncancel", this._onTransitionEnd.bind(this) ); return this.panel; }, get isVisible() { return !this.panel.hasAttribute("inactive"); }, update() { if (BrowserHandler.kiosk || this._frozen) { return; } let text; let type; let types = ["overLink"]; if (XULBrowserWindow.busyUI) { types.push("status"); } types.push("defaultStatus"); for (type of types) { if ((text = XULBrowserWindow[type])) { break; } } // If it's a long data: URI that uses base64 encoding, truncate to // a reasonable length rather than trying to display the entire thing. // We can't shorten arbitrary URIs like this, as bidi etc might mean // we need the trailing characters for display. But a base64-encoded // data-URI is plain ASCII, so this is OK for status panel display. // (See bug 1484071.) let textCropped = false; if (text.length > 500 && text.match(/^data:[^,]+;base64,/)) { text = text.substring(0, 500) + "\u2026"; textCropped = true; } if (this._labelElement.value != text || (text && !this.isVisible)) { this.panel.setAttribute("previoustype", this.panel.getAttribute("type")); this.panel.setAttribute("type", type); this._label = text; this._labelElement.setAttribute( "crop", type == "overLink" && !textCropped ? "center" : "end" ); } }, get _labelElement() { delete this._labelElement; return (this._labelElement = document.getElementById("statuspanel-label")); }, set _label(val) { if (!this.isVisible) { this.panel.removeAttribute("mirror"); this.panel.removeAttribute("sizelimit"); } if ( this.panel.getAttribute("type") == "status" && this.panel.getAttribute("previoustype") == "status" ) { // Before updating the label, set the panel's current width as its // min-width to let the panel grow but not shrink and prevent // unnecessary flicker while loading pages. We only care about the // panel's width once it has been painted, so we can do this // without flushing layout. this.panel.style.minWidth = window.windowUtils.getBoundsWithoutFlushing(this.panel).width + "px"; } else { this.panel.style.minWidth = ""; } if (val) { this._labelElement.value = val; if (this.panel.hidden) { this.panel.hidden = false; // This ensures that the "inactive" attribute removal triggers a // transition. getComputedStyle(this.panel).display; } this.panel.removeAttribute("inactive"); MousePosTracker.addListener(this); } else { this.panel.setAttribute("inactive", "true"); MousePosTracker.removeListener(this); } }, _onTransitionEnd() { if (!this.isVisible) { this.panel.hidden = true; } }, getMouseTargetRect() { let container = this.panel.parentNode; let panelRect = window.windowUtils.getBoundsWithoutFlushing(this.panel); let containerRect = window.windowUtils.getBoundsWithoutFlushing(container); return { top: panelRect.top, bottom: panelRect.bottom, left: RTL_UI ? containerRect.right - panelRect.width : containerRect.left, right: RTL_UI ? containerRect.right : containerRect.left + panelRect.width, }; }, onMouseEnter() { this._mirror(); }, onMouseLeave() { this._mirror(); }, _mirror() { if (this._frozen) { return; } if (this.panel.hasAttribute("mirror")) { this.panel.removeAttribute("mirror"); } else { this.panel.setAttribute("mirror", "true"); } if (!this.panel.hasAttribute("sizelimit")) { this.panel.setAttribute("sizelimit", "true"); } }, }; var TabBarVisibility = { _initialUpdateDone: false, update() { let toolbar = document.getElementById("TabsToolbar"); let collapse = false; if ( !gBrowser /* gBrowser isn't initialized yet */ || gBrowser.visibleTabs.length == 1 ) { collapse = !window.toolbar.visible; } if (collapse == toolbar.collapsed && this._initialUpdateDone) { return; } this._initialUpdateDone = true; toolbar.collapsed = collapse; let navbar = document.getElementById("nav-bar"); navbar.setAttribute("tabs-hidden", collapse); document.getElementById("menu_closeWindow").hidden = collapse; document.l10n.setAttributes( document.getElementById("menu_close"), collapse ? "tabbrowser-menuitem-close" : "tabbrowser-menuitem-close-tab" ); TabsInTitlebar.allowedBy("tabs-visible", !collapse); }, }; var TabContextMenu = { contextTab: null, _updateToggleMuteMenuItems(aTab, aConditionFn) { ["muted", "soundplaying"].forEach(attr => { if (!aConditionFn || aConditionFn(attr)) { if (aTab.hasAttribute(attr)) { aTab.toggleMuteMenuItem.setAttribute(attr, "true"); aTab.toggleMultiSelectMuteMenuItem.setAttribute(attr, "true"); } else { aTab.toggleMuteMenuItem.removeAttribute(attr); aTab.toggleMultiSelectMuteMenuItem.removeAttribute(attr); } } }); }, updateContextMenu(aPopupMenu) { let tab = aPopupMenu.triggerNode && (aPopupMenu.triggerNode.tab || aPopupMenu.triggerNode.closest("tab")); this.contextTab = tab || gBrowser.selectedTab; this.contextTab.addEventListener("TabAttrModified", this); aPopupMenu.addEventListener("popuphiding", this); let disabled = gBrowser.tabs.length == 1; let multiselectionContext = this.contextTab.multiselected; let tabCountInfo = JSON.stringify({ tabCount: (multiselectionContext && gBrowser.multiSelectedTabsCount) || 1, }); var menuItems = aPopupMenu.getElementsByAttribute( "tbattr", "tabbrowser-multiple" ); for (let menuItem of menuItems) { menuItem.disabled = disabled; } disabled = gBrowser.visibleTabs.length == 1; menuItems = aPopupMenu.getElementsByAttribute( "tbattr", "tabbrowser-multiple-visible" ); for (let menuItem of menuItems) { menuItem.disabled = disabled; } // Session store document.getElementById("context_undoCloseTab").disabled = SessionStore.getClosedTabCountForWindow(window) == 0; // Show/hide fullscreen context menu items and set the // autohide item's checked state to mirror the autohide pref. showFullScreenViewContextMenuItems(aPopupMenu); // Only one of Reload_Tab/Reload_Selected_Tabs should be visible. document.getElementById("context_reloadTab").hidden = multiselectionContext; document.getElementById("context_reloadSelectedTabs").hidden = !multiselectionContext; // Show Play Tab menu item if the tab has attribute activemedia-blocked document.getElementById("context_playTab").hidden = !( this.contextTab.activeMediaBlocked && !multiselectionContext ); document.getElementById("context_playSelectedTabs").hidden = !( this.contextTab.activeMediaBlocked && multiselectionContext ); // Only one of pin/unpin/multiselect-pin/multiselect-unpin should be visible let contextPinTab = document.getElementById("context_pinTab"); contextPinTab.hidden = this.contextTab.pinned || multiselectionContext; let contextUnpinTab = document.getElementById("context_unpinTab"); contextUnpinTab.hidden = !this.contextTab.pinned || multiselectionContext; let contextPinSelectedTabs = document.getElementById( "context_pinSelectedTabs" ); contextPinSelectedTabs.hidden = this.contextTab.pinned || !multiselectionContext; let contextUnpinSelectedTabs = document.getElementById( "context_unpinSelectedTabs" ); contextUnpinSelectedTabs.hidden = !this.contextTab.pinned || !multiselectionContext; // Move Tab items let contextMoveTabOptions = document.getElementById( "context_moveTabOptions" ); contextMoveTabOptions.setAttribute("data-l10n-args", tabCountInfo); contextMoveTabOptions.disabled = this.contextTab.hidden || gBrowser.allTabsSelected(); let selectedTabs = gBrowser.selectedTabs; let contextMoveTabToEnd = document.getElementById("context_moveToEnd"); let allSelectedTabsAdjacent = selectedTabs.every( (element, index, array) => { return array.length > index + 1 ? element._tPos + 1 == array[index + 1]._tPos : true; } ); let contextTabIsSelected = this.contextTab.multiselected; let visibleTabs = gBrowser.visibleTabs; let lastVisibleTab = visibleTabs[visibleTabs.length - 1]; let tabsToMove = contextTabIsSelected ? selectedTabs : [this.contextTab]; let lastTabToMove = tabsToMove[tabsToMove.length - 1]; let isLastPinnedTab = false; if (lastTabToMove.pinned) { let sibling = gBrowser.tabContainer.findNextTab(lastTabToMove); isLastPinnedTab = !sibling || !sibling.pinned; } contextMoveTabToEnd.disabled = (lastTabToMove == lastVisibleTab || isLastPinnedTab) && allSelectedTabsAdjacent; let contextMoveTabToStart = document.getElementById("context_moveToStart"); let isFirstTab = tabsToMove[0] == visibleTabs[0] || tabsToMove[0] == visibleTabs[gBrowser._numPinnedTabs]; contextMoveTabToStart.disabled = isFirstTab && allSelectedTabsAdjacent; if (this.contextTab.hasAttribute("customizemode")) { document.getElementById("context_openTabInWindow").disabled = true; } // Only one of "Duplicate Tab"/"Duplicate Tabs" should be visible. document.getElementById("context_duplicateTab").hidden = multiselectionContext; document.getElementById("context_duplicateTabs").hidden = !multiselectionContext; // Disable "Close Tabs to the Left/Right" if there are no tabs // preceding/following it. let closeTabsToTheStartItem = document.getElementById( "context_closeTabsToTheStart" ); let noTabsToStart = !gBrowser.getTabsToTheStartFrom(this.contextTab).length; closeTabsToTheStartItem.disabled = noTabsToStart; let closeTabsToTheEndItem = document.getElementById( "context_closeTabsToTheEnd" ); let noTabsToEnd = !gBrowser.getTabsToTheEndFrom(this.contextTab).length; closeTabsToTheEndItem.disabled = noTabsToEnd; // Disable "Close other Tabs" if there are no unpinned tabs. let unpinnedTabsToClose = multiselectionContext ? gBrowser.visibleTabs.filter(t => !t.multiselected && !t.pinned).length : gBrowser.visibleTabs.filter(t => t != this.contextTab && !t.pinned) .length; let closeOtherTabsItem = document.getElementById("context_closeOtherTabs"); closeOtherTabsItem.disabled = unpinnedTabsToClose < 1; // Update the close item with how many tabs will close. document .getElementById("context_closeTab") .setAttribute("data-l10n-args", tabCountInfo); // Disable "Close Multiple Tabs" if all sub menuitems are disabled document.getElementById("context_closeTabOptions").disabled = closeTabsToTheStartItem.disabled && closeTabsToTheEndItem.disabled && closeOtherTabsItem.disabled; // Hide "Bookmark Tab…" for multiselection. // Update its state if visible. let bookmarkTab = document.getElementById("context_bookmarkTab"); bookmarkTab.hidden = multiselectionContext; // Show "Bookmark Selected Tabs" in a multiselect context and hide it otherwise. let bookmarkMultiSelectedTabs = document.getElementById( "context_bookmarkSelectedTabs" ); bookmarkMultiSelectedTabs.hidden = !multiselectionContext; let toggleMute = document.getElementById("context_toggleMuteTab"); let toggleMultiSelectMute = document.getElementById( "context_toggleMuteSelectedTabs" ); // Only one of mute_unmute_tab/mute_unmute_selected_tabs should be visible toggleMute.hidden = multiselectionContext; toggleMultiSelectMute.hidden = !multiselectionContext; const isMuted = this.contextTab.hasAttribute("muted"); document.l10n.setAttributes( toggleMute, isMuted ? "tabbrowser-context-unmute-tab" : "tabbrowser-context-mute-tab" ); document.l10n.setAttributes( toggleMultiSelectMute, isMuted ? "tabbrowser-context-unmute-selected-tabs" : "tabbrowser-context-mute-selected-tabs" ); this.contextTab.toggleMuteMenuItem = toggleMute; this.contextTab.toggleMultiSelectMuteMenuItem = toggleMultiSelectMute; this._updateToggleMuteMenuItems(this.contextTab); let selectAllTabs = document.getElementById("context_selectAllTabs"); selectAllTabs.disabled = gBrowser.allTabsSelected(); gSync.updateTabContextMenu(aPopupMenu, this.contextTab); let reopenInContainer = document.getElementById( "context_reopenInContainer" ); reopenInContainer.hidden = !Services.prefs.getBoolPref("privacy.userContext.enabled", false) || PrivateBrowsingUtils.isWindowPrivate(window); reopenInContainer.disabled = this.contextTab.hidden; gShareUtils.updateShareURLMenuItem( this.contextTab.linkedBrowser, document.getElementById("context_sendTabToDevice") ); }, handleEvent(aEvent) { switch (aEvent.type) { case "popuphiding": if (aEvent.target.id == "tabContextMenu") { this.contextTab.removeEventListener("TabAttrModified", this); } break; case "TabAttrModified": let tab = aEvent.target; this._updateToggleMuteMenuItems(tab, attr => aEvent.detail.changed.includes(attr) ); break; } }, createReopenInContainerMenu(event) { createUserContextMenu(event, { isContextMenu: true, excludeUserContextId: this.contextTab.getAttribute("usercontextid"), }); }, duplicateSelectedTabs() { let tabsToDuplicate = gBrowser.selectedTabs; let newIndex = tabsToDuplicate[tabsToDuplicate.length - 1]._tPos + 1; for (let tab of tabsToDuplicate) { let newTab = SessionStore.duplicateTab(window, tab); gBrowser.moveTabTo(newTab, newIndex++); } }, reopenInContainer(event) { let userContextId = parseInt( event.target.getAttribute("data-usercontextid") ); let reopenedTabs = this.contextTab.multiselected ? gBrowser.selectedTabs : [this.contextTab]; for (let tab of reopenedTabs) { if (tab.getAttribute("usercontextid") == userContextId) { continue; } /* Create a triggering principal that is able to load the new tab For content principals that are about: chrome: or resource: we need system to load them. Anything other than system principal needs to have the new userContextId. */ let triggeringPrincipal; if (tab.linkedPanel) { triggeringPrincipal = tab.linkedBrowser.contentPrincipal; } else { // For lazy tab browsers, get the original principal // from SessionStore let tabState = JSON.parse(SessionStore.getTabState(tab)); try { triggeringPrincipal = E10SUtils.deserializePrincipal( tabState.triggeringPrincipal_base64 ); } catch (ex) { continue; } } if (!triggeringPrincipal || triggeringPrincipal.isNullPrincipal) { // Ensure that we have a null principal if we couldn't // deserialize it (for lazy tab browsers) ... // This won't always work however is safe to use. triggeringPrincipal = Services.scriptSecurityManager.createNullPrincipal({ userContextId }); } else if (triggeringPrincipal.isContentPrincipal) { triggeringPrincipal = Services.scriptSecurityManager.principalWithOA( triggeringPrincipal, { userContextId, } ); } let newTab = gBrowser.addTab(tab.linkedBrowser.currentURI.spec, { userContextId, pinned: tab.pinned, index: tab._tPos + 1, triggeringPrincipal, }); if (gBrowser.selectedTab == tab) { gBrowser.selectedTab = newTab; } if (tab.muted && !newTab.muted) { newTab.toggleMuteAudio(tab.muteReason); } } }, closeContextTabs(event) { if (this.contextTab.multiselected) { gBrowser.removeMultiSelectedTabs(); } else { gBrowser.removeTab(this.contextTab, { animate: true }); } }, };