The Tor Browser: comparison browser/base/content/tabbrowser.xml

--1:000000000000
+:f373d9a59eff
+<?xml version="1.0"?>
+<!-- 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/. -->
+<!DOCTYPE bindings [
+<!ENTITY % tabBrowserDTD SYSTEM "chrome://browser/locale/tabbrowser.dtd" >
+%tabBrowserDTD;
+]>
+# MAKE_E10S_WORK surrounds code needed to have the front-end try to be smart
+# about using non-remote browsers for loading certain URIs when remote tabs
+# (browser.tabs.remote) are enabled.
+#define MAKE_E10S_WORK 1
+<bindings id="tabBrowserBindings"
+xmlns="http://www.mozilla.org/xbl"
+xmlns:xul="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"
+xmlns:xbl="http://www.mozilla.org/xbl">
+<binding id="tabbrowser">
+<resources>
+<stylesheet src="chrome://browser/content/tabbrowser.css"/>
+</resources>
+<content>
+<xul:stringbundle anonid="tbstringbundle" src="chrome://browser/locale/tabbrowser.properties"/>
+<xul:tabbox anonid="tabbox" class="tabbrowser-tabbox"
+flex="1" eventnode="document" xbl:inherits="handleCtrlPageUpDown"
+onselect="if (event.target.localName == 'tabpanels') this.parentNode.updateCurrentBrowser();">
+<xul:tabpanels flex="1" class="plain" selectedIndex="0" anonid="panelcontainer">
+<xul:notificationbox flex="1">
+<xul:hbox flex="1" class="browserSidebarContainer">
+<xul:vbox flex="1" class="browserContainer">
+<xul:stack flex="1" class="browserStack" anonid="browserStack">
+<xul:browser anonid="initialBrowser" type="content-primary" message="true"
+xbl:inherits="tooltip=contenttooltip,contextmenu=contentcontextmenu,autocompletepopup,selectpopup"/>
+</xul:stack>
+</xul:vbox>
+</xul:hbox>
+</xul:notificationbox>
+</xul:tabpanels>
+</xul:tabbox>
+<children/>
+</content>
+<implementation implements="nsIDOMEventListener, nsIMessageListener">
+<property name="tabContextMenu" readonly="true"
+onget="return this.tabContainer.contextMenu;"/>
+<field name="tabContainer" readonly="true">
+document.getElementById(this.getAttribute("tabcontainer"));
+</field>
+<field name="tabs" readonly="true">
+this.tabContainer.childNodes;
+</field>
+<property name="visibleTabs" readonly="true">
+<getter><![CDATA[
+if (!this._visibleTabs)
+this._visibleTabs = Array.filter(this.tabs,
+function (tab) !tab.hidden && !tab.closing);
+return this._visibleTabs;
+]]></getter>
+</property>
+<field name="closingTabsEnum" readonly="true">({ ALL: 0, OTHER: 1, TO_END: 2 });</field>
+<field name="_visibleTabs">null</field>
+<field name="mURIFixup" readonly="true">
+Components.classes["@mozilla.org/docshell/urifixup;1"]
+.getService(Components.interfaces.nsIURIFixup);
+</field>
+<field name="mFaviconService" readonly="true">
+Components.classes["@mozilla.org/browser/favicon-service;1"]
+.getService(Components.interfaces.nsIFaviconService);
+</field>
+<field name="_placesAutocomplete" readonly="true">
+Components.classes["@mozilla.org/autocomplete/search;1?name=history"]
+.getService(Components.interfaces.mozIPlacesAutoComplete);
+</field>
+<field name="_unifiedComplete" readonly="true">
+Components.classes["@mozilla.org/autocomplete/search;1?name=unifiedcomplete"]
+.getService(Components.interfaces.mozIPlacesAutoComplete);
+</field>
+<field name="mTabBox" readonly="true">
+document.getAnonymousElementByAttribute(this, "anonid", "tabbox");
+</field>
+<field name="mPanelContainer" readonly="true">
+document.getAnonymousElementByAttribute(this, "anonid", "panelcontainer");
+</field>
+<field name="mStringBundle">
+document.getAnonymousElementByAttribute(this, "anonid", "tbstringbundle");
+</field>
+<field name="mCurrentTab">
+null
+</field>
+<field name="_lastRelatedTab">
+null
+</field>
+<field name="mCurrentBrowser">
+null
+</field>
+<field name="mProgressListeners">
+[]
+</field>
+<field name="mTabsProgressListeners">
+[]
+</field>
+<field name="mTabListeners">
+[]
+</field>
+<field name="mTabFilters">
+[]
+</field>
+<field name="mIsBusy">
+false
+</field>
+<field name="arrowKeysShouldWrap" readonly="true">
+#ifdef XP_MACOSX
+true
+#else
+false
+#endif
+</field>
+<field name="_autoScrollPopup">
+null
+</field>
+<field name="_previewMode">
+false
+</field>
+<field name="_lastFindValue">
+""
+</field>
+<property name="_numPinnedTabs" readonly="true">
+<getter><![CDATA[
+for (var i = 0; i < this.tabs.length; i++) {
+if (!this.tabs[i].pinned)
+break;
+}
+return i;
+]]></getter>
+</property>
+<method name="isFindBarInitialized">
+<parameter name="aTab"/>
+<body><![CDATA[
+return (aTab || this.selectedTab)._findBar != undefined;
+]]></body>
+</method>
+<method name="getFindBar">
+<parameter name="aTab"/>
+<body><![CDATA[
+if (!aTab)
+aTab = this.selectedTab;
+if (aTab._findBar)
+return aTab._findBar;
+let findBar = document.createElementNS(this.namespaceURI, "findbar");
+let browser = this.getBrowserForTab(aTab);
+let browserContainer = this.getBrowserContainer(browser);
+browserContainer.appendChild(findBar);
+// Force a style flush to ensure that our binding is attached.
+findBar.clientTop;
+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;
+]]></body>
+</method>
+<method name="getStatusPanel">
+<body><![CDATA[
+if (!this._statusPanel) {
+this._statusPanel = document.createElementNS(this.namespaceURI, "statuspanel");
+this._statusPanel.setAttribute("inactive", "true");
+this._statusPanel.setAttribute("layer", "true");
+this._appendStatusPanel();
+}
+return this._statusPanel;
+]]></body>
+</method>
+<method name="_appendStatusPanel">
+<body><![CDATA[
+if (this._statusPanel) {
+let browser = this.selectedBrowser;
+let browserContainer = this.getBrowserContainer(browser);
+browserContainer.insertBefore(this._statusPanel, browser.parentNode.nextSibling);
+}
+]]></body>
+</method>
+<method name="updateWindowResizers">
+<body><![CDATA[
+if (!window.gShowPageResizers)
+return;
+var show = window.windowState == window.STATE_NORMAL;
+for (let i = 0; i < this.browsers.length; i++) {
+this.browsers[i].showWindowResizer = show;
+}
+]]></body>
+</method>
+<method name="_setCloseKeyState">
+<parameter name="aEnabled"/>
+<body><![CDATA[
+let keyClose = document.getElementById("key_close");
+let closeKeyEnabled = keyClose.getAttribute("disabled") != "true";
+if (closeKeyEnabled == aEnabled)
+return;
+if (aEnabled)
+keyClose.removeAttribute("disabled");
+else
+keyClose.setAttribute("disabled", "true");
+// We also want to remove the keyboard shortcut from the file menu
+// when the shortcut is disabled, and bring it back when it's
+// renabled.
+//
+// Fixing bug 630826 could make that happen automatically.
+// Fixing bug 630830 could avoid the ugly hack below.
+let closeMenuItem = document.getElementById("menu_close");
+let parentPopup = closeMenuItem.parentNode;
+let nextItem = closeMenuItem.nextSibling;
+let clonedItem = closeMenuItem.cloneNode(true);
+parentPopup.removeChild(closeMenuItem);
+if (aEnabled)
+clonedItem.setAttribute("key", "key_close");
+else
+clonedItem.removeAttribute("key");
+parentPopup.insertBefore(clonedItem, nextItem);
+]]></body>
+</method>
+<method name="pinTab">
+<parameter name="aTab"/>
+<body><![CDATA[
+if (aTab.pinned)
+return;
+if (aTab.hidden)
+this.showTab(aTab);
+this.moveTabTo(aTab, this._numPinnedTabs);
+aTab.setAttribute("pinned", "true");
+this.tabContainer._unlockTabSizing();
+this.tabContainer._positionPinnedTabs();
+this.tabContainer.adjustTabstrip();
+// Bug 961867 - [e10s] Implement the logic for app tabs
+if (!gMultiProcessBrowser)
+this.getBrowserForTab(aTab).docShell.isAppTab = true;
+if (aTab.selected)
+this._setCloseKeyState(false);
+let event = document.createEvent("Events");
+event.initEvent("TabPinned", true, false);
+aTab.dispatchEvent(event);
+]]></body>
+</method>
+<method name="unpinTab">
+<parameter name="aTab"/>
+<body><![CDATA[
+if (!aTab.pinned)
+return;
+this.moveTabTo(aTab, this._numPinnedTabs - 1);
+aTab.removeAttribute("pinned");
+aTab.style.MozMarginStart = "";
+this.tabContainer._unlockTabSizing();
+this.tabContainer._positionPinnedTabs();
+this.tabContainer.adjustTabstrip();
+// Bug 961867 - [e10s] Implement the logic for app tabs
+if (!gMultiProcessBrowser)
+this.getBrowserForTab(aTab).docShell.isAppTab = false;
+if (aTab.selected)
+this._setCloseKeyState(true);
+let event = document.createEvent("Events");
+event.initEvent("TabUnpinned", true, false);
+aTab.dispatchEvent(event);
+]]></body>
+</method>
+<method name="previewTab">
+<parameter name="aTab"/>
+<parameter name="aCallback"/>
+<body>
+<![CDATA[
+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;
+}
+]]>
+</body>
+</method>
+<method name="getBrowserAtIndex">
+<parameter name="aIndex"/>
+<body>
+<![CDATA[
+return this.browsers[aIndex];
+]]>
+</body>
+</method>
+<method name="getBrowserIndexForDocument">
+<parameter name="aDocument"/>
+<body>
+<![CDATA[
+var tab = this._getTabForContentWindow(aDocument.defaultView);
+return tab ? tab._tPos : -1;
+]]>
+</body>
+</method>
+<method name="getBrowserForDocument">
+<parameter name="aDocument"/>
+<body>
+<![CDATA[
+var tab = this._getTabForContentWindow(aDocument.defaultView);
+return tab ? tab.linkedBrowser : null;
+]]>
+</body>
+</method>
+<method name="_getTabForContentWindow">
+<parameter name="aWindow"/>
+<body>
+<![CDATA[
+for (let i = 0; i < this.browsers.length; i++) {
+if (this.browsers[i].contentWindow == aWindow)
+return this.tabs[i];
+}
+return null;
+]]>
+</body>
+</method>
+<method name="_getTabForBrowser">
+<parameter name="aBrowser"/>
+<body>
+<![CDATA[
+for (let i = 0; i < this.tabs.length; i++) {
+if (this.tabs[i].linkedBrowser == aBrowser)
+return this.tabs[i];
+}
+return null;
+]]>
+</body>
+</method>
+<method name="getNotificationBox">
+<parameter name="aBrowser"/>
+<body>
+<![CDATA[
+return this.getSidebarContainer(aBrowser).parentNode;
+]]>
+</body>
+</method>
+<method name="getSidebarContainer">
+<parameter name="aBrowser"/>
+<body>
+<![CDATA[
+return this.getBrowserContainer(aBrowser).parentNode;
+]]>
+</body>
+</method>
+<method name="getBrowserContainer">
+<parameter name="aBrowser"/>
+<body>
+<![CDATA[
+return (aBrowser || this.mCurrentBrowser).parentNode.parentNode;
+]]>
+</body>
+</method>
+<method name="getTabModalPromptBox">
+<parameter name="aBrowser"/>
+<body>
+<![CDATA[
+const XUL_NS = "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul";
+let browser = (aBrowser || this.mCurrentBrowser);
+let stack = browser.parentNode;
+let self = this;
+let promptBox = {
+appendPrompt : function(args, onCloseCallback) {
+let newPrompt = document.createElementNS(XUL_NS, "tabmodalprompt");
+stack.appendChild(newPrompt);
+browser.setAttribute("tabmodalPromptShowing", true);
+newPrompt.clientTop; // style flush to assure binding is attached
+let tab = self._getTabForBrowser(browser);
+newPrompt.init(args, tab, onCloseCallback);
+return newPrompt;
+},
+removePrompt : function(aPrompt) {
+stack.removeChild(aPrompt);
+let prompts = this.listPrompts();
+if (prompts.length) {
+let prompt = prompts[prompts.length - 1];
+prompt.Dialog.setDefaultFocus();
+} else {
+browser.removeAttribute("tabmodalPromptShowing");
+browser.focus();
+}
+},
+listPrompts : function(aPrompt) {
+let els = stack.getElementsByTagNameNS(XUL_NS, "tabmodalprompt");
+// NodeList --> real JS array
+let prompts = Array.slice(els);
+return prompts;
+},
+};
+return promptBox;
+]]>
+</body>
+</method>
+<method name="_callProgressListeners">
+<parameter name="aBrowser"/>
+<parameter name="aMethod"/>
+<parameter name="aArguments"/>
+<parameter name="aCallGlobalListeners"/>
+<parameter name="aCallTabsListeners"/>
+<body><![CDATA[
+var rv = true;
+if (!aBrowser)
+aBrowser = this.mCurrentBrowser;
+if (aCallGlobalListeners != false &&
+aBrowser == this.mCurrentBrowser) {
+this.mProgressListeners.forEach(function (p) {
+if (aMethod in p) {
+try {
+if (!p[aMethod].apply(p, aArguments))
+rv = false;
+} catch (e) {
+// don't inhibit other listeners
+Components.utils.reportError(e);
+}
+}
+});
+}
+if (aCallTabsListeners != false) {
+aArguments.unshift(aBrowser);
+this.mTabsProgressListeners.forEach(function (p) {
+if (aMethod in p) {
+try {
+if (!p[aMethod].apply(p, aArguments))
+rv = false;
+} catch (e) {
+// don't inhibit other listeners
+Components.utils.reportError(e);
+}
+}
+});
+}
+return rv;
+]]></body>
+</method>
+<!-- A web progress listener object definition for a given tab. -->
+<method name="mTabProgressListener">
+<parameter name="aTab"/>
+<parameter name="aBrowser"/>
+<parameter name="aStartsBlank"/>
+<body>
+<![CDATA[
+return ({
+mTabBrowser: this,
+mTab: aTab,
+mBrowser: aBrowser,
+mBlank: aStartsBlank,
+// cache flags for correct status UI update after tab switching
+mStateFlags: 0,
+mStatus: 0,
+mMessage: "",
+mTotalProgress: 0,
+// count of open requests (should always be 0 or 1)
+mRequestCount: 0,
+destroy: function () {
+delete this.mTab;
+delete this.mBrowser;
+delete this.mTabBrowser;
+},
+_callProgressListeners: function () {
+Array.unshift(arguments, this.mBrowser);
+return this.mTabBrowser._callProgressListeners.apply(this.mTabBrowser, arguments);
+},
+_shouldShowProgress: function (aRequest) {
+if (this.mBlank)
+return false;
+if (gMultiProcessBrowser)
+return true;
+// Don't show progress indicators in tabs for about: URIs
+// pointing to local resources.
+try {
+let channel = aRequest.QueryInterface(Ci.nsIChannel);
+if (channel.originalURI.schemeIs("about") &&
+(channel.URI.schemeIs("jar") || channel.URI.schemeIs("file")))
+return false;
+} catch (e) {}
+return true;
+},
+onProgressChange: function (aWebProgress, aRequest,
+aCurSelfProgress, aMaxSelfProgress,
+aCurTotalProgress, aMaxTotalProgress) {
+this.mTotalProgress = aMaxTotalProgress ? aCurTotalProgress / aMaxTotalProgress : 0;
+if (!this._shouldShowProgress(aRequest))
+return;
+if (this.mTotalProgress)
+this.mTab.setAttribute("progress", "true");
+this._callProgressListeners("onProgressChange",
+[aWebProgress, aRequest,
+aCurSelfProgress, aMaxSelfProgress,
+aCurTotalProgress, aMaxTotalProgress]);
+},
+onProgressChange64: function (aWebProgress, aRequest,
+aCurSelfProgress, aMaxSelfProgress,
+aCurTotalProgress, aMaxTotalProgress) {
+return this.onProgressChange(aWebProgress, aRequest,
+aCurSelfProgress, aMaxSelfProgress, aCurTotalProgress,
+aMaxTotalProgress);
+},
+onStateChange: function (aWebProgress, aRequest, aStateFlags, aStatus) {
+if (!aRequest)
+return;
+var oldBlank = this.mBlank;
+const nsIWebProgressListener = Components.interfaces.nsIWebProgressListener;
+const nsIChannel = Components.interfaces.nsIChannel;
+if (aStateFlags & nsIWebProgressListener.STATE_START) {
+this.mRequestCount++;
+}
+else if (aStateFlags & nsIWebProgressListener.STATE_STOP) {
+const NS_ERROR_UNKNOWN_HOST = 2152398878;
+if (--this.mRequestCount > 0 && aStatus == NS_ERROR_UNKNOWN_HOST) {
+// to prevent bug 235825: wait for the request handled
+// by the automatic keyword resolver
+return;
+}
+// since we (try to) only handle STATE_STOP of the last request,
+// the count of open requests should now be 0
+this.mRequestCount = 0;
+}
+if (aStateFlags & nsIWebProgressListener.STATE_START &&
+aStateFlags & nsIWebProgressListener.STATE_IS_NETWORK) {
+// It's okay to clear what the user typed when we start
+// loading a document. If the user types, this counter gets
+// set to zero, if the document load ends without an
+// onLocationChange, this counter gets decremented
+// (so we keep it while switching tabs after failed loads)
+// We need to add 2 because loadURIWithFlags may have
+// cancelled a pending load which would have cleared
+// its anchor scroll detection temporary increment.
+if (aWebProgress.isTopLevel)
+this.mBrowser.userTypedClear += 2;
+if (this._shouldShowProgress(aRequest)) {
+if (!(aStateFlags & nsIWebProgressListener.STATE_RESTORING)) {
+this.mTab.setAttribute("busy", "true");
+if (!(aWebProgress.loadType & Ci.nsIDocShell.LOAD_CMD_RELOAD))
+this.mTabBrowser.setTabTitleLoading(this.mTab);
+}
+if (this.mTab.selected)
+this.mTabBrowser.mIsBusy = true;
+}
+}
+else if (aStateFlags & nsIWebProgressListener.STATE_STOP &&
+aStateFlags & nsIWebProgressListener.STATE_IS_NETWORK) {
+if (this.mTab.hasAttribute("busy")) {
+this.mTab.removeAttribute("busy");
+this.mTabBrowser._tabAttrModified(this.mTab);
+if (!this.mTab.selected)
+this.mTab.setAttribute("unread", "true");
+}
+this.mTab.removeAttribute("progress");
+if (aWebProgress.isTopLevel) {
+if (!Components.isSuccessCode(aStatus) &&
+!isTabEmpty(this.mTab)) {
+// 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;
+if (this.mTab.selected && gURLBar)
+URLBarSetURI();
+} else {
+// The document is done loading, we no longer want the
+// value cleared.
+if (this.mBrowser.userTypedClear > 1)
+this.mBrowser.userTypedClear -= 2;
+else if (this.mBrowser.userTypedClear > 0)
+this.mBrowser.userTypedClear--;
+}
+if (!this.mBrowser.mIconURL)
+this.mTabBrowser.useDefaultIcon(this.mTab);
+}
+if (this.mBlank)
+this.mBlank = false;
+var location = aRequest.QueryInterface(nsIChannel).URI;
+// 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.label == this.mTabBrowser.mStringBundle.getString("tabs.connecting"))
+this.mTabBrowser.setTabTitle(this.mTab);
+if (this.mTab.selected)
+this.mTabBrowser.mIsBusy = false;
+}
+if (oldBlank) {
+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 & (nsIWebProgressListener.STATE_START |
+nsIWebProgressListener.STATE_STOP)) {
+// reset cached temporary values at beginning and end
+this.mMessage = "";
+this.mTotalProgress = 0;
+}
+this.mStateFlags = aStateFlags;
+this.mStatus = aStatus;
+},
+onLocationChange: function (aWebProgress, aRequest, aLocation,
+aFlags) {
+// OnLocationChange is called for both the top-level content
+// and the subframes.
+let topLevel = aWebProgress.isTopLevel;
+if (topLevel) {
+// If userTypedClear > 0, the document loaded correctly and we should be
+// clearing the user typed value. We also 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).
+if (this.mBrowser.userTypedClear > 0 ||
+((aFlags & Ci.nsIWebProgressListener.LOCATION_CHANGE_ERROR_PAGE) &&
+aLocation.spec != "about:blank"))
+this.mBrowser.userTypedValue = null;
+// Clear out the missing plugins list since it's related to the
+// previous location.
+this.mBrowser.missingPlugins = null;
+if (this.mTabBrowser.isFindBarInitialized(this.mTab)) {
+let findBar = this.mTabBrowser.getFindBar(this.mTab);
+// Close the Find toolbar if we're in old-style TAF mode
+if (findBar.findMode != findBar.FIND_NORMAL)
+findBar.close();
+// fix bug 253793 - turn off highlight when page changes
+findBar.getElement("highlight").checked = false;
+}
+// Don't clear the favicon if this onLocationChange was
+// triggered by a pushState or a replaceState.  See bug 550565.
+if (aWebProgress.isLoadingDocument &&
+!(aWebProgress.loadType & Ci.nsIDocShell.LOAD_CMD_PUSHSTATE)) {
+this.mBrowser.mIconURL = null;
+}
+let autocomplete = this.mTabBrowser._placesAutocomplete;
+let unifiedComplete = this.mTabBrowser._unifiedComplete;
+if (this.mBrowser.registeredOpenURI) {
+autocomplete.unregisterOpenPage(this.mBrowser.registeredOpenURI);
+unifiedComplete.unregisterOpenPage(this.mBrowser.registeredOpenURI);
+delete this.mBrowser.registeredOpenURI;
+}
+// Tabs in private windows aren't registered as "Open" so
+// that they don't appear as switch-to-tab candidates.
+if (!isBlankPageURL(aLocation.spec) &&
+(!PrivateBrowsingUtils.isWindowPrivate(window) ||
+PrivateBrowsingUtils.permanentPrivateBrowsing)) {
+autocomplete.registerOpenPage(aLocation);
+unifiedComplete.registerOpenPage(aLocation);
+this.mBrowser.registeredOpenURI = aLocation;
+}
+}
+if (!this.mBlank) {
+this._callProgressListeners("onLocationChange",
+[aWebProgress, aRequest, aLocation,
+aFlags]);
+}
+if (topLevel) {
+this.mBrowser.lastURI = aLocation;
+this.mBrowser.lastLocationChange = Date.now();
+}
+},
+onStatusChange: function (aWebProgress, aRequest, aStatus, aMessage) {
+if (this.mBlank)
+return;
+this._callProgressListeners("onStatusChange",
+[aWebProgress, aRequest, aStatus, aMessage]);
+this.mMessage = aMessage;
+},
+onSecurityChange: function (aWebProgress, aRequest, aState) {
+this._callProgressListeners("onSecurityChange",
+[aWebProgress, aRequest, aState]);
+},
+onRefreshAttempted: function (aWebProgress, aURI, aDelay, aSameURI) {
+return this._callProgressListeners("onRefreshAttempted",
+[aWebProgress, aURI, aDelay, aSameURI]);
+},
+QueryInterface: function (aIID) {
+if (aIID.equals(Components.interfaces.nsIWebProgressListener) ||
+aIID.equals(Components.interfaces.nsIWebProgressListener2) ||
+aIID.equals(Components.interfaces.nsISupportsWeakReference) ||
+aIID.equals(Components.interfaces.nsISupports))
+return this;
+throw Components.results.NS_NOINTERFACE;
+}
+});
+]]>
+</body>
+</method>
+<method name="setIcon">
+<parameter name="aTab"/>
+<parameter name="aURI"/>
+<body>
+<![CDATA[
+var browser = this.getBrowserForTab(aTab);
+browser.mIconURL = aURI instanceof Ci.nsIURI ? aURI.spec : aURI;
+if (aURI && this.mFaviconService) {
+if (!(aURI instanceof Ci.nsIURI))
+aURI = makeURI(aURI);
+this.mFaviconService.setAndFetchFaviconForPage(browser.currentURI,
+aURI, false,
+PrivateBrowsingUtils.isWindowPrivate(window) ?
+this.mFaviconService.FAVICON_LOAD_PRIVATE :
+this.mFaviconService.FAVICON_LOAD_NON_PRIVATE);
+}
+let sizedIconUrl = browser.mIconURL || "";
+if (sizedIconUrl) {
+let size = Math.round(16 * window.devicePixelRatio);
+sizedIconUrl += (sizedIconUrl.contains("#") ? "&" : "#") +
+"-moz-resolution=" + size + "," + size;
+}
+if (sizedIconUrl != aTab.getAttribute("image")) {
+if (sizedIconUrl)
+aTab.setAttribute("image", sizedIconUrl);
+else
+aTab.removeAttribute("image");
+this._tabAttrModified(aTab);
+}
+this._callProgressListeners(browser, "onLinkIconAvailable", [browser.mIconURL]);
+]]>
+</body>
+</method>
+<method name="getIcon">
+<parameter name="aTab"/>
+<body>
+<![CDATA[
+let browser = aTab ? this.getBrowserForTab(aTab) : this.selectedBrowser;
+return browser.mIconURL;
+]]>
+</body>
+</method>
+<method name="shouldLoadFavIcon">
+<parameter name="aURI"/>
+<body>
+<![CDATA[
+return (aURI &&
+Services.prefs.getBoolPref("browser.chrome.site_icons") &&
+Services.prefs.getBoolPref("browser.chrome.favicons") &&
+("schemeIs" in aURI) && (aURI.schemeIs("http") || aURI.schemeIs("https")));
+]]>
+</body>
+</method>
+<method name="useDefaultIcon">
+<parameter name="aTab"/>
+<body>
+<![CDATA[
+var browser = this.getBrowserForTab(aTab);
+var documentURI = browser.documentURI;
+var icon = null;
+if (browser.imageDocument) {
+if (Services.prefs.getBoolPref("browser.chrome.site_icons")) {
+let sz = Services.prefs.getIntPref("browser.chrome.image_icons.max_size");
+if (browser.imageDocument.width <= sz &&
+browser.imageDocument.height <= sz) {
+icon = browser.currentURI;
+}
+}
+}
+// Use documentURIObject in the check for shouldLoadFavIcon so that we
+// do the right thing with about:-style error pages.  Bug 453442
+else if (this.shouldLoadFavIcon(documentURI)) {
+let url = documentURI.prePath + "/favicon.ico";
+if (!this.isFailedIcon(url))
+icon = url;
+}
+this.setIcon(aTab, icon);
+]]>
+</body>
+</method>
+<method name="isFailedIcon">
+<parameter name="aURI"/>
+<body>
+<![CDATA[
+if (this.mFaviconService) {
+if (!(aURI instanceof Ci.nsIURI))
+aURI = makeURI(aURI);
+return this.mFaviconService.isFailedFavicon(aURI);
+}
+return null;
+]]>
+</body>
+</method>
+<method name="getWindowTitleForBrowser">
+<parameter name="aBrowser"/>
+<body>
+<![CDATA[
+var newTitle = "";
+var docElement = this.ownerDocument.documentElement;
+var sep = docElement.getAttribute("titlemenuseparator");
+// Strip out any null bytes in the content title, since the
+// underlying widget implementations of nsWindow::SetTitle pass
+// null-terminated strings to system APIs.
+var docTitle = aBrowser.contentTitle.replace("\0", "", "g");
+if (!docTitle)
+docTitle = docElement.getAttribute("titledefault");
+var modifier = docElement.getAttribute("titlemodifier");
+if (docTitle) {
+newTitle += docElement.getAttribute("titlepreface");
+newTitle += docTitle;
+if (modifier)
+newTitle += sep;
+}
+newTitle += modifier;
+// 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").contains("location")) {
+var uri = this.mURIFixup.createExposableURI(
+aBrowser.currentURI);
+if (uri.scheme == "about")
+newTitle = uri.spec + sep + newTitle;
+else
+newTitle = uri.prePath + sep + newTitle;
+}
+} catch (e) {}
+return newTitle;
+]]>
+</body>
+</method>
+<method name="updateTitlebar">
+<body>
+<![CDATA[
+if ("TabView" in window && TabView.isVisible()) {
+// ToDo: this will be removed when we gain ability to draw to the menu bar.
+// Bug 586175
+this.ownerDocument.title = TabView.windowTitle;
+}
+else {
+this.ownerDocument.title = this.getWindowTitleForBrowser(this.mCurrentBrowser);
+}
+]]>
+</body>
+</method>
+<method name="updateCurrentBrowser">
+<parameter name="aForceUpdate"/>
+<body>
+<![CDATA[
+var newBrowser = this.getBrowserAtIndex(this.tabContainer.selectedIndex);
+if (this.mCurrentBrowser == newBrowser && !aForceUpdate)
+return;
+if (!aForceUpdate) {
+TelemetryStopwatch.start("FX_TAB_SWITCH_UPDATE_MS");
+window.QueryInterface(Ci.nsIInterfaceRequestor).getInterface(Ci.nsIDOMWindowUtils)
+.beginTabSwitch();
+}
+var oldTab = this.mCurrentTab;
+// Preview mode should not reset the owner
+if (!this._previewMode && !oldTab.selected)
+oldTab.owner = null;
+if (this._lastRelatedTab) {
+if (!this._lastRelatedTab.selected)
+this._lastRelatedTab.owner = null;
+this._lastRelatedTab = null;
+}
+var oldBrowser = this.mCurrentBrowser;
+oldBrowser.setAttribute("type", "content-targetable");
+oldBrowser.docShellIsActive = false;
+var updateBlockedPopups = false;
+if ((oldBrowser.blockedPopups && !newBrowser.blockedPopups) ||
+(!oldBrowser.blockedPopups && newBrowser.blockedPopups))
+updateBlockedPopups = true;
+newBrowser.setAttribute("type", "content-primary");
+newBrowser.docShellIsActive =
+(window.windowState != window.STATE_MINIMIZED);
+this.mCurrentBrowser = newBrowser;
+this.mCurrentTab = this.tabContainer.selectedItem;
+this.showTab(this.mCurrentTab);
+var forwardButtonContainer = document.getElementById("urlbar-wrapper");
+if (forwardButtonContainer) {
+forwardButtonContainer.setAttribute("switchingtabs", "true");
+window.addEventListener("MozAfterPaint", function removeSwitchingtabsAttr() {
+window.removeEventListener("MozAfterPaint", removeSwitchingtabsAttr);
+forwardButtonContainer.removeAttribute("switchingtabs");
+});
+}
+this._appendStatusPanel();
+if (updateBlockedPopups)
+this.mCurrentBrowser.updateBlockedPopups(false);
+// Update the URL bar.
+var loc = this.mCurrentBrowser.currentURI;
+// Bug 666809 - SecurityUI support for e10s
+var webProgress = this.mCurrentBrowser.webProgress;
+var securityUI = this.mCurrentBrowser.securityUI;
+this._callProgressListeners(null, "onLocationChange",
+[webProgress, null, loc, 0], true,
+false);
+if (securityUI) {
+this._callProgressListeners(null, "onSecurityChange",
+[webProgress, null, securityUI.state], true, false);
+}
+var listener = this.mTabListeners[this.tabContainer.selectedIndex] || null;
+if (listener && listener.mStateFlags) {
+this._callProgressListeners(null, "onUpdateCurrentBrowser",
+[listener.mStateFlags, listener.mStatus,
+listener.mMessage, listener.mTotalProgress],
+true, false);
+}
+if (!this._previewMode) {
+this.mCurrentTab.removeAttribute("unread");
+oldTab.lastAccessed = Date.now();
+let oldFindBar = oldTab._findBar;
+if (oldFindBar &&
+oldFindBar.findMode == oldFindBar.FIND_NORMAL &&
+!oldFindBar.hidden)
+this._lastFindValue = oldFindBar._findField.value;
+this.updateTitlebar();
+this.mCurrentTab.removeAttribute("titlechanged");
+}
+// If the new tab is busy, and our current state is not busy, then
+// we need to fire a start to all progress listeners.
+const nsIWebProgressListener = Components.interfaces.nsIWebProgressListener;
+if (this.mCurrentTab.hasAttribute("busy") && !this.mIsBusy) {
+this.mIsBusy = true;
+this._callProgressListeners(null, "onStateChange",
+[webProgress, null,
+nsIWebProgressListener.STATE_START |
+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 (!this.mCurrentTab.hasAttribute("busy") && this.mIsBusy) {
+this.mIsBusy = false;
+this._callProgressListeners(null, "onStateChange",
+[webProgress, null,
+nsIWebProgressListener.STATE_STOP |
+nsIWebProgressListener.STATE_IS_NETWORK, 0],
+true, false);
+}
+this._setCloseKeyState(!this.mCurrentTab.pinned);
+// 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
+}
+});
+this.mCurrentTab.dispatchEvent(event);
+this._tabAttrModified(oldTab);
+this._tabAttrModified(this.mCurrentTab);
+if (oldBrowser != newBrowser &&
+oldBrowser.docShell &&
+oldBrowser.docShell.contentViewer.inPermitUnload) {
+// 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();
+// NB: This code assumes that the beforeunload prompt
+//     is the top-most prompt on the tab.
+promptBox.removePrompt(prompts[prompts.length - 1]);
+}
+// Adjust focus
+oldBrowser._urlbarFocused = (gURLBar && gURLBar.focused);
+if (this.isFindBarInitialized(oldTab)) {
+let findBar = this.getFindBar(oldTab);
+oldTab._findBarFocused = (!findBar.hidden &&
+findBar._findField.getAttribute("focused") == "true");
+}
+do {
+// When focus is in the tab bar, retain it there.
+if (document.activeElement == oldTab) {
+// We need to explicitly focus the new tab, because
+// tabbox.xml does this only in some cases.
+this.mCurrentTab.focus();
+break;
+}
+// If there's a tabmodal prompt showing, focus it.
+if (newBrowser.hasAttribute("tabmodalPromptShowing")) {
+let XUL_NS = "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul";
+let prompts = newBrowser.parentNode.getElementsByTagNameNS(XUL_NS, "tabmodalprompt");
+let prompt = prompts[prompts.length - 1];
+prompt.Dialog.setDefaultFocus();
+break;
+}
+// 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) {
+// Explicitly close the popup if the URL bar retains focus
+gURLBar.closePopup();
+if (!window.fullScreen) {
+gURLBar.focus();
+break;
+} else if (isTabEmpty(this.mCurrentTab)) {
+focusAndSelectUrlBar();
+break;
+}
+}
+// Focus the find bar if it was previously focused for that tab.
+if (gFindBarInitialized && !gFindBar.hidden &&
+this.selectedTab._findBarFocused) {
+gFindBar._findField.focus();
+break;
+}
+// Otherwise, focus the content area.
+let fm = Cc["@mozilla.org/focus-manager;1"].getService(Ci.nsIFocusManager);
+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 &&
+(newFocusedElement instanceof HTMLAnchorElement ||
+newFocusedElement.getAttributeNS("http://www.w3.org/1999/xlink", "type") == "simple"))
+focusFlags |= fm.FLAG_SHOWRING;
+}
+fm.setFocus(newBrowser, focusFlags);
+} while (false);
+}
+this.tabContainer._setPositionalAttributes();
+if (!aForceUpdate)
+TelemetryStopwatch.finish("FX_TAB_SWITCH_UPDATE_MS");
+]]>
+</body>
+</method>
+<method name="_tabAttrModified">
+<parameter name="aTab"/>
+<body><![CDATA[
+if (aTab.closing)
+return;
+// This event should be dispatched when any of these attributes change:
+// label, crop, busy, image, selected
+var event = document.createEvent("Events");
+event.initEvent("TabAttrModified", true, false);
+aTab.dispatchEvent(event);
+]]></body>
+</method>
+<method name="setTabTitleLoading">
+<parameter name="aTab"/>
+<body>
+<![CDATA[
+aTab.label = this.mStringBundle.getString("tabs.connecting");
+aTab.crop = "end";
+this._tabAttrModified(aTab);
+]]>
+</body>
+</method>
+<method name="setTabTitle">
+<parameter name="aTab"/>
+<body>
+<![CDATA[
+var browser = this.getBrowserForTab(aTab);
+var crop = "end";
+var title = browser.contentTitle;
+if (!title) {
+if (browser.currentURI.spec) {
+try {
+title = this.mURIFixup.createExposableURI(browser.currentURI).spec;
+} catch(ex) {
+title = browser.currentURI.spec;
+}
+}
+if (title && !isBlankPageURL(title)) {
+// At this point, we now have a URI.
+// Let's try to unescape it using a character set
+// in case the URI is not ASCII.
+try {
+var characterSet = browser.characterSet;
+const textToSubURI = Components.classes["@mozilla.org/intl/texttosuburi;1"]
+.getService(Components.interfaces.nsITextToSubURI);
+title = textToSubURI.unEscapeNonAsciiURI(characterSet, title);
+} catch(ex) { /* Do nothing. */ }
+crop = "center";
+} else // Still no title?  Fall back to our untitled string.
+title = this.mStringBundle.getString("tabs.emptyTabTitle");
+}
+if (aTab.label == title &&
+aTab.crop == crop)
+return false;
+aTab.label = title;
+aTab.crop = crop;
+this._tabAttrModified(aTab);
+if (aTab.selected)
+this.updateTitlebar();
+return true;
+]]>
+</body>
+</method>
+<method name="loadOneTab">
+<parameter name="aURI"/>
+<parameter name="aReferrerURI"/>
+<parameter name="aCharset"/>
+<parameter name="aPostData"/>
+<parameter name="aLoadInBackground"/>
+<parameter name="aAllowThirdPartyFixup"/>
+<body>
+<![CDATA[
+var aFromExternal;
+var aRelatedToCurrent;
+var aDisableMCB;
+var aSkipAnimation;
+if (arguments.length == 2 &&
+typeof arguments[1] == "object" &&
+!(arguments[1] instanceof Ci.nsIURI)) {
+let params = arguments[1];
+aReferrerURI          = params.referrerURI;
+aCharset              = params.charset;
+aPostData             = params.postData;
+aLoadInBackground     = params.inBackground;
+aAllowThirdPartyFixup = params.allowThirdPartyFixup;
+aFromExternal         = params.fromExternal;
+aRelatedToCurrent     = params.relatedToCurrent;
+aDisableMCB           = params.disableMCB;
+aSkipAnimation        = params.skipAnimation;
+}
+var bgLoad = (aLoadInBackground != null) ? aLoadInBackground :
+Services.prefs.getBoolPref("browser.tabs.loadInBackground");
+var owner = bgLoad ? null : this.selectedTab;
+var tab = this.addTab(aURI, {
+referrerURI: aReferrerURI,
+charset: aCharset,
+postData: aPostData,
+ownerTab: owner,
+allowThirdPartyFixup: aAllowThirdPartyFixup,
+fromExternal: aFromExternal,
+relatedToCurrent: aRelatedToCurrent,
+skipAnimation: aSkipAnimation,
+disableMCB: aDisableMCB});
+if (!bgLoad)
+this.selectedTab = tab;
+return tab;
+]]>
+</body>
+</method>
+<method name="loadTabs">
+<parameter name="aURIs"/>
+<parameter name="aLoadInBackground"/>
+<parameter name="aReplace"/>
+<body><![CDATA[
+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 || aLoadInBackground ? null : this.selectedTab;
+var firstTabAdded = null;
+if (aReplace) {
+try {
+this.loadURI(aURIs[0], null, null);
+} catch (e) {
+// Ignore failure in case a URI is wrong, so we can continue
+// opening the next ones.
+}
+}
+else
+firstTabAdded = this.addTab(aURIs[0], {ownerTab: owner, skipAnimation: multiple});
+var tabNum = this.tabContainer.selectedIndex;
+for (let i = 1; i < aURIs.length; ++i) {
+let tab = this.addTab(aURIs[i], {skipAnimation: true});
+if (aReplace)
+this.moveTabTo(tab, ++tabNum);
+}
+if (!aLoadInBackground) {
+if (firstTabAdded) {
+// .selectedTab setter focuses the content area
+this.selectedTab = firstTabAdded;
+}
+else
+this.selectedBrowser.focus();
+}
+]]></body>
+</method>
+#ifdef MAKE_E10S_WORK
+<method name="updateBrowserRemoteness">
+<parameter name="aBrowser"/>
+<parameter name="aURL"/>
+<body>
+<![CDATA[
+let shouldBeRemote = this._shouldBrowserBeRemote(aURL);
+let isRemote = aBrowser.getAttribute("remote") == "true";
+if (isRemote == shouldBeRemote)
+return false;
+let wasActive = document.activeElement == aBrowser;
+// Unhook our progress listener.
+let tab = this._getTabForBrowser(aBrowser);
+let index = tab._tPos;
+let filter = this.mTabFilters[index];
+aBrowser.webProgress.removeProgressListener(filter);
+// Change the "remote" attribute.
+let parent = aBrowser.parentNode;
+parent.removeChild(aBrowser);
+aBrowser.setAttribute("remote", shouldBeRemote ? "true" : "false");
+parent.appendChild(aBrowser);
+// Restore the progress listener.
+aBrowser.webProgress.addProgressListener(filter, Ci.nsIWebProgress.NOTIFY_ALL);
+if (shouldBeRemote)
+tab.setAttribute("remote", "true");
+else
+tab.removeAttribute("remote");
+if (wasActive)
+aBrowser.focus();
+return true;
+]]>
+</body>
+</method>
+<!--
+Returns true if we want to load the content for this URL in a
+remote process. Eventually this should just check whether aURL
+is unprivileged. Right now, though, we would like to load
+some unprivileged URLs (like about:neterror) in the main
+process since they interact with chrome code through
+BrowserOnClick.
+-->
+<method name="_shouldBrowserBeRemote">
+<parameter name="aURL"/>
+<body>
+<![CDATA[
+if (!gMultiProcessBrowser)
+return false;
+// loadURI in browser.xml treats null as about:blank
+if (!aURL)
+aURL = "about:blank";
+if (aURL.startsWith("about:") &&
+aURL.toLowerCase() != "about:home" &&
+aURL.toLowerCase() != "about:blank") {
+return false;
+}
+if (aURL.startsWith("chrome:"))
+return false;
+return true;
+]]>
+</body>
+</method>
+#endif
+<method name="addTab">
+<parameter name="aURI"/>
+<parameter name="aReferrerURI"/>
+<parameter name="aCharset"/>
+<parameter name="aPostData"/>
+<parameter name="aOwner"/>
+<parameter name="aAllowThirdPartyFixup"/>
+<body>
+<![CDATA[
+const NS_XUL = "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul";
+var aFromExternal;
+var aRelatedToCurrent;
+var aSkipAnimation;
+var aDisableMCB;
+if (arguments.length == 2 &&
+typeof arguments[1] == "object" &&
+!(arguments[1] instanceof Ci.nsIURI)) {
+let params = arguments[1];
+aReferrerURI          = params.referrerURI;
+aCharset              = params.charset;
+aPostData             = params.postData;
+aOwner                = params.ownerTab;
+aAllowThirdPartyFixup = params.allowThirdPartyFixup;
+aFromExternal         = params.fromExternal;
+aRelatedToCurrent     = params.relatedToCurrent;
+aSkipAnimation        = params.skipAnimation;
+aDisableMCB           = params.disableMCB;
+}
+// if we're adding tabs, we're past interrupt mode, ditch the owner
+if (this.mCurrentTab.owner)
+this.mCurrentTab.owner = null;
+var t = document.createElementNS(NS_XUL, "tab");
+var uriIsAboutBlank = !aURI || aURI == "about:blank";
+t.setAttribute("crop", "end");
+t.setAttribute("onerror", "this.removeAttribute('image');");
+t.className = "tabbrowser-tab";
+#ifdef MAKE_E10S_WORK
+let remote = this._shouldBrowserBeRemote(aURI);
+#else
+let remote = gMultiProcessBrowser;
+#endif
+if (remote)
+t.setAttribute("remote", "true");
+this.tabContainer._unlockTabSizing();
+// 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 = !aSkipAnimation &&
+this.tabContainer.getAttribute("overflow") != "true" &&
+Services.prefs.getBoolPref("browser.tabs.animate");
+if (!animate) {
+t.setAttribute("fadein", "true");
+setTimeout(function (tabContainer) {
+tabContainer._handleNewTab(t);
+}, 0, this.tabContainer);
+}
+// invalidate caches
+this._browsers = null;
+this._visibleTabs = null;
+this.tabContainer.appendChild(t);
+// If this new tab is owned by another, assert that relationship
+if (aOwner)
+t.owner = aOwner;
+var b = document.createElementNS(
+"http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul",
+"browser");
+b.setAttribute("type", "content-targetable");
+b.setAttribute("message", "true");
+b.setAttribute("contextmenu", this.getAttribute("contentcontextmenu"));
+b.setAttribute("tooltip", this.getAttribute("contenttooltip"));
+if (remote)
+b.setAttribute("remote", "true");
+if (window.gShowPageResizers && window.windowState == window.STATE_NORMAL) {
+b.setAttribute("showresizer", "true");
+}
+if (this.hasAttribute("autocompletepopup"))
+b.setAttribute("autocompletepopup", this.getAttribute("autocompletepopup"));
+if (this.hasAttribute("selectpopup"))
+b.setAttribute("selectpopup", this.getAttribute("selectpopup"));
+b.setAttribute("autoscrollpopup", this._autoScrollPopup.id);
+// Create the browserStack container
+var stack = document.createElementNS(NS_XUL, "stack");
+stack.className = "browserStack";
+stack.appendChild(b);
+stack.setAttribute("flex", "1");
+// Create the browserContainer
+var browserContainer = document.createElementNS(NS_XUL, "vbox");
+browserContainer.className = "browserContainer";
+browserContainer.appendChild(stack);
+browserContainer.setAttribute("flex", "1");
+// Create the sidebar container
+var browserSidebarContainer = document.createElementNS(NS_XUL,
+"hbox");
+browserSidebarContainer.className = "browserSidebarContainer";
+browserSidebarContainer.appendChild(browserContainer);
+browserSidebarContainer.setAttribute("flex", "1");
+// Add the Message and the Browser to the box
+var notificationbox = document.createElementNS(NS_XUL,
+"notificationbox");
+notificationbox.setAttribute("flex", "1");
+notificationbox.appendChild(browserSidebarContainer);
+var position = this.tabs.length - 1;
+var uniqueId = this._generateUniquePanelID();
+notificationbox.id = uniqueId;
+t.linkedPanel = uniqueId;
+t.linkedBrowser = b;
+t._tPos = position;
+this.tabContainer._setPositionalAttributes();
+// Prevent the superfluous initial load of a blank document
+// if we're going to load something other than about:blank.
+if (!uriIsAboutBlank) {
+b.setAttribute("nodefaultsrc", "true");
+}
+// 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.mPanelContainer.appendChild(notificationbox);
+// We've waited until the tab is in the DOM to set the label. This
+// allows the TabLabelModified event to be properly dispatched.
+if (!aURI || isBlankPageURL(aURI)) {
+t.label = this.mStringBundle.getString("tabs.emptyTabTitle");
+} else {
+t.label = aURI;
+}
+this.tabContainer.updateVisibility();
+// wire up a progress listener for the new browser object.
+var tabListener = this.mTabProgressListener(t, b, uriIsAboutBlank);
+const filter = Components.classes["@mozilla.org/appshell/component/browser-status-filter;1"]
+.createInstance(Components.interfaces.nsIWebProgress);
+filter.addProgressListener(tabListener, Components.interfaces.nsIWebProgress.NOTIFY_ALL);
+b.webProgress.addProgressListener(filter, Components.interfaces.nsIWebProgress.NOTIFY_ALL);
+this.mTabListeners[position] = tabListener;
+this.mTabFilters[position] = filter;
+b.droppedLinkHandler = handleDroppedLink;
+// If we just created a new tab that loads the default
+// newtab url, swap in a preloaded page if possible.
+// Do nothing if we're a private window.
+let docShellsSwapped = false;
+if (aURI == BROWSER_NEW_TAB_URL &&
+!PrivateBrowsingUtils.isWindowPrivate(window) &&
+!gMultiProcessBrowser) {
+docShellsSwapped = gBrowserNewTabPreloader.newTab(t);
+} else if (aURI == "about:customizing") {
+docShellsSwapped = gCustomizationTabPreloader.newTab(t);
+}
+// Dispatch a new tab notification.  We do this once we're
+// entirely done, so that things are in a consistent state
+// even if the event listener opens or closes tabs.
+var evt = document.createEvent("Events");
+evt.initEvent("TabOpen", true, false);
+t.dispatchEvent(evt);
+// If we didn't swap docShells with a preloaded browser
+// then let's just continue loading the page normally.
+if (!docShellsSwapped && !uriIsAboutBlank) {
+// pretend the user typed this so it'll be available till
+// the document successfully loads
+if (aURI && gInitialPages.indexOf(aURI) == -1)
+b.userTypedValue = aURI;
+let flags = Ci.nsIWebNavigation.LOAD_FLAGS_NONE;
+if (aAllowThirdPartyFixup) {
+flags |= Ci.nsIWebNavigation.LOAD_FLAGS_ALLOW_THIRD_PARTY_FIXUP;
+flags |= Ci.nsIWebNavigation.LOAD_FLAGS_FIXUP_SCHEME_TYPOS;
+}
+if (aFromExternal)
+flags |= Ci.nsIWebNavigation.LOAD_FLAGS_FROM_EXTERNAL;
+if (aDisableMCB)
+flags |= Ci.nsIWebNavigation.LOAD_FLAGS_ALLOW_MIXED_CONTENT;
+try {
+b.loadURIWithFlags(aURI, flags, aReferrerURI, aCharset, aPostData);
+} catch (ex) {
+Cu.reportError(ex);
+}
+}
+// We start our browsers out as inactive, and then maintain
+// activeness in the tab switcher.
+b.docShellIsActive = false;
+// Check if we're opening a tab related to the current tab and
+// move it to after the current tab.
+// aReferrerURI is null or undefined if the tab is opened from
+// an external application or bookmark, i.e. somewhere other
+// than the current tab.
+if ((aRelatedToCurrent == null ? aReferrerURI : aRelatedToCurrent) &&
+Services.prefs.getBoolPref("browser.tabs.insertRelatedAfterCurrent")) {
+let newTabPos = (this._lastRelatedTab ||
+this.selectedTab)._tPos + 1;
+if (this._lastRelatedTab)
+this._lastRelatedTab.owner = null;
+else
+t.owner = this.selectedTab;
+this.moveTabTo(t, newTabPos);
+this._lastRelatedTab = t;
+}
+if (animate) {
+mozRequestAnimationFrame(function () {
+this.tabContainer._handleTabTelemetryStart(t, aURI);
+// kick the animation off
+t.setAttribute("fadein", "true");
+}.bind(this));
+}
+return t;
+]]>
+</body>
+</method>
+<method name="warnAboutClosingTabs">
+<parameter name="aCloseTabs"/>
+<parameter name="aTab"/>
+<body>
+<![CDATA[
+var tabsToClose;
+switch (aCloseTabs) {
+case this.closingTabsEnum.ALL:
+tabsToClose = this.tabs.length - this._removingTabs.length -
+gBrowser._numPinnedTabs;
+break;
+case this.closingTabsEnum.OTHER:
+tabsToClose = this.visibleTabs.length - 1 - gBrowser._numPinnedTabs;
+break;
+case this.closingTabsEnum.TO_END:
+if (!aTab)
+throw new Error("Required argument missing: aTab");
+tabsToClose = this.getTabsToTheEndFrom(aTab).length;
+break;
+default:
+throw new Error("Invalid argument: " + aCloseTabs);
+}
+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;
+var ps = Services.prompt;
+// default to true: if it were false, we wouldn't get this far
+var warnOnClose = { value: true };
+var bundle = this.mStringBundle;
+// 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();
+var warningMessage =
+PluralForm.get(tabsToClose, bundle.getString("tabs.closeWarningMultiple"))
+.replace("#1", tabsToClose);
+var buttonPressed =
+ps.confirmEx(window,
+bundle.getString("tabs.closeWarningTitle"),
+warningMessage,
+(ps.BUTTON_TITLE_IS_STRING * ps.BUTTON_POS_0)
++ (ps.BUTTON_TITLE_CANCEL * ps.BUTTON_POS_1),
+bundle.getString("tabs.closeButtonMultiple"),
+null, null,
+aCloseTabs == this.closingTabsEnum.ALL ?
+bundle.getString("tabs.closeWarningPromptMe") : null,
+warnOnClose);
+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;
+]]>
+</body>
+</method>
+<method name="getTabsToTheEndFrom">
+<parameter name="aTab"/>
+<body>
+<![CDATA[
+var tabsToEnd = [];
+let tabs = this.visibleTabs;
+for (let i = tabs.length - 1; tabs[i] != aTab && i >= 0; --i) {
+tabsToEnd.push(tabs[i]);
+}
+return tabsToEnd.reverse();
+]]>
+</body>
+</method>
+<method name="removeTabsToTheEndFrom">
+<parameter name="aTab"/>
+<body>
+<![CDATA[
+if (this.warnAboutClosingTabs(this.closingTabsEnum.TO_END, aTab)) {
+let tabs = this.getTabsToTheEndFrom(aTab);
+for (let i = tabs.length - 1; i >= 0; --i) {
+this.removeTab(tabs[i], {animate: true});
+}
+}
+]]>
+</body>
+</method>
+<method name="removeAllTabsBut">
+<parameter name="aTab"/>
+<body>
+<![CDATA[
+if (aTab.pinned)
+return;
+if (this.warnAboutClosingTabs(this.closingTabsEnum.OTHER)) {
+let tabs = this.visibleTabs;
+this.selectedTab = aTab;
+for (let i = tabs.length - 1; i >= 0; --i) {
+if (tabs[i] != aTab && !tabs[i].pinned)
+this.removeTab(tabs[i], {animate: true});
+}
+}
+]]>
+</body>
+</method>
+<method name="removeCurrentTab">
+<parameter name="aParams"/>
+<body>
+<![CDATA[
+this.removeTab(this.mCurrentTab, aParams);
+]]>
+</body>
+</method>
+<field name="_removingTabs">
+[]
+</field>
+<method name="removeTab">
+<parameter name="aTab"/>
+<parameter name="aParams"/>
+<body>
+<![CDATA[
+if (aParams) {
+var animate = aParams.animate;
+var byMouse = aParams.byMouse;
+}
+// Handle requests for synchronously removing an already
+// asynchronously closing tab.
+if (!animate &&
+aTab.closing) {
+this._endRemoveTab(aTab);
+return;
+}
+var isLastTab = (this.tabs.length - this._removingTabs.length == 1);
+if (!this._beginRemoveTab(aTab, false, null, true))
+return;
+if (!aTab.pinned && !aTab.hidden && aTab._fullyOpen && byMouse)
+this.tabContainer._lockTabSizing(aTab);
+else
+this.tabContainer._unlockTabSizing();
+if (!animate /* the caller didn't opt in */ ||
+isLastTab ||
+aTab.pinned ||
+aTab.hidden ||
+this._removingTabs.length > 3 /* don't want lots of concurrent animations */ ||
+aTab.getAttribute("fadein") != "true" /* fade-in transition hasn't been triggered yet */ ||
+window.getComputedStyle(aTab).maxWidth == "0.1px" /* fade-in transition hasn't moved yet */ ||
+!Services.prefs.getBoolPref("browser.tabs.animate")) {
+this._endRemoveTab(aTab);
+return;
+}
+this.tabContainer._handleTabTelemetryStart(aTab);
+this._blurTab(aTab);
+aTab.style.maxWidth = ""; // ensure that fade-out transition happens
+aTab.removeAttribute("fadein");
+setTimeout(function (tab, tabbrowser) {
+if (tab.parentNode &&
+window.getComputedStyle(tab).maxWidth == "0.1px") {
+NS_ASSERT(false, "Giving up waiting for the tab closing animation to finish (bug 608589)");
+tabbrowser._endRemoveTab(tab);
+}
+}, 3000, aTab, this);
+]]>
+</body>
+</method>
+<!-- Tab close requests are ignored if the window is closing anyway,
+e.g. when holding Ctrl+W. -->
+<field name="_windowIsClosing">
+false
+</field>
+<method name="_beginRemoveTab">
+<parameter name="aTab"/>
+<parameter name="aTabWillBeMoved"/>
+<parameter name="aCloseWindowWithLastTab"/>
+<parameter name="aCloseWindowFastpath"/>
+<body>
+<![CDATA[
+if (aTab.closing ||
+this._windowIsClosing)
+return false;
+var browser = this.getBrowserForTab(aTab);
+if (!aTabWillBeMoved) {
+let ds = browser.docShell;
+if (ds &&
+ds.contentViewer &&
+!ds.contentViewer.permitUnload()) {
+return false;
+}
+}
+var closeWindow = false;
+var newTab = false;
+if (this.tabs.length - this._removingTabs.length == 1) {
+closeWindow = aCloseWindowWithLastTab != null ? aCloseWindowWithLastTab :
+!window.toolbar.visible ||
+Services.prefs.getBoolPref("browser.tabs.closeWindowWithLastTab");
+// 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 &&
+aCloseWindowFastpath &&
+this._removingTabs.length == 0) {
+// 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);
+return null;
+}
+newTab = true;
+}
+aTab.closing = true;
+this._removingTabs.push(aTab);
+this._visibleTabs = null; // invalidate cache
+// Invalidate hovered tab state tracking for this closing tab.
+if (this.tabContainer._hoveredTab == aTab)
+aTab._mouseleave();
+if (newTab)
+this.addTab(BROWSER_NEW_TAB_URL, {skipAnimation: true});
+else
+this.tabContainer.updateVisibility();
+// 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.
+var evt = document.createEvent("UIEvent");
+evt.initUIEvent("TabClose", true, false, window, aTabWillBeMoved ? 1 : 0);
+aTab.dispatchEvent(evt);
+if (!aTabWillBeMoved && !gMultiProcessBrowser) {
+// Prevent this tab from showing further dialogs, since we're closing it
+var windowUtils = browser.contentWindow.QueryInterface(Ci.nsIInterfaceRequestor).
+getInterface(Ci.nsIDOMWindowUtils);
+windowUtils.disableDialogs();
+}
+// Remove the tab's filter and progress listener.
+const filter = this.mTabFilters[aTab._tPos];
+browser.webProgress.removeProgressListener(filter);
+filter.removeProgressListener(this.mTabListeners[aTab._tPos]);
+this.mTabListeners[aTab._tPos].destroy();
+if (browser.registeredOpenURI && !aTabWillBeMoved) {
+this._placesAutocomplete.unregisterOpenPage(browser.registeredOpenURI);
+this._unifiedComplete.unregisterOpenPage(browser.registeredOpenURI);
+delete browser.registeredOpenURI;
+}
+// We are no longer the primary content area.
+browser.setAttribute("type", "content-targetable");
+// Remove this tab as the owner of any other tabs, since it's going away.
+Array.forEach(this.tabs, function (tab) {
+if ("owner" in tab && tab.owner == aTab)
+// |tab| is a child of the tab we're removing, make it an orphan
+tab.owner = null;
+});
+aTab._endRemoveArgs = [closeWindow, newTab];
+return true;
+]]>
+</body>
+</method>
+<method name="_endRemoveTab">
+<parameter name="aTab"/>
+<body>
+<![CDATA[
+if (!aTab || !aTab._endRemoveArgs)
+return;
+var [aCloseWindow, aNewTab] = aTab._endRemoveArgs;
+aTab._endRemoveArgs = null;
+if (this._windowIsClosing) {
+aCloseWindow = false;
+aNewTab = false;
+}
+this._lastRelatedTab = null;
+// update the UI early for responsiveness
+aTab.collapsed = true;
+this.tabContainer._fillTrailingGap();
+this._blurTab(aTab);
+this._removingTabs.splice(this._removingTabs.indexOf(aTab), 1);
+if (aCloseWindow) {
+this._windowIsClosing = true;
+while (this._removingTabs.length)
+this._endRemoveTab(this._removingTabs[0]);
+} else if (!this._windowIsClosing) {
+if (aNewTab)
+focusAndSelectUrlBar();
+// workaround for bug 345399
+this.tabContainer.mTabstrip._updateScrollButtonsDisabledState();
+}
+// We're going to remove the tab and the browser now.
+// Clean up mTabFilters and mTabListeners now rather than in
+// _beginRemoveTab, so that their size is always in sync with the
+// number of tabs and browsers (the xbl destructor depends on this).
+this.mTabFilters.splice(aTab._tPos, 1);
+this.mTabListeners.splice(aTab._tPos, 1);
+var browser = this.getBrowserForTab(aTab);
+// Because of the way XBL works (fields just set JS
+// properties on the element) and the code we have 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 so that the
+// XBL implementation of nsIObserver still works.
+browser.destroy();
+var wasPinned = aTab.pinned;
+// Invalidate browsers cache, as the tab is removed from the
+// tab container.
+this._browsers = null;
+// Remove the tab ...
+this.tabContainer.removeChild(aTab);
+// ... 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.adjustTabstrip();
+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.getNotificationBox(browser);
+// 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.parentNode.removeChild(browser);
+// Release the browser in case something is erroneously holding a
+// reference to the tab after its removal.
+aTab.linkedBrowser = null;
+// As the browser is removed, the removal of a dependent document can
+// cause the whole window to close. So at this point, it's possible
+// that the binding is destructed.
+if (this.mTabBox) {
+let selectedPanel = this.mTabBox.selectedPanel;
+this.mPanelContainer.removeChild(panel);
+// Under the hood, a selectedIndex attribute controls which panel
+// is displayed. Removing a panel A which precedes the selected
+// panel B makes selectedIndex point to the panel next to B. We
+// need to explicitly preserve B as the selected panel.
+this.mTabBox.selectedPanel = selectedPanel;
+}
+if (aCloseWindow)
+this._windowIsClosing = closeWindow(true, window.warnAboutClosingWindow);
+]]>
+</body>
+</method>
+<method name="_blurTab">
+<parameter name="aTab"/>
+<body>
+<![CDATA[
+if (!aTab.selected)
+return;
+if (aTab.owner &&
+!aTab.owner.hidden &&
+!aTab.owner.closing &&
+Services.prefs.getBoolPref("browser.tabs.selectOwnerOnClose")) {
+this.selectedTab = aTab.owner;
+return;
+}
+// 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.filter(this.tabs, function(tab) {
+return !tab.closing;
+}, this);
+}
+// Try to find a remaining tab that comes after the given tab
+var tab = aTab;
+do {
+tab = tab.nextSibling;
+} while (tab && remainingTabs.indexOf(tab) == -1);
+if (!tab) {
+tab = aTab;
+do {
+tab = tab.previousSibling;
+} while (tab && remainingTabs.indexOf(tab) == -1);
+}
+this.selectedTab = tab;
+]]>
+</body>
+</method>
+<method name="swapNewTabWithBrowser">
+<parameter name="aNewTab"/>
+<parameter name="aBrowser"/>
+<body>
+<![CDATA[
+// The browser must be standalone.
+if (aBrowser.getTabBrowser())
+throw Cr.NS_ERROR_INVALID_ARG;
+// The tab is definitely not loading.
+aNewTab.removeAttribute("busy");
+if (aNewTab.selected) {
+this.mIsBusy = false;
+}
+this._swapBrowserDocShells(aNewTab, aBrowser);
+// Update the new tab's title.
+this.setTabTitle(aNewTab);
+if (aNewTab.selected) {
+this.updateCurrentBrowser(true);
+}
+]]>
+</body>
+</method>
+<method name="swapBrowsersAndCloseOther">
+<parameter name="aOurTab"/>
+<parameter name="aOtherTab"/>
+<body>
+<![CDATA[
+// Do not allow transfering a private tab to a non-private window
+// and vice versa.
+if (PrivateBrowsingUtils.isWindowPrivate(window) !=
+PrivateBrowsingUtils.isWindowPrivate(aOtherTab.ownerDocument.defaultView))
+return;
+// That's gBrowser for the other window, not the tab's browser!
+var remoteBrowser = aOtherTab.ownerDocument.defaultView.gBrowser;
+var isPending = aOtherTab.hasAttribute("pending");
+// 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, true, true))
+return;
+let ourBrowser = this.getBrowserForTab(aOurTab);
+let otherBrowser = aOtherTab.linkedBrowser;
+// 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) {
+SessionStore.setTabState(aOurTab, SessionStore.getTabState(aOtherTab));
+// 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");
+this._tabAttrModified(aOurTab);
+if (aOurTab.selected)
+this.mIsBusy = true;
+}
+this._swapBrowserDocShells(aOurTab, otherBrowser);
+}
+// Handle findbar data (if any)
+let otherFindBar = aOtherTab._findBar;
+if (otherFindBar &&
+otherFindBar.findMode == otherFindBar.FIND_NORMAL) {
+let ourFindBar = this.getFindBar(aOurTab);
+ourFindBar._findField.value = otherFindBar._findField.value;
+if (!otherFindBar.hidden)
+ourFindBar.onFindCommand();
+}
+// Finish tearing down the tab that's going away.
+remoteBrowser._endRemoveTab(aOtherTab);
+if (isBusy)
+this.setTabTitleLoading(aOurTab);
+else
+this.setTabTitle(aOurTab);
+// If the tab was already selected (this happpens in the scenario
+// of replaceTabWithWindow), notify onLocationChange, etc.
+if (aOurTab.selected)
+this.updateCurrentBrowser(true);
+]]>
+</body>
+</method>
+<method name="_swapBrowserDocShells">
+<parameter name="aOurTab"/>
+<parameter name="aOtherBrowser"/>
+<body>
+<![CDATA[
+// Unhook our progress listener
+let index = aOurTab._tPos;
+const filter = this.mTabFilters[index];
+let tabListener = this.mTabListeners[index];
+let ourBrowser = this.getBrowserForTab(aOurTab);
+ourBrowser.webProgress.removeProgressListener(filter);
+filter.removeProgressListener(tabListener);
+// Make sure to unregister any open URIs.
+this._swapRegisteredOpenURIs(ourBrowser, aOtherBrowser);
+// Give others a chance to swap state.
+let event = new CustomEvent("SwapDocShells", {"detail": aOtherBrowser});
+ourBrowser.dispatchEvent(event);
+// Swap the docshells
+ourBrowser.swapDocShells(aOtherBrowser);
+// Restore the progress listener
+this.mTabListeners[index] = tabListener =
+this.mTabProgressListener(aOurTab, ourBrowser, false);
+const notifyAll = Ci.nsIWebProgress.NOTIFY_ALL;
+filter.addProgressListener(tabListener, notifyAll);
+ourBrowser.webProgress.addProgressListener(filter, notifyAll);
+]]>
+</body>
+</method>
+<method name="_swapRegisteredOpenURIs">
+<parameter name="aOurBrowser"/>
+<parameter name="aOtherBrowser"/>
+<body>
+<![CDATA[
+// If the current URI is registered as open remove it from the list.
+if (aOurBrowser.registeredOpenURI) {
+this._placesAutocomplete.unregisterOpenPage(aOurBrowser.registeredOpenURI);
+this._unifiedComplete.unregisterOpenPage(aOurBrowser.registeredOpenURI);
+delete aOurBrowser.registeredOpenURI;
+}
+// If the other/new URI is registered as open then copy it over.
+if (aOtherBrowser.registeredOpenURI) {
+aOurBrowser.registeredOpenURI = aOtherBrowser.registeredOpenURI;
+delete aOtherBrowser.registeredOpenURI;
+}
+]]>
+</body>
+</method>
+<method name="reloadAllTabs">
+<body>
+<![CDATA[
+let tabs = this.visibleTabs;
+let l = tabs.length;
+for (var i = 0; i < l; i++) {
+try {
+this.getBrowserForTab(tabs[i]).reload();
+} catch (e) {
+// ignore failure to reload so others will be reloaded
+}
+}
+]]>
+</body>
+</method>
+<method name="reloadTab">
+<parameter name="aTab"/>
+<body>
+<![CDATA[
+this.getBrowserForTab(aTab).reload();
+]]>
+</body>
+</method>
+<method name="addProgressListener">
+<parameter name="aListener"/>
+<body>
+<![CDATA[
+if (arguments.length != 1) {
+Components.utils.reportError("gBrowser.addProgressListener was " +
+"called with a second argument, " +
+"which is not supported. See bug " +
+"608628. Call stack: " + new Error().stack);
+}
+this.mProgressListeners.push(aListener);
+]]>
+</body>
+</method>
+<method name="removeProgressListener">
+<parameter name="aListener"/>
+<body>
+<![CDATA[
+this.mProgressListeners =
+this.mProgressListeners.filter(function (l) l != aListener);
+]]>
+</body>
+</method>
+<method name="addTabsProgressListener">
+<parameter name="aListener"/>
+<body>
+this.mTabsProgressListeners.push(aListener);
+</body>
+</method>
+<method name="removeTabsProgressListener">
+<parameter name="aListener"/>
+<body>
+<![CDATA[
+this.mTabsProgressListeners =
+this.mTabsProgressListeners.filter(function (l) l != aListener);
+]]>
+</body>
+</method>
+<method name="getBrowserForTab">
+<parameter name="aTab"/>
+<body>
+<![CDATA[
+return aTab.linkedBrowser;
+]]>
+</body>
+</method>
+<method name="showOnlyTheseTabs">
+<parameter name="aTabs"/>
+<body>
+<![CDATA[
+Array.forEach(this.tabs, function(tab) {
+if (aTabs.indexOf(tab) == -1)
+this.hideTab(tab);
+else
+this.showTab(tab);
+}, this);
+this.tabContainer._handleTabSelect(false);
+]]>
+</body>
+</method>
+<method name="showTab">
+<parameter name="aTab"/>
+<body>
+<![CDATA[
+if (aTab.hidden) {
+aTab.removeAttribute("hidden");
+this._visibleTabs = null; // invalidate cache
+this.tabContainer.adjustTabstrip();
+this.tabContainer._setPositionalAttributes();
+let event = document.createEvent("Events");
+event.initEvent("TabShow", true, false);
+aTab.dispatchEvent(event);
+}
+]]>
+</body>
+</method>
+<method name="hideTab">
+<parameter name="aTab"/>
+<body>
+<![CDATA[
+if (!aTab.hidden && !aTab.pinned && !aTab.selected &&
+!aTab.closing) {
+aTab.setAttribute("hidden", "true");
+this._visibleTabs = null; // invalidate cache
+this.tabContainer.adjustTabstrip();
+this.tabContainer._setPositionalAttributes();
+let event = document.createEvent("Events");
+event.initEvent("TabHide", true, false);
+aTab.dispatchEvent(event);
+}
+]]>
+</body>
+</method>
+<method name="selectTabAtIndex">
+<parameter name="aIndex"/>
+<parameter name="aEvent"/>
+<body>
+<![CDATA[
+let tabs = this.visibleTabs;
+// count backwards for aIndex < 0
+if (aIndex < 0)
+aIndex += tabs.length;
+if (aIndex >= 0 && aIndex < tabs.length)
+this.selectedTab = tabs[aIndex];
+if (aEvent) {
+aEvent.preventDefault();
+aEvent.stopPropagation();
+}
+]]>
+</body>
+</method>
+<property name="selectedTab">
+<getter>
+return this.mCurrentTab;
+</getter>
+<setter>
+<![CDATA[
+// Update the tab
+this.mTabBox.selectedTab = val;
+return val;
+]]>
+</setter>
+</property>
+<property name="selectedBrowser"
+onget="return this.mCurrentBrowser;"
+readonly="true"/>
+<property name="browsers" readonly="true">
+<getter>
+<![CDATA[
+return this._browsers ||
+(this._browsers = Array.map(this.tabs, function (tab) tab.linkedBrowser));
+]]>
+</getter>
+</property>
+<field name="_browsers">null</field>
+<!-- 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. -->
+<method name="replaceTabWithWindow">
+<parameter name="aTab"/>
+<parameter name="aOptions"/>
+<body>
+<![CDATA[
+if (this.tabs.length == 1)
+return null;
+let event = new CustomEvent("TabBecomingWindow", {
+bubbles: true,
+cancelable: true
+});
+aTab.dispatchEvent(event);
+if (event.defaultPrevented) {
+return null;
+}
+var options = "chrome,dialog=no,all";
+for (var name in aOptions)
+options += "," + name + "=" + aOptions[name];
+// tell a new window to take the "dropped" tab
+return window.openDialog(getBrowserURL(), "_blank", options, aTab);
+]]>
+</body>
+</method>
+<method name="moveTabTo">
+<parameter name="aTab"/>
+<parameter name="aIndex"/>
+<body>
+<![CDATA[
+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;
+this._lastRelatedTab = null;
+this.mTabFilters.splice(aIndex, 0, this.mTabFilters.splice(aTab._tPos, 1)[0]);
+this.mTabListeners.splice(aIndex, 0, this.mTabListeners.splice(aTab._tPos, 1)[0]);
+let wasFocused = (document.activeElement == this.mCurrentTab);
+aIndex = aIndex < aTab._tPos ? aIndex: aIndex+1;
+this.mCurrentTab._selected = false;
+// invalidate caches
+this._browsers = null;
+this._visibleTabs = null;
+// use .item() instead of [] because dragging to the end of the strip goes out of
+// bounds: .item() returns null (so it acts like appendChild), but [] throws
+this.tabContainer.insertBefore(aTab, this.tabs.item(aIndex));
+for (let i = 0; i < this.tabs.length; i++) {
+this.tabs[i]._tPos = i;
+this.tabs[i]._selected = false;
+}
+this.mCurrentTab._selected = true;
+if (wasFocused)
+this.mCurrentTab.focus();
+this.tabContainer._handleTabSelect(false);
+if (aTab.pinned)
+this.tabContainer._positionPinnedTabs();
+this.tabContainer._setPositionalAttributes();
+var evt = document.createEvent("UIEvents");
+evt.initUIEvent("TabMove", true, false, window, oldPosition);
+aTab.dispatchEvent(evt);
+]]>
+</body>
+</method>
+<method name="moveTabForward">
+<body>
+<![CDATA[
+let nextTab = this.mCurrentTab.nextSibling;
+while (nextTab && nextTab.hidden)
+nextTab = nextTab.nextSibling;
+if (nextTab)
+this.moveTabTo(this.mCurrentTab, nextTab._tPos);
+else if (this.arrowKeysShouldWrap)
+this.moveTabToStart();
+]]>
+</body>
+</method>
+<method name="moveTabBackward">
+<body>
+<![CDATA[
+let previousTab = this.mCurrentTab.previousSibling;
+while (previousTab && previousTab.hidden)
+previousTab = previousTab.previousSibling;
+if (previousTab)
+this.moveTabTo(this.mCurrentTab, previousTab._tPos);
+else if (this.arrowKeysShouldWrap)
+this.moveTabToEnd();
+]]>
+</body>
+</method>
+<method name="moveTabToStart">
+<body>
+<![CDATA[
+var tabPos = this.mCurrentTab._tPos;
+if (tabPos > 0)
+this.moveTabTo(this.mCurrentTab, 0);
+]]>
+</body>
+</method>
+<method name="moveTabToEnd">
+<body>
+<![CDATA[
+var tabPos = this.mCurrentTab._tPos;
+if (tabPos < this.browsers.length - 1)
+this.moveTabTo(this.mCurrentTab, this.browsers.length - 1);
+]]>
+</body>
+</method>
+<method name="moveTabOver">
+<parameter name="aEvent"/>
+<body>
+<![CDATA[
+var direction = window.getComputedStyle(this.parentNode, null).direction;
+if ((direction == "ltr" && aEvent.keyCode == KeyEvent.DOM_VK_RIGHT) ||
+(direction == "rtl" && aEvent.keyCode == KeyEvent.DOM_VK_LEFT))
+this.moveTabForward();
+else
+this.moveTabBackward();
+]]>
+</body>
+</method>
+<method name="duplicateTab">
+<parameter name="aTab"/><!-- can be from a different window as well -->
+<body>
+<![CDATA[
+return SessionStore.duplicateTab(window, aTab);
+]]>
+</body>
+</method>
+<!-- BEGIN FORWARDED BROWSER PROPERTIES.  IF YOU ADD A PROPERTY TO THE BROWSER ELEMENT
+MAKE SURE TO ADD IT HERE AS WELL. -->
+<property name="canGoBack"
+onget="return this.mCurrentBrowser.canGoBack;"
+readonly="true"/>
+<property name="canGoForward"
+onget="return this.mCurrentBrowser.canGoForward;"
+readonly="true"/>
+<method name="goBack">
+<body>
+<![CDATA[
+return this.mCurrentBrowser.goBack();
+]]>
+</body>
+</method>
+<method name="goForward">
+<body>
+<![CDATA[
+return this.mCurrentBrowser.goForward();
+]]>
+</body>
+</method>
+<method name="reload">
+<body>
+<![CDATA[
+return this.mCurrentBrowser.reload();
+]]>
+</body>
+</method>
+<method name="reloadWithFlags">
+<parameter name="aFlags"/>
+<body>
+<![CDATA[
+return this.mCurrentBrowser.reloadWithFlags(aFlags);
+]]>
+</body>
+</method>
+<method name="stop">
+<body>
+<![CDATA[
+return this.mCurrentBrowser.stop();
+]]>
+</body>
+</method>
+<!-- throws exception for unknown schemes -->
+<method name="loadURI">
+<parameter name="aURI"/>
+<parameter name="aReferrerURI"/>
+<parameter name="aCharset"/>
+<body>
+<![CDATA[
+#ifdef MAKE_E10S_WORK
+this.updateBrowserRemoteness(this.mCurrentBrowser, aURI);
+try {
+#endif
+return this.mCurrentBrowser.loadURI(aURI, aReferrerURI, aCharset);
+#ifdef MAKE_E10S_WORK
+} catch (e) {
+let url = this.mCurrentBrowser.currentURI.spec;
+this.updateBrowserRemoteness(this.mCurrentBrowser, url);
+throw e;
+}
+#endif
+]]>
+</body>
+</method>
+<!-- throws exception for unknown schemes -->
+<method name="loadURIWithFlags">
+<parameter name="aURI"/>
+<parameter name="aFlags"/>
+<parameter name="aReferrerURI"/>
+<parameter name="aCharset"/>
+<parameter name="aPostData"/>
+<body>
+<![CDATA[
+#ifdef MAKE_E10S_WORK
+this.updateBrowserRemoteness(this.mCurrentBrowser, aURI);
+try {
+#endif
+return this.mCurrentBrowser.loadURIWithFlags(aURI, aFlags, aReferrerURI, aCharset, aPostData);
+#ifdef MAKE_E10S_WORK
+} catch (e) {
+let url = this.mCurrentBrowser.currentURI.spec;
+this.updateBrowserRemoteness(this.mCurrentBrowser, url);
+throw e;
+}
+#endif
+]]>
+</body>
+</method>
+<method name="goHome">
+<body>
+<![CDATA[
+return this.mCurrentBrowser.goHome();
+]]>
+</body>
+</method>
+<property name="homePage">
+<getter>
+<![CDATA[
+return this.mCurrentBrowser.homePage;
+]]>
+</getter>
+<setter>
+<![CDATA[
+this.mCurrentBrowser.homePage = val;
+return val;
+]]>
+</setter>
+</property>
+<method name="gotoIndex">
+<parameter name="aIndex"/>
+<body>
+<![CDATA[
+return this.mCurrentBrowser.gotoIndex(aIndex);
+]]>
+</body>
+</method>
+<method name="attachFormFill">
+<body><![CDATA[
+for (var i = 0; i < this.mPanelContainer.childNodes.length; ++i) {
+var cb = this.getBrowserAtIndex(i);
+cb.attachFormFill();
+}
+]]></body>
+</method>
+<method name="detachFormFill">
+<body><![CDATA[
+for (var i = 0; i < this.mPanelContainer.childNodes.length; ++i) {
+var cb = this.getBrowserAtIndex(i);
+cb.detachFormFill();
+}
+]]></body>
+</method>
+<property name="currentURI"
+onget="return this.mCurrentBrowser.currentURI;"
+readonly="true"/>
+<property name="finder"
+onget="return this.mCurrentBrowser.finder"
+readonly="true"/>
+<property name="docShell"
+onget="return this.mCurrentBrowser.docShell"
+readonly="true"/>
+<property name="webNavigation"
+onget="return this.mCurrentBrowser.webNavigation"
+readonly="true"/>
+<property name="webBrowserFind"
+readonly="true"
+onget="return this.mCurrentBrowser.webBrowserFind"/>
+<property name="webProgress"
+readonly="true"
+onget="return this.mCurrentBrowser.webProgress"/>
+<property name="contentWindow"
+readonly="true"
+onget="return this.mCurrentBrowser.contentWindow"/>
+<property name="sessionHistory"
+onget="return this.mCurrentBrowser.sessionHistory;"
+readonly="true"/>
+<property name="markupDocumentViewer"
+onget="return this.mCurrentBrowser.markupDocumentViewer;"
+readonly="true"/>
+<property name="contentViewerEdit"
+onget="return this.mCurrentBrowser.contentViewerEdit;"
+readonly="true"/>
+<property name="contentViewerFile"
+onget="return this.mCurrentBrowser.contentViewerFile;"
+readonly="true"/>
+<property name="contentDocument"
+onget="return this.mCurrentBrowser.contentDocument;"
+readonly="true"/>
+<property name="contentTitle"
+onget="return this.mCurrentBrowser.contentTitle;"
+readonly="true"/>
+<property name="contentPrincipal"
+onget="return this.mCurrentBrowser.contentPrincipal;"
+readonly="true"/>
+<property name="securityUI"
+onget="return this.mCurrentBrowser.securityUI;"
+readonly="true"/>
+<property name="fullZoom"
+onget="return this.mCurrentBrowser.fullZoom;"
+onset="this.mCurrentBrowser.fullZoom = val;"/>
+<property name="textZoom"
+onget="return this.mCurrentBrowser.textZoom;"
+onset="this.mCurrentBrowser.textZoom = val;"/>
+<property name="isSyntheticDocument"
+onget="return this.mCurrentBrowser.isSyntheticDocument;"
+readonly="true"/>
+<method name="_handleKeyEvent">
+<parameter name="aEvent"/>
+<body><![CDATA[
+if (!aEvent.isTrusted) {
+// Don't let untrusted events mess with tabs.
+return;
+}
+if (aEvent.altKey)
+return;
+if (aEvent.ctrlKey && aEvent.shiftKey && !aEvent.metaKey) {
+switch (aEvent.keyCode) {
+case aEvent.DOM_VK_PAGE_UP:
+this.moveTabBackward();
+aEvent.stopPropagation();
+aEvent.preventDefault();
+return;
+case aEvent.DOM_VK_PAGE_DOWN:
+this.moveTabForward();
+aEvent.stopPropagation();
+aEvent.preventDefault();
+return;
+}
+}
+// We need to take care of FAYT-watching as long as the findbar
+// isn't initialized.  The checks on aEvent are copied from
+// _shouldFastFind (see findbar.xml).
+if (!gFindBarInitialized &&
+!(aEvent.ctrlKey || aEvent.metaKey) &&
+!aEvent.defaultPrevented) {
+let charCode = aEvent.charCode;
+if (charCode) {
+let char = String.fromCharCode(charCode);
+if (char == "'" || char == "/" ||
+Services.prefs.getBoolPref("accessibility.typeaheadfind")) {
+gFindBar._onBrowserKeypress(aEvent);
+return;
+}
+}
+}
+#ifdef XP_MACOSX
+if (!aEvent.metaKey)
+return;
+var offset = 1;
+switch (aEvent.charCode) {
+case '}'.charCodeAt(0):
+offset = -1;
+case '{'.charCodeAt(0):
+if (window.getComputedStyle(this, null).direction == "ltr")
+offset *= -1;
+this.tabContainer.advanceSelectedTab(offset, true);
+aEvent.stopPropagation();
+aEvent.preventDefault();
+}
+#else
+if (aEvent.ctrlKey && !aEvent.shiftKey && !aEvent.metaKey &&
+aEvent.keyCode == KeyEvent.DOM_VK_F4 &&
+!this.mCurrentTab.pinned) {
+this.removeCurrentTab({animate: true});
+aEvent.stopPropagation();
+aEvent.preventDefault();
+}
+#endif
+]]></body>
+</method>
+<property name="userTypedClear"
+onget="return this.mCurrentBrowser.userTypedClear;"
+onset="return this.mCurrentBrowser.userTypedClear = val;"/>
+<property name="userTypedValue"
+onget="return this.mCurrentBrowser.userTypedValue;"
+onset="return this.mCurrentBrowser.userTypedValue = val;"/>
+<method name="createTooltip">
+<parameter name="event"/>
+<body><![CDATA[
+event.stopPropagation();
+var tab = document.tooltipNode;
+if (tab.localName != "tab") {
+event.preventDefault();
+return;
+}
+event.target.setAttribute("label", tab.mOverCloseButton ?
+tab.getAttribute("closetabtext") :
+tab.getAttribute("label"));
+]]></body>
+</method>
+<method name="handleEvent">
+<parameter name="aEvent"/>
+<body><![CDATA[
+switch (aEvent.type) {
+case "keypress":
+this._handleKeyEvent(aEvent);
+break;
+case "sizemodechange":
+if (aEvent.target == window) {
+this.mCurrentBrowser.docShellIsActive =
+(window.windowState != window.STATE_MINIMIZED);
+}
+break;
+}
+]]></body>
+</method>
+<method name="receiveMessage">
+<parameter name="aMessage"/>
+<body><![CDATA[
+let json = aMessage.json;
+let browser = aMessage.target;
+switch (aMessage.name) {
+case "DOMTitleChanged": {
+let tab = this._getTabForBrowser(browser);
+if (!tab || tab.hasAttribute("pending"))
+return;
+let titleChanged = this.setTabTitle(tab);
+if (titleChanged && !tab.selected && !tab.hasAttribute("busy"))
+tab.setAttribute("titlechanged", "true");
+break;
+}
+case "DOMWindowClose": {
+if (this.tabs.length == 1) {
+window.close();
+return;
+}
+let tab = this._getTabForBrowser(browser);
+if (tab) {
+this.removeTab(tab);
+}
+break;
+}
+case "contextmenu": {
+gContextMenuContentData = { event: aMessage.objects.event,
+browser: browser };
+let popup = browser.ownerDocument.getElementById("contentAreaContextMenu");
+let event = gContextMenuContentData.event;
+let pos = browser.mapScreenCoordinatesFromContent(event.screenX, event.screenY);
+popup.openPopupAtScreen(pos.x, pos.y, true);
+break;
+}
+case "DOMWebNotificationClicked": {
+let tab = this._getTabForBrowser(browser);
+if (!tab)
+return;
+this.selectedTab = tab;
+window.focus();
+break;
+}
+}
+]]></body>
+</method>
+<constructor>
+<![CDATA[
+let browserStack = document.getAnonymousElementByAttribute(this, "anonid", "browserStack");
+this.mCurrentBrowser = document.getAnonymousElementByAttribute(this, "anonid", "initialBrowser");
+this.mCurrentTab = this.tabContainer.firstChild;
+document.addEventListener("keypress", this, false);
+window.addEventListener("sizemodechange", this, false);
+var uniqueId = this._generateUniquePanelID();
+this.mPanelContainer.childNodes[0].id = uniqueId;
+this.mCurrentTab.linkedPanel = uniqueId;
+this.mCurrentTab._tPos = 0;
+this.mCurrentTab._fullyOpen = true;
+this.mCurrentTab.linkedBrowser = this.mCurrentBrowser;
+// set up the shared autoscroll popup
+this._autoScrollPopup = this.mCurrentBrowser._createAutoScrollPopup();
+this._autoScrollPopup.id = "autoscroller";
+this.appendChild(this._autoScrollPopup);
+this.mCurrentBrowser.setAttribute("autoscrollpopup", this._autoScrollPopup.id);
+this.mCurrentBrowser.droppedLinkHandler = handleDroppedLink;
+this.updateWindowResizers();
+// Hook up the event listeners to the first browser
+var tabListener = this.mTabProgressListener(this.mCurrentTab, this.mCurrentBrowser, true);
+const nsIWebProgress = Components.interfaces.nsIWebProgress;
+const filter = Components.classes["@mozilla.org/appshell/component/browser-status-filter;1"]
+.createInstance(nsIWebProgress);
+filter.addProgressListener(tabListener, nsIWebProgress.NOTIFY_ALL);
+this.mTabListeners[0] = tabListener;
+this.mTabFilters[0] = filter;
+this.webProgress.addProgressListener(filter, nsIWebProgress.NOTIFY_ALL);
+this.style.backgroundColor =
+Services.prefs.getBoolPref("browser.display.use_system_colors") ?
+"-moz-default-background-color" :
+Services.prefs.getCharPref("browser.display.background_color");
+let remote = window.QueryInterface(Ci.nsIInterfaceRequestor)
+.getInterface(Ci.nsIWebNavigation)
+.QueryInterface(Ci.nsILoadContext)
+.useRemoteTabs;
+if (remote) {
+messageManager.addMessageListener("DOMTitleChanged", this);
+messageManager.addMessageListener("DOMWindowClose", this);
+messageManager.addMessageListener("contextmenu", this);
+}
+messageManager.addMessageListener("DOMWebNotificationClicked", this);
+]]>
+</constructor>
+<method name="_generateUniquePanelID">
+<body><![CDATA[
+if (!this._uniquePanelIDCounter) {
+this._uniquePanelIDCounter = 0;
+}
+let outerID = window.QueryInterface(Ci.nsIInterfaceRequestor)
+.getInterface(Ci.nsIDOMWindowUtils)
+.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);
+]]></body>
+</method>
+<destructor>
+<![CDATA[
+for (var i = 0; i < this.mTabListeners.length; ++i) {
+let browser = this.getBrowserAtIndex(i);
+if (browser.registeredOpenURI) {
+this._placesAutocomplete.unregisterOpenPage(browser.registeredOpenURI);
+this._unifiedComplete.unregisterOpenPage(browser.registeredOpenURI);
+delete browser.registeredOpenURI;
+}
+browser.webProgress.removeProgressListener(this.mTabFilters[i]);
+this.mTabFilters[i].removeProgressListener(this.mTabListeners[i]);
+this.mTabFilters[i] = null;
+this.mTabListeners[i].destroy();
+this.mTabListeners[i] = null;
+}
+document.removeEventListener("keypress", this, false);
+window.removeEventListener("sizemodechange", this, false);
+if (gMultiProcessBrowser) {
+messageManager.removeMessageListener("DOMTitleChanged", this);
+messageManager.removeMessageListener("contextmenu", this);
+}
+]]>
+</destructor>
+<!-- Deprecated stuff, implemented for backwards compatibility. -->
+<method name="enterTabbedMode">
+<body>
+Application.console.log("enterTabbedMode is an obsolete method and " +
+"will be removed in a future release.");
+</body>
+</method>
+<field name="mTabbedMode" readonly="true">true</field>
+<method name="setStripVisibilityTo">
+<parameter name="aShow"/>
+<body>
+this.tabContainer.visible = aShow;
+</body>
+</method>
+<method name="getStripVisibility">
+<body>
+return this.tabContainer.visible;
+</body>
+</method>
+<property name="mContextTab" readonly="true"
+onget="return TabContextMenu.contextTab;"/>
+<property name="mPrefs" readonly="true"
+onget="return Services.prefs;"/>
+<property name="mTabContainer" readonly="true"
+onget="return this.tabContainer;"/>
+<property name="mTabs" readonly="true"
+onget="return this.tabs;"/>
+<!--
+- Compatibility hack: several extensions depend on this property to
+- access the tab context menu or tab container, so keep that working for
+- now. Ideally we can remove this once extensions are using
+- tabbrowser.tabContextMenu and tabbrowser.tabContainer directly.
+-->
+<property name="mStrip" readonly="true">
+<getter>
+<![CDATA[
+return ({
+self: this,
+childNodes: [null, this.tabContextMenu, this.tabContainer],
+firstChild: { nextSibling: this.tabContextMenu },
+getElementsByAttribute: function (attr, attrValue) {
+if (attr == "anonid" && attrValue == "tabContextMenu")
+return [this.self.tabContextMenu];
+return [];
+},
+// Also support adding event listeners (forward to the tab container)
+addEventListener: function (a,b,c) { this.self.tabContainer.addEventListener(a,b,c); },
+removeEventListener: function (a,b,c) { this.self.tabContainer.removeEventListener(a,b,c); }
+});
+]]>
+</getter>
+</property>
+</implementation>
+<handlers>
+<handler event="DOMWindowClose" phase="capturing">
+<![CDATA[
+if (!event.isTrusted)
+return;
+if (this.tabs.length == 1)
+return;
+var tab = this._getTabForContentWindow(event.target);
+if (tab) {
+this.removeTab(tab);
+event.preventDefault();
+}
+]]>
+</handler>
+<handler event="DOMWillOpenModalDialog" phase="capturing">
+<![CDATA[
+if (!event.isTrusted)
+return;
+// We're about to open a modal dialog, make sure the opening
+// tab is brought to the front.
+// 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.
+// XXX Why originalTarget for the browser?
+this.selectedTab = (event.target instanceof Window) ?
+this._getTabForContentWindow(event.target.top) :
+this._getTabForBrowser(event.originalTarget);
+]]>
+</handler>
+<handler event="DOMTitleChanged">
+<![CDATA[
+if (!event.isTrusted)
+return;
+var contentWin = event.target.defaultView;
+if (contentWin != contentWin.top)
+return;
+var tab = this._getTabForContentWindow(contentWin);
+if (tab.hasAttribute("pending"))
+return;
+var titleChanged = this.setTabTitle(tab);
+if (titleChanged && !tab.selected && !tab.hasAttribute("busy"))
+tab.setAttribute("titlechanged", "true");
+]]>
+</handler>
+<handler event="oop-browser-crashed">
+<![CDATA[
+if (!event.isTrusted)
+return;
+let browser = event.originalTarget;
+let title = browser.contentTitle;
+let uri = browser.currentURI;
+let icon = browser.mIconURL;
+this.updateBrowserRemoteness(browser, "about:tabcrashed");
+browser.setAttribute("crashedPageTitle", title);
+browser.docShell.displayLoadError(Cr.NS_ERROR_CONTENT_CRASHED, uri, null);
+browser.removeAttribute("crashedPageTitle");
+let tab = this._getTabForBrowser(browser);
+this.setIcon(tab, icon);
+]]>
+</handler>
+</handlers>
+</binding>
+<binding id="tabbrowser-tabbox"
+extends="chrome://global/content/bindings/tabbox.xml#tabbox">
+<implementation>
+<property name="tabs" readonly="true"
+onget="return document.getBindingParent(this).tabContainer;"/>
+</implementation>
+</binding>
+<binding id="tabbrowser-arrowscrollbox" extends="chrome://global/content/bindings/scrollbox.xml#arrowscrollbox-clicktoscroll">
+<implementation>
+<!-- Override scrollbox.xml method, since our scrollbox's children are
+inherited from the binding parent -->
+<method name="_getScrollableElements">
+<body><![CDATA[
+return Array.filter(document.getBindingParent(this).childNodes,
+this._canScrollToElement, this);
+]]></body>
+</method>
+<method name="_canScrollToElement">
+<parameter name="tab"/>
+<body><![CDATA[
+return !tab.pinned && !tab.hidden;
+]]></body>
+</method>
+<field name="_tabMarginLeft">null</field>
+<field name="_tabMarginRight">null</field>
+<method name="_calcTabMargins">
+<parameter name="aTab"/>
+<body><![CDATA[
+if (this._tabMarginLeft === null || this._tabMarginRight === null) {
+let tabMiddle = document.getAnonymousElementByAttribute(aTab, "class", "tab-background-middle");
+let tabMiddleStyle = window.getComputedStyle(tabMiddle, null);
+this._tabMarginLeft = parseFloat(tabMiddleStyle.marginLeft);
+this._tabMarginRight = parseFloat(tabMiddleStyle.marginRight);
+}
+]]></body>
+</method>
+<method name="_adjustElementStartAndEnd">
+<parameter name="aTab"/>
+<parameter name="tabStart"/>
+<parameter name="tabEnd"/>
+<body><![CDATA[
+this._calcTabMargins(aTab);
+if (this._tabMarginLeft < 0) {
+tabStart = tabStart + this._tabMarginLeft;
+}
+if (this._tabMarginRight < 0) {
+tabEnd = tabEnd - this._tabMarginRight;
+}
+return [tabStart, tabEnd];
+]]></body>
+</method>
+</implementation>
+<handlers>
+<handler event="underflow" phase="capturing"><![CDATA[
+if (event.detail == 0)
+return; // Ignore vertical events
+var tabs = document.getBindingParent(this);
+tabs.removeAttribute("overflow");
+if (tabs._lastTabClosedByMouse)
+tabs._expandSpacerBy(this._scrollButtonDown.clientWidth);
+tabs.tabbrowser._removingTabs.forEach(tabs.tabbrowser.removeTab,
+tabs.tabbrowser);
+tabs._positionPinnedTabs();
+]]></handler>
+<handler event="overflow"><![CDATA[
+if (event.detail == 0)
+return; // Ignore vertical events
+var tabs = document.getBindingParent(this);
+var numberOfTabs = tabs.tabbrowser.visibleTabs.length;
+if (numberOfTabs == 1)
+return;
+tabs.setAttribute("overflow", "true");
+tabs._positionPinnedTabs();
+tabs._handleTabSelect(false);
+]]></handler>
+</handlers>
+</binding>
+<binding id="tabbrowser-tabs"
+extends="chrome://global/content/bindings/tabbox.xml#tabs">
+<resources>
+<stylesheet src="chrome://browser/content/tabbrowser.css"/>
+</resources>
+<content>
+<xul:hbox align="end">
+<xul:image class="tab-drop-indicator" anonid="tab-drop-indicator" collapsed="true"/>
+</xul:hbox>
+<xul:arrowscrollbox anonid="arrowscrollbox" orient="horizontal" flex="1"
+style="min-width: 1px;"
+#ifndef XP_MACOSX
+clicktoscroll="true"
+#endif
+class="tabbrowser-arrowscrollbox">
+# This is a hack to circumvent bug 472020, otherwise the tabs show up on the
+# right of the newtab button.
+<children includes="tab"/>
+# This is to ensure anything extensions put here will go before the newtab
+# button, necessary due to the previous hack.
+<children/>
+<xul:toolbarbutton class="tabs-newtab-button"
+command="cmd_newNavigatorTab"
+onclick="checkForMiddleClick(this, event);"
+onmouseover="document.getBindingParent(this)._enterNewTab();"
+onmouseout="document.getBindingParent(this)._leaveNewTab();"
+tooltiptext="&newTabButton.tooltip;"/>
+<xul:spacer class="closing-tabs-spacer" anonid="closing-tabs-spacer"
+style="width: 0;"/>
+</xul:arrowscrollbox>
+</content>
+<implementation implements="nsIDOMEventListener">
+<constructor>
+<![CDATA[
+this.mTabClipWidth = Services.prefs.getIntPref("browser.tabs.tabClipWidth");
+var tab = this.firstChild;
+tab.label = this.tabbrowser.mStringBundle.getString("tabs.emptyTabTitle");
+tab.setAttribute("crop", "end");
+tab.setAttribute("onerror", "this.removeAttribute('image');");
+window.addEventListener("resize", this, false);
+window.addEventListener("load", this, false);
+try {
+this._tabAnimationLoggingEnabled = Services.prefs.getBoolPref("browser.tabs.animationLogging.enabled");
+} catch (ex) {
+this._tabAnimationLoggingEnabled = false;
+}
+this._browserNewtabpageEnabled = Services.prefs.getBoolPref("browser.newtabpage.enabled");
+]]>
+</constructor>
+<field name="tabbrowser" readonly="true">
+document.getElementById(this.getAttribute("tabbrowser"));
+</field>
+<field name="tabbox" readonly="true">
+this.tabbrowser.mTabBox;
+</field>
+<field name="contextMenu" readonly="true">
+document.getElementById("tabContextMenu");
+</field>
+<field name="mTabstripWidth">0</field>
+<field name="mTabstrip">
+document.getAnonymousElementByAttribute(this, "anonid", "arrowscrollbox");
+</field>
+<field name="_firstTab">null</field>
+<field name="_lastTab">null</field>
+<field name="_afterSelectedTab">null</field>
+<field name="_beforeHoveredTab">null</field>
+<field name="_afterHoveredTab">null</field>
+<field name="_hoveredTab">null</field>
+<property name="_isCustomizing" readonly="true">
+<getter>
+let root = document.documentElement;
+return root.getAttribute("customizing") == "true" ||
+root.getAttribute("customize-exiting") == "true";
+</getter>
+</property>
+<method name="_setPositionalAttributes">
+<body><![CDATA[
+let visibleTabs = this.tabbrowser.visibleTabs;
+if (!visibleTabs.length)
+return;
+let selectedIndex = visibleTabs.indexOf(this.selectedItem);
+let lastVisible = visibleTabs.length - 1;
+if (this._afterSelectedTab)
+this._afterSelectedTab.removeAttribute("afterselected-visible");
+if (this.selectedItem.closing || selectedIndex == lastVisible) {
+this._afterSelectedTab = null;
+} else {
+this._afterSelectedTab = visibleTabs[selectedIndex + 1];
+this._afterSelectedTab.setAttribute("afterselected-visible",
+"true");
+}
+if (this._firstTab)
+this._firstTab.removeAttribute("first-visible-tab");
+this._firstTab = visibleTabs[0];
+this._firstTab.setAttribute("first-visible-tab", "true");
+if (this._lastTab)
+this._lastTab.removeAttribute("last-visible-tab");
+this._lastTab = visibleTabs[lastVisible];
+this._lastTab.setAttribute("last-visible-tab", "true");
+let hoveredTab = this._hoveredTab;
+if (hoveredTab) {
+hoveredTab._mouseleave();
+hoveredTab._mouseenter();
+}
+]]></body>
+</method>
+<field name="_blockDblClick">false</field>
+<field name="_tabDropIndicator">
+document.getAnonymousElementByAttribute(this, "anonid", "tab-drop-indicator");
+</field>
+<field name="_dragOverDelay">350</field>
+<field name="_dragTime">0</field>
+<field name="_container" readonly="true"><![CDATA[
+this.parentNode && this.parentNode.localName == "toolbar" ? this.parentNode : this;
+]]></field>
+<field name="_propagatedVisibilityOnce">false</field>
+<property name="visible"
+onget="return !this._container.collapsed;">
+<setter><![CDATA[
+if (val == this.visible &&
+this._propagatedVisibilityOnce)
+return val;
+this._container.collapsed = !val;
+this._propagateVisibility();
+this._propagatedVisibilityOnce = true;
+return val;
+]]></setter>
+</property>
+<method name="_enterNewTab">
+<body><![CDATA[
+let visibleTabs = this.tabbrowser.visibleTabs;
+let candidate = visibleTabs[visibleTabs.length - 1];
+if (!candidate.selected) {
+this._beforeHoveredTab = candidate;
+candidate.setAttribute("beforehovered", "true");
+}
+]]></body>
+</method>
+<method name="_leaveNewTab">
+<body><![CDATA[
+if (this._beforeHoveredTab) {
+this._beforeHoveredTab.removeAttribute("beforehovered");
+this._beforeHoveredTab = null;
+}
+]]></body>
+</method>
+<method name="_propagateVisibility">
+<body><![CDATA[
+let visible = this.visible;
+document.getElementById("menu_closeWindow").hidden = !visible;
+document.getElementById("menu_close").setAttribute("label",
+this.tabbrowser.mStringBundle.getString(visible ? "tabs.closeTab" : "tabs.close"));
+TabsInTitlebar.allowedBy("tabs-visible", visible);
+]]></body>
+</method>
+<method name="updateVisibility">
+<body><![CDATA[
+if (this.childNodes.length - this.tabbrowser._removingTabs.length == 1)
+this.visible = window.toolbar.visible;
+else
+this.visible = true;
+]]></body>
+</method>
+<method name="adjustTabstrip">
+<body><![CDATA[
+let numTabs = this.childNodes.length -
+this.tabbrowser._removingTabs.length;
+if (numTabs > 2) {
+// This is an optimization to avoid layout flushes by calling
+// getBoundingClientRect() when we just opened a second tab. In
+// this case it's highly unlikely that the tab width is smaller
+// than mTabClipWidth and the tab close button obscures too much
+// of the tab's label. In the edge case of the window being too
+// narrow (or if tabClipWidth has been set to a way higher value),
+// we'll correct the 'closebuttons' attribute after the tabopen
+// animation has finished.
+let tab = this.tabbrowser.visibleTabs[this.tabbrowser._numPinnedTabs];
+if (tab && tab.getBoundingClientRect().width <= this.mTabClipWidth) {
+this.setAttribute("closebuttons", "activetab");
+return;
+}
+}
+this.removeAttribute("closebuttons");
+]]></body>
+</method>
+<method name="_handleTabSelect">
+<parameter name="aSmoothScroll"/>
+<body><![CDATA[
+if (this.getAttribute("overflow") == "true")
+this.mTabstrip.ensureElementIsVisible(this.selectedItem, aSmoothScroll);
+]]></body>
+</method>
+<method name="_fillTrailingGap">
+<body><![CDATA[
+try {
+// if we're at the right side (and not the logical end,
+// which is why this works for both LTR and RTL)
+// of the tabstrip, we need to ensure that we stay
+// completely scrolled to the right side
+var tabStrip = this.mTabstrip;
+if (tabStrip.scrollPosition + tabStrip.scrollClientSize >
+tabStrip.scrollSize)
+tabStrip.scrollByPixels(-1);
+} catch (e) {}
+]]></body>
+</method>
+<field name="_closingTabsSpacer">
+document.getAnonymousElementByAttribute(this, "anonid", "closing-tabs-spacer");
+</field>
+<field name="_tabDefaultMaxWidth">NaN</field>
+<field name="_lastTabClosedByMouse">false</field>
+<field name="_hasTabTempMaxWidth">false</field>
+<!-- Try to keep the active tab's close button under the mouse cursor -->
+<method name="_lockTabSizing">
+<parameter name="aTab"/>
+<body><![CDATA[
+var tabs = this.tabbrowser.visibleTabs;
+if (!tabs.length)
+return;
+var isEndTab = (aTab._tPos > tabs[tabs.length-1]._tPos);
+var tabWidth = aTab.getBoundingClientRect().width;
+if (!this._tabDefaultMaxWidth)
+this._tabDefaultMaxWidth =
+parseFloat(window.getComputedStyle(aTab).maxWidth);
+this._lastTabClosedByMouse = true;
+if (this.getAttribute("overflow") == "true") {
+// Don't need to do anything if we're in overflow mode and aren't scrolled
+// all the way to the right, or if we're closing the last tab.
+if (isEndTab || !this.mTabstrip._scrollButtonDown.disabled)
+return;
+// If the tab has an owner that will become the active tab, the owner will
+// be to the left of it, so we actually want the left tab to slide over.
+// This can't be done as easily in non-overflow mode, so we don't bother.
+if (aTab.owner)
+return;
+this._expandSpacerBy(tabWidth);
+} else { // non-overflow mode
+// Locking is neither in effect nor needed, so let tabs expand normally.
+if (isEndTab && !this._hasTabTempMaxWidth)
+return;
+let numPinned = this.tabbrowser._numPinnedTabs;
+// Force tabs to stay the same width, unless we're closing the last tab,
+// which case we need to let them expand just enough so that the overall
+// tabbar width is the same.
+if (isEndTab) {
+let numNormalTabs = tabs.length - numPinned;
+tabWidth = tabWidth * (numNormalTabs + 1) / numNormalTabs;
+if (tabWidth > this._tabDefaultMaxWidth)
+tabWidth = this._tabDefaultMaxWidth;
+}
+tabWidth += "px";
+for (let i = numPinned; i < tabs.length; i++) {
+let tab = tabs[i];
+tab.style.setProperty("max-width", tabWidth, "important");
+if (!isEndTab) { // keep tabs the same width
+tab.style.transition = "none";
+tab.clientTop; // flush styles to skip animation; see bug 649247
+tab.style.transition = "";
+}
+}
+this._hasTabTempMaxWidth = true;
+this.tabbrowser.addEventListener("mousemove", this, false);
+window.addEventListener("mouseout", this, false);
+}
+]]></body>
+</method>
+<method name="_expandSpacerBy">
+<parameter name="pixels"/>
+<body><![CDATA[
+let spacer = this._closingTabsSpacer;
+spacer.style.width = parseFloat(spacer.style.width) + pixels + "px";
+this.setAttribute("using-closing-tabs-spacer", "true");
+this.tabbrowser.addEventListener("mousemove", this, false);
+window.addEventListener("mouseout", this, false);
+]]></body>
+</method>
+<method name="_unlockTabSizing">
+<body><![CDATA[
+this.tabbrowser.removeEventListener("mousemove", this, false);
+window.removeEventListener("mouseout", this, false);
+if (this._hasTabTempMaxWidth) {
+this._hasTabTempMaxWidth = false;
+let tabs = this.tabbrowser.visibleTabs;
+for (let i = 0; i < tabs.length; i++)
+tabs[i].style.maxWidth = "";
+}
+if (this.hasAttribute("using-closing-tabs-spacer")) {
+this.removeAttribute("using-closing-tabs-spacer");
+this._closingTabsSpacer.style.width = 0;
+}
+]]></body>
+</method>
+<field name="_lastNumPinned">0</field>
+<method name="_positionPinnedTabs">
+<body><![CDATA[
+var numPinned = this.tabbrowser._numPinnedTabs;
+var doPosition = this.getAttribute("overflow") == "true" &&
+numPinned > 0;
+if (doPosition) {
+this.setAttribute("positionpinnedtabs", "true");
+let scrollButtonWidth = this.mTabstrip._scrollButtonDown.getBoundingClientRect().width;
+let paddingStart = this.mTabstrip.scrollboxPaddingStart;
+let width = 0;
+for (let i = numPinned - 1; i >= 0; i--) {
+let tab = this.childNodes[i];
+width += tab.getBoundingClientRect().width;
+tab.style.MozMarginStart = - (width + scrollButtonWidth + paddingStart) + "px";
+}
+this.style.MozPaddingStart = width + paddingStart + "px";
+} else {
+this.removeAttribute("positionpinnedtabs");
+for (let i = 0; i < numPinned; i++) {
+let tab = this.childNodes[i];
+tab.style.MozMarginStart = "";
+}
+this.style.MozPaddingStart = "";
+}
+if (this._lastNumPinned != numPinned) {
+this._lastNumPinned = numPinned;
+this._handleTabSelect(false);
+}
+]]></body>
+</method>
+<method name="_animateTabMove">
+<parameter name="event"/>
+<body><![CDATA[
+let draggedTab = event.dataTransfer.mozGetDataAt(TAB_DROP_TYPE, 0);
+if (this.getAttribute("movingtab") != "true") {
+this.setAttribute("movingtab", "true");
+this.selectedItem = draggedTab;
+}
+if (!("animLastScreenX" in draggedTab._dragData))
+draggedTab._dragData.animLastScreenX = draggedTab._dragData.screenX;
+let screenX = event.screenX;
+if (screenX == draggedTab._dragData.animLastScreenX)
+return;
+let draggingRight = screenX > draggedTab._dragData.animLastScreenX;
+draggedTab._dragData.animLastScreenX = screenX;
+let rtl = (window.getComputedStyle(this).direction == "rtl");
+let pinned = draggedTab.pinned;
+let numPinned = this.tabbrowser._numPinnedTabs;
+let tabs = this.tabbrowser.visibleTabs
+.slice(pinned ? 0 : numPinned,
+pinned ? numPinned : undefined);
+if (rtl)
+tabs.reverse();
+let tabWidth = draggedTab.getBoundingClientRect().width;
+// Move the dragged tab based on the mouse position.
+let leftTab = tabs[0];
+let rightTab = tabs[tabs.length - 1];
+let tabScreenX = draggedTab.boxObject.screenX;
+let translateX = screenX - draggedTab._dragData.screenX;
+if (!pinned)
+translateX += this.mTabstrip.scrollPosition - draggedTab._dragData.scrollX;
+let leftBound = leftTab.boxObject.screenX - tabScreenX;
+let rightBound = (rightTab.boxObject.screenX + rightTab.boxObject.width) -
+(tabScreenX + tabWidth);
+translateX = Math.max(translateX, leftBound);
+translateX = Math.min(translateX, rightBound);
+draggedTab.style.transform = "translateX(" + translateX + "px)";
+// Determine what tab we're dragging over.
+// * Point of reference is the center of the dragged tab. If that
+//   point touches a background tab, the dragged tab would take that
+//   tab's position when dropped.
+// * We're doing a binary search in order to reduce the amount of
+//   tabs we need to check.
+let tabCenter = tabScreenX + translateX + tabWidth / 2;
+let newIndex = -1;
+let oldIndex = "animDropIndex" in draggedTab._dragData ?
+draggedTab._dragData.animDropIndex : draggedTab._tPos;
+let low = 0;
+let high = tabs.length - 1;
+while (low <= high) {
+let mid = Math.floor((low + high) / 2);
+if (tabs[mid] == draggedTab &&
+++mid > high)
+break;
+let boxObject = tabs[mid].boxObject;
+let screenX = boxObject.screenX + getTabShift(tabs[mid], oldIndex);
+if (screenX > tabCenter) {
+high = mid - 1;
+} else if (screenX + boxObject.width < tabCenter) {
+low = mid + 1;
+} else {
+newIndex = tabs[mid]._tPos;
+break;
+}
+}
+if (newIndex >= oldIndex)
+newIndex++;
+if (newIndex < 0 || newIndex == oldIndex)
+return;
+draggedTab._dragData.animDropIndex = newIndex;
+// Shift background tabs to leave a gap where the dragged tab
+// would currently be dropped.
+for (let tab of tabs) {
+if (tab != draggedTab) {
+let shift = getTabShift(tab, newIndex);
+tab.style.transform = shift ? "translateX(" + shift + "px)" : "";
+}
+}
+function getTabShift(tab, dropIndex) {
+if (tab._tPos < draggedTab._tPos && tab._tPos >= dropIndex)
+return rtl ? -tabWidth : tabWidth;
+if (tab._tPos > draggedTab._tPos && tab._tPos < dropIndex)
+return rtl ? tabWidth : -tabWidth;
+return 0;
+}
+]]></body>
+</method>
+<method name="_finishAnimateTabMove">
+<body><![CDATA[
+if (this.getAttribute("movingtab") != "true")
+return;
+for (let tab of this.tabbrowser.visibleTabs)
+tab.style.transform = "";
+this.removeAttribute("movingtab");
+this._handleTabSelect();
+]]></body>
+</method>
+<method name="handleEvent">
+<parameter name="aEvent"/>
+<body><![CDATA[
+switch (aEvent.type) {
+case "load":
+this.updateVisibility();
+break;
+case "resize":
+if (aEvent.target != window)
+break;
+TabsInTitlebar.updateAppearance();
+if (this.tabbrowser.visibleTabs.length > 1) {
+var width = this.mTabstrip.boxObject.width;
+if (width != this.mTabstripWidth) {
+this.adjustTabstrip();
+this._fillTrailingGap();
+this._handleTabSelect();
+this.mTabstripWidth = width;
+}
+}
+this.tabbrowser.updateWindowResizers();
+break;
+case "mouseout":
+// If the "related target" (the node to which the pointer went) is not
+// a child of the current document, the mouse just left the window.
+let relatedTarget = aEvent.relatedTarget;
+if (relatedTarget && relatedTarget.ownerDocument == document)
+break;
+case "mousemove":
+if (document.getElementById("tabContextMenu").state != "open")
+this._unlockTabSizing();
+break;
+}
+]]></body>
+</method>
+<field name="_animateElement">
+this.mTabstrip._scrollButtonDown;
+</field>
+<method name="_notifyBackgroundTab">
+<parameter name="aTab"/>
+<body><![CDATA[
+if (aTab.pinned)
+return;
+var scrollRect = this.mTabstrip.scrollClientRect;
+var tab = aTab.getBoundingClientRect();
+this.mTabstrip._calcTabMargins(aTab);
+// DOMRect left/right properties are immutable.
+tab = {left: tab.left, right: tab.right};
+// Is the new tab already completely visible?
+if (scrollRect.left <= tab.left && tab.right <= scrollRect.right)
+return;
+if (this.mTabstrip.smoothScroll) {
+let selected = !this.selectedItem.pinned &&
+this.selectedItem.getBoundingClientRect();
+if (selected) {
+selected = {left: selected.left, right: selected.right};
+// Need to take in to account the width of the left/right margins on tabs.
+selected.left = selected.left + this.mTabstrip._tabMarginLeft;
+selected.right = selected.right - this.mTabstrip._tabMarginRight;
+}
+tab.left += this.mTabstrip._tabMarginLeft;
+tab.right -= this.mTabstrip._tabMarginRight;
+// Can we make both the new tab and the selected tab completely visible?
+if (!selected ||
+Math.max(tab.right - selected.left, selected.right - tab.left) <=
+scrollRect.width) {
+this.mTabstrip.ensureElementIsVisible(aTab);
+return;
+}
+this.mTabstrip._smoothScrollByPixels(this.mTabstrip._isRTLScrollbox ?
+selected.right - scrollRect.right :
+selected.left - scrollRect.left);
+}
+if (!this._animateElement.hasAttribute("notifybgtab")) {
+this._animateElement.setAttribute("notifybgtab", "true");
+setTimeout(function (ele) {
+ele.removeAttribute("notifybgtab");
+}, 150, this._animateElement);
+}
+]]></body>
+</method>
+<method name="_getDragTargetTab">
+<parameter name="event"/>
+<body><![CDATA[
+let tab = event.target.localName == "tab" ? event.target : null;
+if (tab &&
+(event.type == "drop" || event.type == "dragover") &&
+event.dataTransfer.dropEffect == "link") {
+let boxObject = tab.boxObject;
+if (event.screenX < boxObject.screenX + boxObject.width * .25 ||
+event.screenX > boxObject.screenX + boxObject.width * .75)
+return null;
+}
+return tab;
+]]></body>
+</method>
+<method name="_getDropIndex">
+<parameter name="event"/>
+<body><![CDATA[
+var tabs = this.childNodes;
+var tab = this._getDragTargetTab(event);
+if (window.getComputedStyle(this, null).direction == "ltr") {
+for (let i = tab ? tab._tPos : 0; i < tabs.length; i++)
+if (event.screenX < tabs[i].boxObject.screenX + tabs[i].boxObject.width / 2)
+return i;
+} else {
+for (let i = tab ? tab._tPos : 0; i < tabs.length; i++)
+if (event.screenX > tabs[i].boxObject.screenX + tabs[i].boxObject.width / 2)
+return i;
+}
+return tabs.length;
+]]></body>
+</method>
+<method name="_setEffectAllowedForDataTransfer">
+<parameter name="event"/>
+<body><![CDATA[
+var dt = event.dataTransfer;
+// Disallow dropping multiple items
+if (dt.mozItemCount > 1)
+return dt.effectAllowed = "none";
+var types = dt.mozTypesAt(0);
+var sourceNode = null;
+// tabs are always added as the first type
+if (types[0] == TAB_DROP_TYPE) {
+var sourceNode = dt.mozGetDataAt(TAB_DROP_TYPE, 0);
+if (sourceNode instanceof XULElement &&
+sourceNode.localName == "tab" &&
+sourceNode.ownerDocument.defaultView instanceof ChromeWindow &&
+sourceNode.ownerDocument.documentElement.getAttribute("windowtype") == "navigator:browser" &&
+sourceNode.ownerDocument.defaultView.gBrowser.tabContainer == sourceNode.parentNode) {
+// Do not allow transfering a private tab to a non-private window
+// and vice versa.
+if (PrivateBrowsingUtils.isWindowPrivate(window) !=
+PrivateBrowsingUtils.isWindowPrivate(sourceNode.ownerDocument.defaultView))
+return dt.effectAllowed = "none";
+if (window.gMultiProcessBrowser !=
+sourceNode.ownerDocument.defaultView.gMultiProcessBrowser)
+return dt.effectAllowed = "none";
+#ifdef XP_MACOSX
+return dt.effectAllowed = event.altKey ? "copy" : "move";
+#else
+return dt.effectAllowed = event.ctrlKey ? "copy" : "move";
+#endif
+}
+}
+if (browserDragAndDrop.canDropLink(event)) {
+// Here we need to do this manually
+return dt.effectAllowed = dt.dropEffect = "link";
+}
+return dt.effectAllowed = "none";
+]]></body>
+</method>
+<method name="_handleNewTab">
+<parameter name="tab"/>
+<body><![CDATA[
+if (tab.parentNode != this)
+return;
+tab._fullyOpen = true;
+this.adjustTabstrip();
+if (tab.getAttribute("selected") == "true") {
+this._fillTrailingGap();
+this._handleTabSelect();
+} else {
+this._notifyBackgroundTab(tab);
+}
+// XXXmano: this is a temporary workaround for bug 345399
+// We need to manually update the scroll buttons disabled state
+// if a tab was inserted to the overflow area or removed from it
+// without any scrolling and when the tabbar has already
+// overflowed.
+this.mTabstrip._updateScrollButtonsDisabledState();
+]]></body>
+</method>
+<method name="_canAdvanceToTab">
+<parameter name="aTab"/>
+<body>
+<![CDATA[
+return !aTab.closing;
+]]>
+</body>
+</method>
+<method name="_handleTabTelemetryStart">
+<parameter name="aTab"/>
+<parameter name="aURI"/>
+<body>
+<![CDATA[
+// Animation-smoothness telemetry/logging
+if (Services.telemetry.canRecord || this._tabAnimationLoggingEnabled) {
+if (aURI == "about:newtab" && (aTab._tPos == 1 || aTab._tPos == 2)) {
+// Indicate newtab page animation where other tabs are unaffected
+// (for which case, the 2nd or 3rd tabs are good representatives, even if not absolute)
+aTab._recordingTabOpenPlain = true;
+}
+aTab._recordingHandle = window.QueryInterface(Ci.nsIInterfaceRequestor)
+.getInterface(Ci.nsIDOMWindowUtils)
+.startFrameTimeRecording();
+}
+// Overall animation duration
+aTab._animStartTime = Date.now();
+]]>
+</body>
+</method>
+<method name="_handleTabTelemetryEnd">
+<parameter name="aTab"/>
+<body>
+<![CDATA[
+if (!aTab._animStartTime) {
+return;
+}
+Services.telemetry.getHistogramById(aTab.closing ?
+"FX_TAB_ANIM_CLOSE_MS" :
+"FX_TAB_ANIM_OPEN_MS")
+.add(Date.now() - aTab._animStartTime);
+aTab._animStartTime = 0;
+// Handle tab animation smoothness telemetry/logging of frame intervals and paint times
+if (!("_recordingHandle" in aTab)) {
+return;
+}
+let intervals = window.QueryInterface(Ci.nsIInterfaceRequestor)
+.getInterface(Ci.nsIDOMWindowUtils)
+.stopFrameTimeRecording(aTab._recordingHandle);
+delete aTab._recordingHandle;
+let frameCount = intervals.length;
+if (this._tabAnimationLoggingEnabled) {
+let msg = "Tab " + (aTab.closing ? "close" : "open") + " (Frame-interval):\n";
+for (let i = 0; i < frameCount; i++) {
+msg += Math.round(intervals[i]) + "\n";
+}
+Services.console.logStringMessage(msg);
+}
+// For telemetry, the first frame interval is not useful since it may represent an interval
+// to a relatively old frame (prior to recording start). So we'll ignore it for the average.
+if (frameCount > 1) {
+let averageInterval = 0;
+for (let i = 1; i < frameCount; i++) {
+averageInterval += intervals[i];
+};
+averageInterval = averageInterval / (frameCount - 1);
+Services.telemetry.getHistogramById("FX_TAB_ANIM_ANY_FRAME_INTERVAL_MS").add(averageInterval);
+if (aTab._recordingTabOpenPlain) {
+delete aTab._recordingTabOpenPlain;
+// While we do have a telemetry probe NEWTAB_PAGE_ENABLED to monitor newtab preview, it'll be
+// easier to overview the data without slicing by it. Hence the additional histograms with _PREVIEW.
+let preview = this._browserNewtabpageEnabled ? "_PREVIEW" : "";
+Services.telemetry.getHistogramById("FX_TAB_ANIM_OPEN" + preview + "_FRAME_INTERVAL_MS").add(averageInterval);
+}
+}
+]]>
+</body>
+</method>
+<!-- Deprecated stuff, implemented for backwards compatibility. -->
+<property name="mTabstripClosebutton" readonly="true"
+onget="return document.getElementById('tabs-closebutton');"/>
+<property name="mAllTabsPopup" readonly="true"
+onget="return document.getElementById('alltabs-popup');"/>
+</implementation>
+<handlers>
+<handler event="TabSelect" action="this._handleTabSelect();"/>
+<handler event="transitionend"><![CDATA[
+if (event.propertyName != "max-width")
+return;
+var tab = event.target;
+this._handleTabTelemetryEnd(tab);
+if (tab.getAttribute("fadein") == "true") {
+if (tab._fullyOpen)
+this.adjustTabstrip();
+else
+this._handleNewTab(tab);
+} else if (tab.closing) {
+this.tabbrowser._endRemoveTab(tab);
+}
+]]></handler>
+<handler event="dblclick"><![CDATA[
+#ifndef XP_MACOSX
+// When the tabbar has an unified appearance with the titlebar
+// and menubar, a double-click in it should have the same behavior
+// as double-clicking the titlebar
+if (TabsInTitlebar.enabled || this.parentNode._dragBindingAlive)
+return;
+#endif
+if (event.button != 0 ||
+event.originalTarget.localName != "box")
+return;
+// See hack note in the tabbrowser-close-tab-button binding
+if (!this._blockDblClick)
+BrowserOpenTab();
+event.preventDefault();
+]]></handler>
+<handler event="click" button="0" phase="capturing"><![CDATA[
+/* Catches extra clicks meant for the in-tab close button.
+* Placed here to avoid leaking (a temporary handler added from the
+* in-tab close button binding would close over the tab and leak it
+* until the handler itself was removed). (bug 897751)
+*
+* The only sequence in which a second click event (i.e. dblclik)
+* can be dispatched on an in-tab close button is when it is shown
+* after the first click (i.e. the first click event was dispatched
+* on the tab). This happens when we show the close button only on
+* the active tab. (bug 352021)
+* The only sequence in which a third click event can be dispatched
+* on an in-tab close button is when the tab was opened with a
+* double click on the tabbar. (bug 378344)
+* In both cases, it is most likely that the close button area has
+* been accidentally clicked, therefore we do not close the tab.
+*
+* We don't want to ignore processing of more than one click event,
+* though, since the user might actually be repeatedly clicking to
+* close many tabs at once.
+*/
+let target = event.originalTarget;
+if (target.classList.contains('tab-close-button')) {
+// We preemptively set this to allow the closing-multiple-tabs-
+// in-a-row case.
+if (this._blockDblClick) {
+target._ignoredCloseButtonClicks = true;
+} else if (event.detail > 1 && !target._ignoredCloseButtonClicks) {
+target._ignoredCloseButtonClicks = true;
+event.stopPropagation();
+return;
+} else {
+// Reset the "ignored click" flag
+target._ignoredCloseButtonClicks = false;
+}
+}
+/* Protects from close-tab-button errant doubleclick:
+* Since we're removing the event target, if the user
+* double-clicks the button, the dblclick event will be dispatched
+* with the tabbar as its event target (and explicit/originalTarget),
+* which treats that as a mouse gesture for opening a new tab.
+* In this context, we're manually blocking the dblclick event
+* (see tabbrowser-close-tab-button dblclick handler).
+*/
+if (this._blockDblClick) {
+if (!("_clickedTabBarOnce" in this)) {
+this._clickedTabBarOnce = true;
+return;
+}
+delete this._clickedTabBarOnce;
+this._blockDblClick = false;
+}
+]]></handler>
+<handler event="click"><![CDATA[
+if (event.button != 1)
+return;
+if (event.target.localName == "tab") {
+this.tabbrowser.removeTab(event.target, {animate: true, byMouse: true});
+} else if (event.originalTarget.localName == "box") {
+BrowserOpenTab();
+} else {
+return;
+}
+event.stopPropagation();
+]]></handler>
+<handler event="keypress"><![CDATA[
+if (event.altKey || event.shiftKey ||
+#ifdef XP_MACOSX
+!event.metaKey)
+#else
+!event.ctrlKey || event.metaKey)
+#endif
+return;
+switch (event.keyCode) {
+case KeyEvent.DOM_VK_UP:
+this.tabbrowser.moveTabBackward();
+break;
+case KeyEvent.DOM_VK_DOWN:
+this.tabbrowser.moveTabForward();
+break;
+case KeyEvent.DOM_VK_RIGHT:
+case KeyEvent.DOM_VK_LEFT:
+this.tabbrowser.moveTabOver(event);
+break;
+case KeyEvent.DOM_VK_HOME:
+this.tabbrowser.moveTabToStart();
+break;
+case KeyEvent.DOM_VK_END:
+this.tabbrowser.moveTabToEnd();
+break;
+default:
+// Stop the keypress event for the above keyboard
+// shortcuts only.
+return;
+}
+event.stopPropagation();
+event.preventDefault();
+]]></handler>
+<handler event="dragstart"><![CDATA[
+var tab = this._getDragTargetTab(event);
+if (!tab || this._isCustomizing)
+return;
+let dt = event.dataTransfer;
+dt.mozSetDataAt(TAB_DROP_TYPE, tab, 0);
+let browser = tab.linkedBrowser;
+// We must not set text/x-moz-url or text/plain data here,
+// otherwise trying to deatch the tab by dropping it on the desktop
+// may result in an "internet shortcut"
+dt.mozSetDataAt("text/x-moz-text-internal", browser.currentURI.spec, 0);
+// Set the cursor to an arrow during tab drags.
+dt.mozCursor = "default";
+// Create a canvas to which we capture the current tab.
+// Until canvas is HiDPI-aware (bug 780362), we need to scale the desired
+// canvas size (in CSS pixels) to the window's backing resolution in order
+// to get a full-resolution drag image for use on HiDPI displays.
+let windowUtils = window.getInterface(Ci.nsIDOMWindowUtils);
+let scale = windowUtils.screenPixelsPerCSSPixel / windowUtils.fullZoom;
+let canvas = document.createElementNS("http://www.w3.org/1999/xhtml", "canvas");
+canvas.mozOpaque = true;
+canvas.width = 160 * scale;
+canvas.height = 90 * scale;
+PageThumbs.captureToCanvas(browser.contentWindow, canvas);
+dt.setDragImage(canvas, -16 * scale, -16 * scale);
+// _dragData.offsetX/Y give the coordinates that the mouse should be
+// positioned relative to the corner of the new window created upon
+// dragend such that the mouse appears to have the same position
+// relative to the corner of the dragged tab.
+function clientX(ele) ele.getBoundingClientRect().left;
+let tabOffsetX = clientX(tab) - clientX(this);
+tab._dragData = {
+offsetX: event.screenX - window.screenX - tabOffsetX,
+offsetY: event.screenY - window.screenY,
+scrollX: this.mTabstrip.scrollPosition,
+screenX: event.screenX
+};
+event.stopPropagation();
+]]></handler>
+<handler event="dragover"><![CDATA[
+var effects = this._setEffectAllowedForDataTransfer(event);
+var ind = this._tabDropIndicator;
+if (effects == "" || effects == "none") {
+ind.collapsed = true;
+return;
+}
+event.preventDefault();
+event.stopPropagation();
+var tabStrip = this.mTabstrip;
+var ltr = (window.getComputedStyle(this, null).direction == "ltr");
+// autoscroll the tab strip if we drag over the scroll
+// buttons, even if we aren't dragging a tab, but then
+// return to avoid drawing the drop indicator
+var pixelsToScroll = 0;
+if (this.getAttribute("overflow") == "true") {
+var targetAnonid = event.originalTarget.getAttribute("anonid");
+switch (targetAnonid) {
+case "scrollbutton-up":
+pixelsToScroll = tabStrip.scrollIncrement * -1;
+break;
+case "scrollbutton-down":
+pixelsToScroll = tabStrip.scrollIncrement;
+break;
+}
+if (pixelsToScroll)
+tabStrip.scrollByPixels((ltr ? 1 : -1) * pixelsToScroll);
+}
+if (effects == "move" &&
+this == event.dataTransfer.mozGetDataAt(TAB_DROP_TYPE, 0).parentNode) {
+ind.collapsed = true;
+this._animateTabMove(event);
+return;
+}
+this._finishAnimateTabMove();
+if (effects == "link") {
+let tab = this._getDragTargetTab(event);
+if (tab) {
+if (!this._dragTime)
+this._dragTime = Date.now();
+if (Date.now() >= this._dragTime + this._dragOverDelay)
+this.selectedItem = tab;
+ind.collapsed = true;
+return;
+}
+}
+var rect = tabStrip.getBoundingClientRect();
+var newMargin;
+if (pixelsToScroll) {
+// if we are scrolling, put the drop indicator at the edge
+// so that it doesn't jump while scrolling
+let scrollRect = tabStrip.scrollClientRect;
+let minMargin = scrollRect.left - rect.left;
+let maxMargin = Math.min(minMargin + scrollRect.width,
+scrollRect.right);
+if (!ltr)
+[minMargin, maxMargin] = [this.clientWidth - maxMargin,
+this.clientWidth - minMargin];
+newMargin = (pixelsToScroll > 0) ? maxMargin : minMargin;
+}
+else {
+let newIndex = this._getDropIndex(event);
+if (newIndex == this.childNodes.length) {
+let tabRect = this.childNodes[newIndex-1].getBoundingClientRect();
+if (ltr)
+newMargin = tabRect.right - rect.left;
+else
+newMargin = rect.right - tabRect.left;
+}
+else {
+let tabRect = this.childNodes[newIndex].getBoundingClientRect();
+if (ltr)
+newMargin = tabRect.left - rect.left;
+else
+newMargin = rect.right - tabRect.right;
+}
+}
+ind.collapsed = false;
+newMargin += ind.clientWidth / 2;
+if (!ltr)
+newMargin *= -1;
+ind.style.transform = "translate(" + Math.round(newMargin) + "px)";
+ind.style.MozMarginStart = (-ind.clientWidth) + "px";
+]]></handler>
+<handler event="drop"><![CDATA[
+var dt = event.dataTransfer;
+var dropEffect = dt.dropEffect;
+var draggedTab;
+if (dropEffect != "link") { // copy or move
+draggedTab = dt.mozGetDataAt(TAB_DROP_TYPE, 0);
+// not our drop then
+if (!draggedTab)
+return;
+}
+this._tabDropIndicator.collapsed = true;
+event.stopPropagation();
+if (draggedTab && dropEffect == "copy") {
+// copy the dropped tab (wherever it's from)
+let newIndex = this._getDropIndex(event);
+let newTab = this.tabbrowser.duplicateTab(draggedTab);
+this.tabbrowser.moveTabTo(newTab, newIndex);
+if (draggedTab.parentNode != this || event.shiftKey)
+this.selectedItem = newTab;
+} else if (draggedTab && draggedTab.parentNode == this) {
+this._finishAnimateTabMove();
+// actually move the dragged tab
+if ("animDropIndex" in draggedTab._dragData) {
+let newIndex = draggedTab._dragData.animDropIndex;
+if (newIndex > draggedTab._tPos)
+newIndex--;
+this.tabbrowser.moveTabTo(draggedTab, newIndex);
+}
+} else if (draggedTab) {
+// 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)
+let newIndex = this._getDropIndex(event);
+let newTab = this.tabbrowser.addTab("about:blank");
+let newBrowser = this.tabbrowser.getBrowserForTab(newTab);
+// Stop the about:blank load
+newBrowser.stop();
+// make sure it has a docshell
+newBrowser.docShell;
+let numPinned = this.tabbrowser._numPinnedTabs;
+if (newIndex < numPinned || draggedTab.pinned && newIndex == numPinned)
+this.tabbrowser.pinTab(newTab);
+this.tabbrowser.moveTabTo(newTab, newIndex);
+// We need to select the tab before calling swapBrowsersAndCloseOther
+// so that window.content in chrome windows points to the right tab
+// when pagehide/show events are fired.
+this.tabbrowser.selectedTab = newTab;
+draggedTab.parentNode._finishAnimateTabMove();
+this.tabbrowser.swapBrowsersAndCloseOther(newTab, draggedTab);
+// Call updateCurrentBrowser to make sure the URL bar is up to date
+// for our new tab after we've done swapBrowsersAndCloseOther.
+this.tabbrowser.updateCurrentBrowser(true);
+} else {
+// Pass true to disallow dropping javascript: or data: urls
+let url;
+try {
+url = browserDragAndDrop.drop(event, { }, true);
+} catch (ex) {}
+if (!url)
+return;
+let bgLoad = Services.prefs.getBoolPref("browser.tabs.loadInBackground");
+if (event.shiftKey)
+bgLoad = !bgLoad;
+let tab = this._getDragTargetTab(event);
+if (!tab || dropEffect == "copy") {
+// We're adding a new tab.
+let newIndex = this._getDropIndex(event);
+let newTab = this.tabbrowser.loadOneTab(url, {inBackground: bgLoad, allowThirdPartyFixup: true});
+this.tabbrowser.moveTabTo(newTab, newIndex);
+} else {
+// Load in an existing tab.
+try {
+let webNav = Ci.nsIWebNavigation;
+let flags = webNav.LOAD_FLAGS_ALLOW_THIRD_PARTY_FIXUP |
+webNav.LOAD_FLAGS_FIXUP_SCHEME_TYPOS;
+this.tabbrowser.getBrowserForTab(tab).loadURIWithFlags(url, flags);
+if (!bgLoad)
+this.selectedItem = tab;
+} catch(ex) {
+// Just ignore invalid urls
+}
+}
+}
+if (draggedTab) {
+delete draggedTab._dragData;
+}
+]]></handler>
+<handler event="dragend"><![CDATA[
+// Note: while this case is correctly handled here, this event
+// isn't dispatched when the tab is moved within the tabstrip,
+// see bug 460801.
+this._finishAnimateTabMove();
+var dt = event.dataTransfer;
+var draggedTab = dt.mozGetDataAt(TAB_DROP_TYPE, 0);
+if (dt.mozUserCancelled || dt.dropEffect != "none" || this._isCustomizing) {
+delete draggedTab._dragData;
+return;
+}
+// Disable detach within the browser toolbox
+var eX = event.screenX;
+var eY = event.screenY;
+var wX = window.screenX;
+// check if the drop point is horizontally within the window
+if (eX > wX && eX < (wX + window.outerWidth)) {
+let bo = this.mTabstrip.boxObject;
+// also avoid detaching if the the tab was dropped too close to
+// the tabbar (half a tab)
+let endScreenY = bo.screenY + 1.5 * bo.height;
+if (eY < endScreenY && eY > window.screenY)
+return;
+}
+// screen.availLeft et. al. only check the screen that this window is on,
+// but we want to look at the screen the tab is being dropped onto.
+var sX = {}, sY = {}, sWidth = {}, sHeight = {};
+Cc["@mozilla.org/gfx/screenmanager;1"]
+.getService(Ci.nsIScreenManager)
+.screenForRect(eX, eY, 1, 1)
+.GetAvailRect(sX, sY, sWidth, sHeight);
+// ensure new window entirely within screen
+var winWidth = Math.min(window.outerWidth, sWidth.value);
+var winHeight = Math.min(window.outerHeight, sHeight.value);
+var left = Math.min(Math.max(eX - draggedTab._dragData.offsetX, sX.value),
+sX.value + sWidth.value - winWidth);
+var top = Math.min(Math.max(eY - draggedTab._dragData.offsetY, sY.value),
+sY.value + sHeight.value - winHeight);
+delete draggedTab._dragData;
+if (this.tabbrowser.tabs.length == 1) {
+// resize _before_ move to ensure the window fits the new screen.  if
+// the window is too large for its screen, the window manager may do
+// automatic repositioning.
+window.resizeTo(winWidth, winHeight);
+window.moveTo(left, top);
+window.focus();
+} else {
+this.tabbrowser.replaceTabWithWindow(draggedTab, { screenX: left,
+screenY: top,
+#ifndef XP_WIN
+outerWidth: winWidth,
+outerHeight: winHeight
+#endif
+});
+}
+event.stopPropagation();
+]]></handler>
+<handler event="dragexit"><![CDATA[
+this._dragTime = 0;
+// This does not work at all (see bug 458613)
+var target = event.relatedTarget;
+while (target && target != this)
+target = target.parentNode;
+if (target)
+return;
+this._tabDropIndicator.collapsed = true;
+event.stopPropagation();
+]]></handler>
+</handlers>
+</binding>
+<!-- close-tab-button binding
+This binding relies on the structure of the tabbrowser binding.
+Therefore it should only be used as a child of the tab or the tabs
+element (in both cases, when they are anonymous nodes of <tabbrowser>).
+-->
+<binding id="tabbrowser-close-tab-button"
+extends="chrome://global/content/bindings/toolbarbutton.xml#toolbarbutton-image">
+<handlers>
+<handler event="click" button="0"><![CDATA[
+var bindingParent = document.getBindingParent(this);
+var tabContainer = bindingParent.parentNode;
+tabContainer.tabbrowser.removeTab(bindingParent, {animate: true, byMouse: true});
+// This enables double-click protection for the tab container
+// (see tabbrowser-tabs 'click' handler).
+tabContainer._blockDblClick = true;
+]]></handler>
+<handler event="dblclick" button="0" phase="capturing">
+// for the one-close-button case
+event.stopPropagation();
+</handler>
+<handler event="dragstart">
+event.stopPropagation();
+</handler>
+</handlers>
+</binding>
+<binding id="tabbrowser-tab" display="xul:hbox"
+extends="chrome://global/content/bindings/tabbox.xml#tab">
+<resources>
+<stylesheet src="chrome://browser/content/tabbrowser.css"/>
+</resources>
+<content context="tabContextMenu" closetabtext="&closeTab.label;">
+<xul:stack class="tab-stack" flex="1">
+<xul:hbox xbl:inherits="pinned,selected,titlechanged,fadein"
+class="tab-background">
+<xul:hbox xbl:inherits="pinned,selected,titlechanged"
+class="tab-background-start"/>
+<xul:hbox xbl:inherits="pinned,selected,titlechanged"
+class="tab-background-middle"/>
+<xul:hbox xbl:inherits="pinned,selected,titlechanged"
+class="tab-background-end"/>
+</xul:hbox>
+<xul:hbox xbl:inherits="pinned,selected,titlechanged"
+class="tab-content" align="center">
+<xul:image xbl:inherits="fadein,pinned,busy,progress,selected"
+class="tab-throbber"
+role="presentation"
+layer="true" />
+<xul:image xbl:inherits="src=image,fadein,pinned,selected"
+anonid="tab-icon-image"
+class="tab-icon-image"
+validate="never"
+role="presentation"/>
+<xul:label flex="1"
+anonid="tab-label"
+xbl:inherits="value=visibleLabel,crop,accesskey,fadein,pinned,selected"
+class="tab-text tab-label"
+role="presentation"/>
+<xul:toolbarbutton anonid="close-button"
+xbl:inherits="fadein,pinned,selected"
+class="tab-close-button close-icon"/>
+</xul:hbox>
+</xul:stack>
+</content>
+<implementation>
+<property name="label">
+<getter>
+return this.getAttribute("label");
+</getter>
+<setter>
+this.setAttribute("label", val);
+let event = new CustomEvent("TabLabelModified", {
+bubbles: true,
+cancelable: true
+});
+this.dispatchEvent(event);
+// Let listeners prevent synchronizing the actual label to the
+// visible label (allowing them to override the visible label).
+if (!event.defaultPrevented)
+this.visibleLabel = val;
+</setter>
+</property>
+<property name="visibleLabel">
+<getter>
+return this.getAttribute("visibleLabel");
+</getter>
+<setter>
+this.setAttribute("visibleLabel", val);
+</setter>
+</property>
+<property name="pinned" readonly="true">
+<getter>
+return this.getAttribute("pinned") == "true";
+</getter>
+</property>
+<property name="hidden" readonly="true">
+<getter>
+return this.getAttribute("hidden") == "true";
+</getter>
+</property>
+<property name="lastAccessed">
+<getter>
+return this.selected ? Date.now() : this._lastAccessed;
+</getter>
+<setter>
+this._lastAccessed = val;
+</setter>
+</property>
+<field name="_lastAccessed">0</field>
+<field name="mOverCloseButton">false</field>
+<field name="mCorrespondingMenuitem">null</field>
+<field name="closing">false</field>
+<method name="_mouseenter">
+<body><![CDATA[
+if (this.hidden || this.closing)
+return;
+let tabContainer = this.parentNode;
+let visibleTabs = tabContainer.tabbrowser.visibleTabs;
+let tabIndex = visibleTabs.indexOf(this);
+if (tabIndex == 0) {
+tabContainer._beforeHoveredTab = null;
+} else {
+let candidate = visibleTabs[tabIndex - 1];
+if (!candidate.selected) {
+tabContainer._beforeHoveredTab = candidate;
+candidate.setAttribute("beforehovered", "true");
+}
+}
+if (tabIndex == visibleTabs.length - 1) {
+tabContainer._afterHoveredTab = null;
+} else {
+let candidate = visibleTabs[tabIndex + 1];
+if (!candidate.selected) {
+tabContainer._afterHoveredTab = candidate;
+candidate.setAttribute("afterhovered", "true");
+}
+}
+tabContainer._hoveredTab = this;
+]]></body>
+</method>
+<method name="_mouseleave">
+<body><![CDATA[
+let tabContainer = this.parentNode;
+if (tabContainer._beforeHoveredTab) {
+tabContainer._beforeHoveredTab.removeAttribute("beforehovered");
+tabContainer._beforeHoveredTab = null;
+}
+if (tabContainer._afterHoveredTab) {
+tabContainer._afterHoveredTab.removeAttribute("afterhovered");
+tabContainer._afterHoveredTab = null;
+}
+tabContainer._hoveredTab = null;
+]]></body>
+</method>
+</implementation>
+<handlers>
+<handler event="mouseover"><![CDATA[
+let anonid = event.originalTarget.getAttribute("anonid");
+if (anonid == "close-button")
+this.mOverCloseButton = true;
+this._mouseenter();
+]]></handler>
+<handler event="mouseout"><![CDATA[
+let anonid = event.originalTarget.getAttribute("anonid");
+if (anonid == "close-button")
+this.mOverCloseButton = false;
+this._mouseleave();
+]]></handler>
+<handler event="dragstart" phase="capturing">
+this.style.MozUserFocus = '';
+</handler>
+<handler event="mousedown" phase="capturing">
+<![CDATA[
+if (this.selected) {
+this.style.MozUserFocus = 'ignore';
+this.clientTop; // just using this to flush style updates
+} else if (this.mOverCloseButton) {
+// Prevent tabbox.xml from selecting the tab.
+event.stopPropagation();
+}
+]]>
+</handler>
+<handler event="mouseup">
+this.style.MozUserFocus = '';
+</handler>
+</handlers>
+</binding>
+<binding id="tabbrowser-alltabs-popup"
+extends="chrome://global/content/bindings/popup.xml#popup">
+<implementation implements="nsIDOMEventListener">
+<method name="_tabOnAttrModified">
+<parameter name="aEvent"/>
+<body><![CDATA[
+var tab = aEvent.target;
+if (tab.mCorrespondingMenuitem)
+this._setMenuitemAttributes(tab.mCorrespondingMenuitem, tab);
+]]></body>
+</method>
+<method name="_tabOnTabClose">
+<parameter name="aEvent"/>
+<body><![CDATA[
+var tab = aEvent.target;
+if (tab.mCorrespondingMenuitem)
+this.removeChild(tab.mCorrespondingMenuitem);
+]]></body>
+</method>
+<method name="handleEvent">
+<parameter name="aEvent"/>
+<body><![CDATA[
+switch (aEvent.type) {
+case "TabAttrModified":
+this._tabOnAttrModified(aEvent);
+break;
+case "TabClose":
+this._tabOnTabClose(aEvent);
+break;
+case "scroll":
+this._updateTabsVisibilityStatus();
+break;
+}
+]]></body>
+</method>
+<method name="_updateTabsVisibilityStatus">
+<body><![CDATA[
+var tabContainer = gBrowser.tabContainer;
+// We don't want menu item decoration unless there is overflow.
+if (tabContainer.getAttribute("overflow") != "true")
+return;
+var tabstripBO = tabContainer.mTabstrip.scrollBoxObject;
+for (var i = 0; i < this.childNodes.length; i++) {
+let curTab = this.childNodes[i].tab;
+if (!curTab) // "Tab Groups" menuitem and its menuseparator
+continue;
+let curTabBO = curTab.boxObject;
+if (curTabBO.screenX >= tabstripBO.screenX &&
+curTabBO.screenX + curTabBO.width <= tabstripBO.screenX + tabstripBO.width)
+this.childNodes[i].setAttribute("tabIsVisible", "true");
+else
+this.childNodes[i].removeAttribute("tabIsVisible");
+}
+]]></body>
+</method>
+<method name="_createTabMenuItem">
+<parameter name="aTab"/>
+<body><![CDATA[
+var menuItem = document.createElementNS(
+"http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul",
+"menuitem");
+menuItem.setAttribute("class", "menuitem-iconic alltabs-item menuitem-with-favicon");
+this._setMenuitemAttributes(menuItem, aTab);
+aTab.mCorrespondingMenuitem = menuItem;
+menuItem.tab = aTab;
+this.appendChild(menuItem);
+]]></body>
+</method>
+<method name="_setMenuitemAttributes">
+<parameter name="aMenuitem"/>
+<parameter name="aTab"/>
+<body><![CDATA[
+aMenuitem.setAttribute("label", aTab.label);
+aMenuitem.setAttribute("crop", aTab.getAttribute("crop"));
+if (aTab.hasAttribute("busy")) {
+aMenuitem.setAttribute("busy", aTab.getAttribute("busy"));
+aMenuitem.removeAttribute("image");
+} else {
+aMenuitem.setAttribute("image", aTab.getAttribute("image"));
+aMenuitem.removeAttribute("busy");
+}
+if (aTab.hasAttribute("pending"))
+aMenuitem.setAttribute("pending", aTab.getAttribute("pending"));
+else
+aMenuitem.removeAttribute("pending");
+if (aTab.selected)
+aMenuitem.setAttribute("selected", "true");
+else
+aMenuitem.removeAttribute("selected");
+]]></body>
+</method>
+</implementation>
+<handlers>
+<handler event="popupshowing">
+<![CDATA[
+var tabcontainer = gBrowser.tabContainer;
+// Listen for changes in the tab bar.
+tabcontainer.addEventListener("TabAttrModified", this, false);
+tabcontainer.addEventListener("TabClose", this, false);
+tabcontainer.mTabstrip.addEventListener("scroll", this, false);
+let tabs = gBrowser.visibleTabs;
+for (var i = 0; i < tabs.length; i++) {
+if (!tabs[i].pinned)
+this._createTabMenuItem(tabs[i]);
+}
+this._updateTabsVisibilityStatus();
+]]></handler>
+<handler event="popuphidden">
+<![CDATA[
+// clear out the menu popup and remove the listeners
+for (let i = this.childNodes.length - 1; i > 0; i--) {
+let menuItem = this.childNodes[i];
+if (menuItem.tab) {
+menuItem.tab.mCorrespondingMenuitem = null;
+this.removeChild(menuItem);
+}
+}
+var tabcontainer = gBrowser.tabContainer;
+tabcontainer.mTabstrip.removeEventListener("scroll", this, false);
+tabcontainer.removeEventListener("TabAttrModified", this, false);
+tabcontainer.removeEventListener("TabClose", this, false);
+]]></handler>
+<handler event="DOMMenuItemActive">
+<![CDATA[
+var tab = event.target.tab;
+if (tab) {
+let overLink = tab.linkedBrowser.currentURI.spec;
+if (overLink == "about:blank")
+overLink = "";
+XULBrowserWindow.setOverLink(overLink, null);
+}
+]]></handler>
+<handler event="DOMMenuItemInactive">
+<![CDATA[
+XULBrowserWindow.setOverLink("", null);
+]]></handler>
+<handler event="command"><![CDATA[
+if (event.target.tab)
+gBrowser.selectedTab = event.target.tab;
+]]></handler>
+</handlers>
+</binding>
+<binding id="statuspanel" display="xul:hbox">
+<content>
+<xul:hbox class="statuspanel-inner">
+<xul:label class="statuspanel-label"
+role="status"
+aria-live="off"
+xbl:inherits="value=label,crop,mirror"
+flex="1"
+crop="end"/>
+</xul:hbox>
+</content>
+<implementation implements="nsIDOMEventListener">
+<constructor><![CDATA[
+window.addEventListener("resize", this, false);
+]]></constructor>
+<destructor><![CDATA[
+window.removeEventListener("resize", this, false);
+MousePosTracker.removeListener(this);
+]]></destructor>
+<property name="label">
+<setter><![CDATA[
+if (!this.label) {
+this.removeAttribute("mirror");
+this.removeAttribute("sizelimit");
+}
+this.style.minWidth = this.getAttribute("type") == "status" &&
+this.getAttribute("previoustype") == "status"
+? getComputedStyle(this).width : "";
+if (val) {
+this.setAttribute("label", val);
+this.removeAttribute("inactive");
+this._calcMouseTargetRect();
+MousePosTracker.addListener(this);
+} else {
+this.setAttribute("inactive", "true");
+MousePosTracker.removeListener(this);
+}
+return val;
+]]></setter>
+<getter>
+return this.hasAttribute("inactive") ? "" : this.getAttribute("label");
+</getter>
+</property>
+<method name="getMouseTargetRect">
+<body><![CDATA[
+return this._mouseTargetRect;
+]]></body>
+</method>
+<method name="onMouseEnter">
+<body>
+this._mirror();
+</body>
+</method>
+<method name="onMouseLeave">
+<body>
+this._mirror();
+</body>
+</method>
+<method name="handleEvent">
+<parameter name="event"/>
+<body><![CDATA[
+if (!this.label)
+return;
+switch (event.type) {
+case "resize":
+this._calcMouseTargetRect();
+break;
+}
+]]></body>
+</method>
+<method name="_calcMouseTargetRect">
+<body><![CDATA[
+let container = this.parentNode;
+let alignRight = (getComputedStyle(container).direction == "rtl");
+let panelRect = this.getBoundingClientRect();
+let containerRect = container.getBoundingClientRect();
+this._mouseTargetRect = {
+top:    panelRect.top,
+bottom: panelRect.bottom,
+left:   alignRight ? containerRect.right - panelRect.width : containerRect.left,
+right:  alignRight ? containerRect.right : containerRect.left + panelRect.width
+};
+]]></body>
+</method>
+<method name="_mirror">
+<body>
+if (this.hasAttribute("mirror"))
+this.removeAttribute("mirror");
+else
+this.setAttribute("mirror", "true");
+if (!this.hasAttribute("sizelimit")) {
+this.setAttribute("sizelimit", "true");
+this._calcMouseTargetRect();
+}
+</body>
+</method>
+</implementation>
+</binding>
+</bindings>

The Tor Browser / file comparison

comparison: browser/base/content/tabbrowser.xml

browser/base/content/tabbrowser.xml