--- a/browser/base/content/browser.js
+++ b/browser/base/content/browser.js
@@ -1229,16 +1229,17 @@ var gBrowserInit = {
     window.QueryInterface(Ci.nsIInterfaceRequestor)
           .getInterface(Ci.nsIWebNavigation)
           .QueryInterface(Ci.nsIDocShellTreeItem).treeOwner
           .QueryInterface(Ci.nsIInterfaceRequestor)
           .getInterface(Ci.nsIXULWindow)
           .XULBrowserWindow = window.XULBrowserWindow;
     window.QueryInterface(Ci.nsIDOMChromeWindow).browserDOMWindow =
       new nsBrowserAccess();
+    BrowserWindowTracker.track(window);
 
     let initBrowser = gBrowser.initialBrowser;
 
     // remoteType and sameProcessAsFrameLoader are passed through to
     // updateBrowserRemoteness as part of an options object, which itself defaults
     // to an empty object. So defaulting them to undefined here will cause the
     // default behavior in updateBrowserRemoteness if they don't get set.
     let isRemote = gMultiProcessBrowser;
@@ -1485,18 +1486,16 @@ var gBrowserInit = {
       document.getElementById("textfieldDirection-swap").hidden = false;
     }
 
     // Setup click-and-hold gestures access to the session history
     // menus if global click-and-hold isn't turned on
     if (!getBoolPref("ui.click_hold_context_menus", false))
       SetClickAndHoldHandlers();
 
-    BrowserWindowTracker.track(window);
-
     PlacesToolbarHelper.init();
 
     ctrlTab.readPref();
     Services.prefs.addObserver(ctrlTab.prefName, ctrlTab);
 
     // The object handling the downloads indicator is initialized here in the
     // delayed startup function, but the actual indicator element is not loaded
     // unless there are downloads to be displayed.

--- a/browser/modules/BrowserWindowTracker.jsm
+++ b/browser/modules/BrowserWindowTracker.jsm
@@ -8,32 +8,29 @@
  */
 
 var EXPORTED_SYMBOLS = ["BrowserWindowTracker"];
 
 ChromeUtils.import("resource://gre/modules/XPCOMUtils.jsm");
 ChromeUtils.import("resource://gre/modules/Services.jsm");
 
 // Lazy getters
-XPCOMUtils.defineLazyServiceGetter(this, "_focusManager",
-                                   "@mozilla.org/focus-manager;1",
-                                   "nsIFocusManager");
 XPCOMUtils.defineLazyModuleGetters(this, {
   AppConstants: "resource://gre/modules/AppConstants.jsm",
   PrivateBrowsingUtils: "resource://gre/modules/PrivateBrowsingUtils.jsm"
 });
 
 // Constants
 const TAB_EVENTS = ["TabBrowserInserted", "TabSelect"];
-const WINDOW_EVENTS = ["activate", "unload"];
+const WINDOW_EVENTS = ["activate", "sizemodechange", "unload"];
 const DEBUG = false;
 
 // Variables
-var _lastFocusedWindow = null;
 var _lastTopLevelWindowID = 0;
+var _trackedWindows = [];
 
 // Global methods
 function debug(s) {
   if (DEBUG) {
     dump("-*- UpdateTopLevelContentWindowIDHelper: " + s + "\n");
   }
 }
 
@@ -49,95 +46,109 @@ function _updateCurrentContentOuterWindo
   _lastTopLevelWindowID = browser.outerWindowID;
   let windowIDWrapper = Cc["@mozilla.org/supports-PRUint64;1"]
                           .createInstance(Ci.nsISupportsPRUint64);
   windowIDWrapper.data = _lastTopLevelWindowID;
   Services.obs.notifyObservers(windowIDWrapper,
                                "net:current-toplevel-outer-content-windowid");
 }
 
