# HG changeset patch
# User Dmitry Butskoy <dmitry@butskoy.name>
# Date 1628960364 -7200
# Parent  45d5ea1452b1c406303ff3be289df08cde3d5a04
Bug 1623054 - Set owner tab for proper tab focus handling after close. r=IanN a=IanN
Upstream bug-report: https://bugzilla.mozilla.org/show_bug.cgi?id=1623054

diff --git seamonkey-2.53.10.2/comm/suite/app/profile/suite-prefs.js seamonkey-2.53.10.2/comm/suite/app/profile/suite-prefs.js
--- seamonkey-2.53.10.2/comm/suite/app/profile/suite-prefs.js
+++ seamonkey-2.53.10.2/comm/suite/app/profile/suite-prefs.js
@@ -224,16 +224,17 @@ pref("browser.tabs.autoHide", false);
 pref("browser.tabs.forceHide", false);
 pref("browser.tabs.closeWindowWithLastTab", true);
 pref("browser.tabs.warnOnClose", true);
 pref("browser.tabs.warnOnCloseOther", true);
 pref("browser.tabs.warnOnOpen", true);
 pref("browser.tabs.maxOpenBeforeWarn", 15);
 pref("browser.tabs.insertRelatedAfterCurrent", true);
 pref("browser.tabs.insertAllTabsAfterCurrent", false);
+pref("browser.tabs.selectOwnerOnClose", true);
 pref("browser.tabs.avoidBrowserFocus", false);
 
 // For future use
 pref("browser.tabs.loadBookmarksInBackground", false);
 
 // how many browsers can be saved in the DOM (by the tabbed browser)
 pref("browser.tabs.max_tabs_undo", 3);
 // should popups by saved in the DOM (by the tabbed browser)
diff --git seamonkey-2.53.10.2/comm/suite/base/content/utilityOverlay.js seamonkey-2.53.10.2/comm/suite/base/content/utilityOverlay.js
--- seamonkey-2.53.10.2/comm/suite/base/content/utilityOverlay.js
+++ seamonkey-2.53.10.2/comm/suite/base/content/utilityOverlay.js
@@ -1637,16 +1637,17 @@ function openLinkIn(url, where, params)
     // fall through
   case "tab":
     var browser = w.getBrowser();
     var tab = browser.addTab(url, {
                 referrerURI: aReferrerURI,
                 referrerPolicy: aReferrerPolicy,
                 charset: aCharset,
                 postData: aPostData,
+                ownerTab: loadInBackground ? null : browser.selectedTab,
                 allowThirdPartyFixup: aAllowThirdPartyFixup,
                 relatedToCurrent: aRelatedToCurrent,
                 allowMixedContent: aAllowMixedContent,
                 noReferrer: aNoReferrer,
                 userContextId: aUserContextId,
                 originPrincipal: aPrincipal,
                 triggeringPrincipal: aTriggeringPrincipal,
               });
diff --git seamonkey-2.53.10.2/comm/suite/browser/tabbrowser.xml seamonkey-2.53.10.2/comm/suite/browser/tabbrowser.xml
--- seamonkey-2.53.10.2/comm/suite/browser/tabbrowser.xml
+++ seamonkey-2.53.10.2/comm/suite/browser/tabbrowser.xml
@@ -1152,16 +1152,27 @@
             newBrowser.docShellIsActive = this.mCurrentTab.linkedBrowser.docShellIsActive;
             if (this.mCurrentBrowser) {
               this.mCurrentBrowser.droppedLinkHandler = null;
               this.mCurrentBrowser.docShellIsActive = false;
               this.mCurrentBrowser.removeAttribute("primary");
               this.finder.mListeners.forEach(l => this.mCurrentBrowser.finder.removeResultListener(l));
             }
 
+            let oldTab = this.mCurrentTab;
+
+            // Preview mode should not reset the owner.
+            if (!this._previewMode && !oldTab.selected)
+              oldTab.owner = null;
+
+            let lastRelatedTab = this.mLastRelatedIndex ? this.tabs[this.mLastRelatedIndex] : null;
+            if (lastRelatedTab && !lastRelatedTab.selected) {
+              lastRelatedTab.owner = null;
+            }
+
             newBrowser.setAttribute("primary", "true");
             this.mCurrentBrowser = newBrowser;
             this.mCurrentTab = this.selectedTab;
             this.mCurrentTab.removeAttribute("unread");
             this.finder.mListeners.forEach(l => this.mCurrentBrowser.finder.addResultListener(l));
 
             var tabListener = this.mTabListeners[this.tabContainer.selectedIndex];
 
@@ -1445,16 +1456,19 @@
                 opener: null,
               };
             }
 
             params.focusNewTab = params.inBackground != null ?
                 !params.inBackground :
                 !Services.prefs.getBoolPref("browser.tabs.loadInBackground");
 
+            if (params.focusNewTab)
+              params.ownerTab = this.selectedTab;
+
             return this.addTab(aURI, params);
          ]]>
         </body>
       </method>
 
       <method name="loadTabs">
         <parameter name="aURIs"/>
         <parameter name="aLoadInBackground"/>