-function _handleEvent(aEvent) {
-  switch (aEvent.type) {
+function _handleEvent(event) {
+  switch (event.type) {
     case "TabBrowserInserted":
-      if (aEvent.target.ownerGlobal.gBrowser.selectedBrowser === aEvent.target.linkedBrowser) {
-        _updateCurrentContentOuterWindowID(aEvent.target.linkedBrowser);
+      if (event.target.ownerGlobal.gBrowser.selectedBrowser === event.target.linkedBrowser) {
+        _updateCurrentContentOuterWindowID(event.target.linkedBrowser);
       }
       break;
     case "TabSelect":
-      _updateCurrentContentOuterWindowID(aEvent.target.linkedBrowser);
+      _updateCurrentContentOuterWindowID(event.target.linkedBrowser);
       break;
     case "activate":
-      WindowHelper.onActivate(aEvent.target);
+      WindowHelper.onActivate(event.target);
+      break;
+    case "sizemodechange":
+      WindowHelper.onSizemodeChange(event.target);
       break;
     case "unload":
-      WindowHelper.removeWindow(aEvent.currentTarget);
+      WindowHelper.removeWindow(event.currentTarget);
       break;
   }
 }
 
 function _handleMessage(message) {
   let browser = message.target;
   if (message.name === "Browser:Init" &&
       browser === browser.ownerGlobal.gBrowser.selectedBrowser) {
     _updateCurrentContentOuterWindowID(browser);
   }
 }
 
+function _trackWindowOrder(window) {
+  _trackedWindows.splice(window.windowState == window.STATE_MINIMIZED ?
+    _trackedWindows.length - 1 : 0, 0, window);
+}
+
+function _untrackWindowOrder(window) {
+  let idx = _trackedWindows.indexOf(window);
+  if (idx >= 0)
+    _trackedWindows.splice(idx, 1);
+}
+
 // Methods that impact a window. Put into single object for organization.
 var WindowHelper = {
   addWindow(window) {
     // Add event listeners
     TAB_EVENTS.forEach(function(event) {
       window.gBrowser.tabContainer.addEventListener(event, _handleEvent);
     });
     WINDOW_EVENTS.forEach(function(event) {
       window.addEventListener(event, _handleEvent);
     });
 
     let messageManager = window.getGroupMessageManager("browsers");
     messageManager.addMessageListener("Browser:Init", _handleMessage);
 
-    // This gets called AFTER activate event, so if this is the focused window
-    // we want to activate it.
-    if (window == _focusManager.activeWindow)
-      this.handleFocusedWindow(window);
+    _trackWindowOrder(window);
 
     // Update the selected tab's content outer window ID.
     _updateCurrentContentOuterWindowID(window.gBrowser.selectedBrowser);
   },
 
   removeWindow(window) {
-    if (window == _lastFocusedWindow)
-      _lastFocusedWindow = null;
+    _untrackWindowOrder(window);
 
     // Remove the event listeners
     TAB_EVENTS.forEach(function(event) {
       window.gBrowser.tabContainer.removeEventListener(event, _handleEvent);
     });
     WINDOW_EVENTS.forEach(function(event) {
       window.removeEventListener(event, _handleEvent);
     });
 
     let messageManager = window.getGroupMessageManager("browsers");
     messageManager.removeMessageListener("Browser:Init", _handleMessage);
   },
 
   onActivate(window, hasFocus) {
     // If this window was the last focused window, we don't need to do anything
-    if (window == _lastFocusedWindow)
+    if (window == _trackedWindows[0])
       return;
 
-    this.handleFocusedWindow(window);
+    _untrackWindowOrder(window);
+    _trackWindowOrder(window);
 
     _updateCurrentContentOuterWindowID(window.gBrowser.selectedBrowser);
   },
 
-  handleFocusedWindow(window) {
-    // window is now focused
-    _lastFocusedWindow = window;
+  onSizemodeChange(window) {
+    if (window.windowState == window.STATE_MINIMIZED) {
+      // Make sure to have the minimized window at the end of the list.
+      _untrackWindowOrder(window);
+      _trackedWindows.push(window);
+    }
   },
 
   getTopWindow(options) {
     let checkPrivacy = typeof options == "object" &&
                        "private" in options;
 
     let allowPopups = typeof options == "object" && !!options.allowPopups;
 
@@ -187,12 +198,26 @@ this.BrowserWindowTracker = {
    *            only, false to restrict the search to non-private only.
    *            Omit the property to search in both groups.
    *        * allowPopups: true if popup windows are permissable.
    */
   getTopWindow(options) {
     return WindowHelper.getTopWindow(options);
   },
 
+  /**
+   * Iterator property that yields window objects by z-index, in reverse order.
+   * This means that the lastly focused window will the first item that is yielded.
+   * Note: we only know the order of windows we're actively tracking, which
+   * basically means _only_ browser windows.
+   */
+  orderedWindows: {
+    * [Symbol.iterator]() {
+      for (let window of _trackedWindows)
+        yield window;
+    }
+  },
+
   track(window) {
     return WindowHelper.addWindow(window);
   }
 };
+Object.freeze(this.BrowserWindowTracker);

--- a/browser/modules/test/browser/browser.ini
+++ b/browser/modules/test/browser/browser.ini
@@ -8,16 +8,17 @@ support-files =
 [browser_BrowserUITelemetry_buckets.js]
 skip-if = !e10s # Bug 1373549
 [browser_BrowserUITelemetry_defaults.js]
 skip-if = !e10s # Bug 1373549
 [browser_BrowserUITelemetry_sidebar.js]
 skip-if = !e10s # Bug 1373549
 [browser_BrowserUITelemetry_syncedtabs.js]
 skip-if = !e10s # Bug 1373549
+[browser_BrowserWindowTracker.js]
 [browser_ContentSearch.js]
 support-files =
   contentSearch.js
   contentSearchBadImage.xml
   contentSearchSuggestions.sjs
   contentSearchSuggestions.xml
   !/browser/components/search/test/head.js
   !/browser/components/search/test/testEngine.xml

new file mode 100644
--- /dev/null
+++ b/browser/modules/test/browser/browser_BrowserWindowTracker.js
@@ -0,0 +1,108 @@
+"use strict";
+
+ChromeUtils.import("resource:///modules/BrowserWindowTracker.jsm");
+ChromeUtils.import("resource://gre/modules/AppConstants.jsm");
+
+const TEST_WINDOW = window;
+
+async function withOpenWindows(amount, cont) {
+  let windows = [];
+  for (let i = 0; i < amount; ++i) {
+    windows.push(await BrowserTestUtils.openNewBrowserWindow());
+  }
+  await cont(windows);
+  await Promise.all(windows.map(window => BrowserTestUtils.closeWindow(window)));
+}
+
+add_task(async function test_getTopWindow() {
+  await withOpenWindows(5, async function(windows) {
+    // Without options passed in.
+    let window = BrowserWindowTracker.getTopWindow();
+    let expectedMostRecentIndex = windows.length - 1;
+    Assert.equal(window, windows[expectedMostRecentIndex],
+      "Last opened window should be the most recent one.");
+
+    // Mess with the focused window things a bit.
+    for (let idx of [3, 1]) {
+      let promise = BrowserTestUtils.waitForEvent(windows[idx], "activate");
+      windows[idx].focus();
+      await promise;
+      window = BrowserWindowTracker.getTopWindow();
+      Assert.equal(window, windows[idx], "Lastly focused window should be the most recent one.");
+      // For this test it's useful to keep the array of created windows in order.
+      windows.splice(idx, 1);
+      windows.push(window);
+    }
+    // Update the pointer to the most recent opened window.
+    expectedMostRecentIndex = windows.length - 1;
+
+    // With 'private' option.
+    window = BrowserWindowTracker.getTopWindow({ private: true });
+    Assert.equal(window, null, "No private windows opened yet.");
+    window = BrowserWindowTracker.getTopWindow({ private: 1 });
+    Assert.equal(window, null, "No private windows opened yet.");
+    windows.push(await BrowserTestUtils.openNewBrowserWindow({ private: true }));
+    ++expectedMostRecentIndex;
+    window = BrowserWindowTracker.getTopWindow({ private: true });
+    Assert.equal(window, windows[expectedMostRecentIndex], "Private window available.");
+    window = BrowserWindowTracker.getTopWindow({ private: 1 });
+    Assert.equal(window, windows[expectedMostRecentIndex], "Private window available.");
+    window = BrowserWindowTracker.getTopWindow({ private: false });
+    Assert.equal(window, windows[expectedMostRecentIndex - 1],
+      "Private window available, but should not be returned.");
+
+    // With 'allowPopups' option.
+    window = BrowserWindowTracker.getTopWindow({ allowPopups: true });
+    Assert.equal(window, windows[expectedMostRecentIndex],
+      "Window focused before the private window should be the most recent one.");
+    window = BrowserWindowTracker.getTopWindow({ allowPopups: false });
+    Assert.equal(window, windows[expectedMostRecentIndex],
+      "Window focused before the private window should be the most recent one.");
+    let popupWindowPromise = BrowserTestUtils.waitForNewWindow();
+    ContentTask.spawn(gBrowser.selectedBrowser, null, function() {
+      let features = "location=no, personalbar=no, toolbar=no, scrollbars=no, menubar=no, status=no";
+      content.window.open("about:blank", "_blank", features);
+    });
+    let popupWindow = await popupWindowPromise;
+    window = BrowserWindowTracker.getTopWindow({ allowPopups: true });
+    Assert.equal(window, popupWindow,
+      "The popup window should be the most recent one, when requested.");
+    window = BrowserWindowTracker.getTopWindow({ allowPopups: false });
+    Assert.equal(window, windows[expectedMostRecentIndex],
+      "Window focused before the popup window should be the most recent one.");
+    popupWindow.close();
+  });
+});
+
+add_task(async function test_orderedWindows() {
+  await withOpenWindows(10, async function(windows) {
+    let ordered = [...BrowserWindowTracker.orderedWindows].filter(w => w != TEST_WINDOW);
+    Assert.deepEqual([9, 8, 7, 6, 5, 4, 3, 2, 1, 0], ordered.map(w => windows.indexOf(w)),
+      "Order of opened windows should be as opened.");
+
+    // Mess with the focused window things a bit.
+    for (let idx of [4, 6, 1]) {
+      let promise = BrowserTestUtils.waitForEvent(windows[idx], "activate");
+      windows[idx].focus();
+      await promise;
+    }
+
+    let ordered2 = [...BrowserWindowTracker.orderedWindows].filter(w => w != TEST_WINDOW);
+    // After the shuffle, we expect window '1' to be the top-most window, because
+    // it was the last one we called focus on. Then '6', the window we focused
+    // before-last, followed by '4'. The order of the other windows remains
+    // unchanged.
+    let expected = [1, 6, 4, 9, 8, 7, 5, 3, 2, 0];
+    Assert.deepEqual(expected, ordered2.map(w => windows.indexOf(w)),
+      "After shuffle of focused windows, the order should've changed.");
+
+    // Minimizing a window should put it at the end of the ordered list of windows.
+    let promise = BrowserTestUtils.waitForEvent(windows[9], "sizemodechange");
+    windows[9].minimize();
+    await promise;
+
+    let ordered3 = [...BrowserWindowTracker.orderedWindows].filter(w => w != TEST_WINDOW);
+    Assert.deepEqual([1, 6, 4, 8, 7, 5, 3, 2, 0, 9], ordered3.map(w => windows.indexOf(w)),
+      "When a window is minimized, the order should've changed.");
+  });
+});