@@ -1556,43 +1570,49 @@
         <parameter name="aPostData"/>
         <parameter name="aFocusNewTab"/>
         <parameter name="aAllowThirdPartyFixup"/>
         <body>
           <![CDATA[
             var aTriggeringPrincipal;
             var aReferrerPolicy;
             var aFromExternal;
+            var aOwner;
             var aRelatedToCurrent;
             var aAllowMixedContent;
             var aNoReferrer;
             var aUserContextId;
             var aOriginPrincipal;
             var aOpener;
             if (arguments.length == 2 &&
                 arguments[1] != null &&
                 typeof arguments[1] == "object" &&
                 !(arguments[1] instanceof Ci.nsIURI)) {
               let params = arguments[1];
               aTriggeringPrincipal  = params.triggeringPrincipal;
               aReferrerURI          = params.referrerURI;
               aReferrerPolicy       = params.referrerPolicy;
               aCharset              = params.charset;
               aPostData             = params.postData;
+              aOwner                = params.ownerTab;
               aFocusNewTab          = params.focusNewTab;
               aAllowThirdPartyFixup = params.allowThirdPartyFixup;
               aFromExternal         = params.fromExternal;
               aRelatedToCurrent     = params.relatedToCurrent;
               aAllowMixedContent    = params.allowMixedContent;
               aNoReferrer           = params.noReferrer;
               aUserContextId        = params.userContextId;
               aOriginPrincipal      = params.originPrincipal;
               aOpener               = params.opener;
             }
 
+            // If we're adding tabs, we're past interrupt mode, ditch the owner.
+            if (this.mCurrentTab.owner)
+              this.mCurrentTab.owner = null;
+
             this._browsers = null; // invalidate cache
 
             var t = this.referenceTab.cloneNode(true);
 
             var blank = !aURI || aURI == "about:blank";
 
             if (!blank)
               t.setAttribute("label", aURI);
@@ -1650,16 +1670,20 @@
 
             // We start our browsers out as inactive.
             b.docShellIsActive = false;
 
             this.mStrip.collapsed = false;
 
             Services.prefs.setBoolPref("browser.tabs.forceHide", false);
 
+            // If this new tab is owned by another, assert that relationship.
+            if (aOwner)
+              t.owner = aOwner;
+
             // wire up a progress listener for the new browser object.
             var position = this.tabs.length - 1;
             var tabListener = this.mTabProgressListener(t, b, blank);
             const filter = Cc["@mozilla.org/appshell/component/browser-status-filter;1"]
                              .createInstance(Ci.nsIWebProgress);
             filter.addProgressListener(tabListener, Ci.nsIWebProgress.NOTIFY_ALL);
             b.webProgress.addProgressListener(filter, Ci.nsIWebProgress.NOTIFY_ALL);
             this.mTabListeners[position] = tabListener;
@@ -1699,16 +1723,20 @@
             // 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 || aReferrerURI ||
                  Services.prefs.getBoolPref("browser.tabs.insertAllTabsAfterCurrent")) &&
                 Services.prefs.getBoolPref("browser.tabs.insertRelatedAfterCurrent")) {
               var lastRelatedIndex = this.mLastRelatedIndex ||
                                      this.tabContainer.selectedIndex;
+              if (this.mLastRelatedIndex)
+                this.tabs[this.mLastRelatedIndex].owner = null;
+              else
+                t.owner = this.selectedTab;
               this.moveTabTo(t, ++lastRelatedIndex);
               this.mLastRelatedIndex = lastRelatedIndex;
             }
 
             if (aFocusNewTab) {
               var parentTab = this.selectedTab;
               this.selectedTab = t;
               this.mPreviousTab = parentTab;
@@ -2037,16 +2065,23 @@
             oldBrowser.webProgress.removeProgressListener(filter);
             filter.removeProgressListener(this.mTabListeners[index]);
             this.mTabFilters.splice(index, 1);
             this.mTabListeners.splice(index, 1);
 
             // We are no longer the primary content area
             oldBrowser.removeAttribute("primary");
 
+            // Remove this tab as the owner of any other tabs, since it's going away.
+            for (let tab of this.tabs) {
+              if ("owner" in tab && tab.owner == aTab)
+                // |tab| is a child of the tab we're removing, make it an orphan.
+                tab.owner = null;
+            }
+
             // Now select the new tab before nuking the old one.
             var currentIndex = this.tabContainer.selectedIndex;
 
             var newIndex = -1;
             if (currentIndex > index)
               newIndex = currentIndex - 1;
             else if (currentIndex < index)
               newIndex = currentIndex;
@@ -2057,23 +2092,30 @@
 
             if (oldBrowser == this.mCurrentBrowser)
               this.mCurrentBrowser = null;
 
             // Invalidate browsers cache, as the tab is removed from the
             // tab container.
             this._browsers = null;
 
-            // Clean up before/afterselected attributes before removing the tab
+            let owner = ("owner" in aTab) ? aTab.owner : null;
+
+            // Clean up before/after selected attributes before removing the
+            // tab.
             aTab._selected = false;
             aTab.remove();
 
             // When the current tab is removed select a new tab
             // and fire select events on tabpanels and tabs
-            if (this.mPreviousTab && (aTab == this.mCurrentTab))
+            if (owner && !owner.hidden && !owner.closing &&
+                Services.prefs.getBoolPref("browser.tabs.selectOwnerOnClose")) {
+              this.selectedTab = owner;
+            }
+            else if (this.mPreviousTab && (aTab == this.mCurrentTab))
               this.selectedTab = this.mPreviousTab;
             else {
               this.tabContainer.selectedIndex = newIndex;
 
               // We need to explicitly clear this, because updateCurrentBrowser
               // doesn't get called for a background tab
               this.mPreviousTab = null;
             }