The Tor Browser: browser/components/sessionstore/test/browser_354894_perwindowpb.js@6474c204b198 (annotated)

browser/components/sessionstore/test/browser_354894_perwindowpb.js@6474c204b198 (annotated)

browser/components/sessionstore/test/browser_354894_perwindowpb.js

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /* 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/. */
 /**
  * Checks that restoring the last browser window in session is actually
  * working:
  *  1.1) Open a new browser window
  *  1.2) Add some tabs
  *  1.3) Close that window
  *  1.4) Opening another window
  *  --> State is restored
  *
  *  2.1) Open a new browser window
  *  2.2) Add some tabs
  *  2.3) Enter private browsing mode
  *  2.4) Close the window while still in private browsing mode
  *  2.5) Opening a new window
  *  --> State is not restored, because private browsing mode is still active
  *  2.6) Leaving private browsing mode
  *  2.7) Open another window
  *  --> State (that was before entering PBM) is restored
  *
  *  3.1) Open a new browser window
  *  3.2) Add some tabs
  *  3.4) Open some popups
  *  3.5) Add another tab to one popup (so that it gets stored) and close it again
  *  3.5) Close the browser window
  *  3.6) Open another browser window
  *  --> State of the closed browser window, but not of the popup, is restored
  *
  *  4.1) Open a popup
  *  4.2) Add another tab to the popup (so that it gets stored) and close it again
  *  4.3) Open a window
  *  --> Nothing at all should be restored
  *
  *  5.1) Open two browser windows and close them again
  *  5.2) undoCloseWindow() one
  *  5.3) Open another browser window
  *  --> Nothing at all should be restored
  *
  * Checks the new notifications are correctly posted and processed, that is
  * for each successful -requested a -granted is received, but omitted if
  *  -requested was cnceled
  * Said notifications are:
  *  - browser-lastwindow-close-requested
  *  - browser-lastwindow-close-granted
  * Tests are:
  *  6) Cancel closing when first observe a -requested
  *  --> Window is kept open
  *  7) Count the number of notifications
  *  --> count(-requested) == count(-granted) + 1
  *  --> (The first -requested was canceled, so off-by-one)
  *  8) (Mac only) Mac version of Test 5 additionally preparing Test 6
  *
  * @see https://bugzilla.mozilla.org/show_bug.cgi?id=354894
  * @note It is implicitly tested that restoring the last window works when
  * non-browser windows are around. The "Run Tests" window as well as the main
  * browser window (wherein the test code gets executed) won't be considered
  * browser windows. To achiveve this said main browser window has it's windowtype
  * attribute modified so that it's not considered a browser window any longer.
  * This is crucial, because otherwise there would be two browser windows around,
  * said main test window and the one opened by the tests, and hence the new
  * logic wouldn't be executed at all.
  * @note Mac only tests the new notifications, as restoring the last window is
  * not enabled on that platform (platform shim; the application is kept running
  * although there are no windows left)
  * @note There is a difference when closing a browser window with
  * BrowserTryToCloseWindow() as opposed to close(). The former will make
  * nsSessionStore restore a window next time it gets a chance and will post
  * notifications. The latter won't.
  */
 function browserWindowsCount(expected, msg) {
   if (typeof expected == "number")
     expected = [expected, expected];
   let count = 0;
   let e = Services.wm.getEnumerator("navigator:browser");
   while (e.hasMoreElements()) {
     if (!e.getNext().closed)
       ++count;
   }
   is(count, expected[0], msg + " (nsIWindowMediator)");
   let state = ss.getBrowserState();
   is(JSON.parse(state).windows.length, expected[1], msg + " (getBrowserState)");
 }
 function test() {
   browserWindowsCount(1, "Only one browser window should be open initially");
   waitForExplicitFinish();
   // This test takes some time to run, and it could timeout randomly.
   // So we require a longer timeout. See bug 528219.
   requestLongerTimeout(2);
   // Some urls that might be opened in tabs and/or popups
   // Do not use about:blank:
   // That one is reserved for special purposes in the tests
   const TEST_URLS = ["about:mozilla", "about:buildconfig"];
   // Number of -request notifications to except
   // remember to adjust when adding new tests
   const NOTIFICATIONS_EXPECTED = 6;
   // Window features of popup windows
   const POPUP_FEATURES = "toolbar=no,resizable=no,status=no";
   // Window features of browser windows
   const CHROME_FEATURES = "chrome,all,dialog=no";
   // Store the old window type for cleanup
   let oldWinType = "";
   // Store the old tabs.warnOnClose pref so that we may reset it during
   // cleanup
   let oldWarnTabsOnClose = gPrefService.getBoolPref("browser.tabs.warnOnClose");
   // Observe these, and also use to count the number of hits
   let observing = {
     "browser-lastwindow-close-requested": 0,
     "browser-lastwindow-close-granted": 0
   };
   /**
    * Helper: Will observe and handle the notifications for us
    */
   let hitCount = 0;
   function observer(aCancel, aTopic, aData) {
     // count so that we later may compare
     observing[aTopic]++;
     // handle some tests
     if (++hitCount == 1) {
       // Test 6
       aCancel.QueryInterface(Ci.nsISupportsPRBool).data = true;
     }
   }
   /**
    * Helper: Sets prefs as the testsuite requires
    * @note Will be reset in cleanTestSuite just before finishing the tests
    */
   function setPrefs() {
     gPrefService.setIntPref("browser.startup.page", 3);
     gPrefService.setBoolPref(
       "browser.privatebrowsing.keep_current_session",
       true
     );
     gPrefService.setBoolPref("browser.tabs.warnOnClose", false);
   }
   /**
    * Helper: Sets up this testsuite
    */
   function setupTestsuite(testFn) {
     // Register our observers
     for (let o in observing)
       Services.obs.addObserver(observer, o, false);
     // Make the main test window not count as a browser window any longer
     oldWinType = document.documentElement.getAttribute("windowtype");
     document.documentElement.setAttribute("windowtype", "navigator:testrunner");
   }
   /**
    * Helper: Cleans up behind the testsuite
    */
   function cleanupTestsuite(callback) {
     // Finally remove observers again
     for (let o in observing)
       Services.obs.removeObserver(observer, o);
     // Reset the prefs we touched
     [
       "browser.startup.page",
       "browser.privatebrowsing.keep_current_session"
     ].forEach(function (pref) {
       if (gPrefService.prefHasUserValue(pref))
         gPrefService.clearUserPref(pref);
     });
     gPrefService.setBoolPref("browser.tabs.warnOnClose", oldWarnTabsOnClose);
     // Reset the window type
     document.documentElement.setAttribute("windowtype", oldWinType);
   }
   /**
    * Helper: sets the prefs and a new window with our test tabs
    */
   function setupTestAndRun(aIsPrivateWindow, testFn) {
     // Prepare the prefs
     setPrefs();
     // Prepare a window; open it and add more tabs
     let options = {};
     if (aIsPrivateWindow) {
       options = {private: true};
     }
     whenNewWindowLoaded(options, function (newWin) {
       TEST_URLS.forEach(function (url) {
         newWin.gBrowser.addTab(url);
       });
       executeSoon(() => testFn(newWin));
     });
   }
   /**
    * Test 1: Normal in-session restore
    * @note: Non-Mac only
    */
   function testOpenCloseNormal(nextFn) {
     setupTestAndRun(false, function(newWin) {
       // Close the window
       // window.close doesn't push any close events,
       // so use BrowserTryToCloseWindow
       newWin.BrowserTryToCloseWindow();
       // The first request to close is denied by our observer (Test 6)
       ok(!newWin.closed, "First close request was denied");
       if (!newWin.closed) {
         newWin.BrowserTryToCloseWindow();
         ok(newWin.closed, "Second close request was granted");
       }
       // Open a new window
       // The previously closed window should be restored
       whenNewWindowLoaded({}, function (newWin) {
         is(newWin.gBrowser.browsers.length, TEST_URLS.length + 1,
            "Restored window in-session with otherpopup windows around");
         // Cleanup
         newWin.close();
         // Next please
         executeSoon(nextFn);
       });
     });
   }
   /**
    * Test 2: PrivateBrowsing in-session restore
    * @note: Non-Mac only
    */
   function testOpenClosePrivateBrowsing(nextFn) {
     setupTestAndRun(false, function(newWin) {
       // Close the window
       newWin.BrowserTryToCloseWindow();
       // Enter private browsing mode
       // Open a new window.
       // The previously closed window should NOT be restored
       whenNewWindowLoaded({private: true}, function (newWin) {
         is(newWin.gBrowser.browsers.length, 1,
            "Did not restore in private browing mode");
         // Cleanup
         newWin.BrowserTryToCloseWindow();
         // Exit private browsing mode again
         whenNewWindowLoaded({}, function (newWin) {
           is(newWin.gBrowser.browsers.length, TEST_URLS.length + 1,
              "Restored after leaving private browsing again");
           newWin.close();
           // Next please
           executeSoon(nextFn);
         });
       });
     });
   }
   /**
    * Test 3: Open some popup windows to check those aren't restored, but
    *         the browser window is
    * @note: Non-Mac only
    */
   function testOpenCloseWindowAndPopup(nextFn) {
     setupTestAndRun(false, function(newWin) {
       // open some popups
       let popup = openDialog(location, "popup", POPUP_FEATURES, TEST_URLS[0]);
       let popup2 = openDialog(location, "popup2", POPUP_FEATURES, TEST_URLS[1]);
       popup2.addEventListener("load", function() {
         popup2.removeEventListener("load", arguments.callee, false);
         popup2.gBrowser.addEventListener("load", function() {
           popup2.gBrowser.removeEventListener("load", arguments.callee, true);
           popup2.gBrowser.addTab(TEST_URLS[0]);
           // close the window
           newWin.BrowserTryToCloseWindow();
           // Close the popup window
           // The test is successful when not this popup window is restored
           // but instead newWin
           popup2.close();
           // open a new window the previously closed window should be restored to
           whenNewWindowLoaded({}, function (newWin) {
             is(newWin.gBrowser.browsers.length, TEST_URLS.length + 1,
                "Restored window and associated tabs in session");
             // Cleanup
             newWin.close();
             popup.close();
             // Next please
             executeSoon(nextFn);
           });
         }, true);
       }, false);
     });
   }
   /**
    * Test 4: Open some popup window to check it isn't restored.
    *         Instead nothing at all should be restored
    * @note: Non-Mac only
    */
   function testOpenCloseOnlyPopup(nextFn) {
     // prepare the prefs
     setPrefs();
     // This will cause nsSessionStore to restore a window the next time it
     // gets a chance.
     let popup = openDialog(location, "popup", POPUP_FEATURES, TEST_URLS[1]);
     popup.addEventListener("load", function() {
       this.removeEventListener("load", arguments.callee, true);
       is(popup.gBrowser.browsers.length, 1,
          "Did not restore the popup window (1)");
       popup.BrowserTryToCloseWindow();
       // Real tests
       popup = openDialog(location, "popup", POPUP_FEATURES, TEST_URLS[1]);
       popup.addEventListener("load", function() {
         popup.removeEventListener("load", arguments.callee, false);
         popup.gBrowser.addEventListener("load", function() {
           popup.gBrowser.removeEventListener("load", arguments.callee, true);
           popup.gBrowser.addTab(TEST_URLS[0]);
           is(popup.gBrowser.browsers.length, 2,
              "Did not restore to the popup window (2)");
           // Close the popup window
           // The test is successful when not this popup window is restored
           // but instead a new window is opened without restoring anything
           popup.close();
           whenNewWindowLoaded({}, function (newWin) {
             isnot(newWin.gBrowser.browsers.length, 2,
                   "Did not restore the popup window");
             is(TEST_URLS.indexOf(newWin.gBrowser.browsers[0].currentURI.spec), -1,
                "Did not restore the popup window (2)");
             // Cleanup
             newWin.close();
             // Next please
             executeSoon(nextFn);
           });
         }, true);
       }, false);
     }, true);
   }
     /**
    * Test 5: Open some windows and do undoCloseWindow. This should prevent any
    *         restoring later in the test
    * @note: Non-Mac only
    */
   function testOpenCloseRestoreFromPopup(nextFn) {
     setupTestAndRun(false, function(newWin) {
       setupTestAndRun(false, function(newWin2) {
         newWin.BrowserTryToCloseWindow();
         newWin2.BrowserTryToCloseWindow();
         browserWindowsCount([0, 1], "browser windows while running testOpenCloseRestoreFromPopup");
         newWin = undoCloseWindow(0);
         whenNewWindowLoaded({}, function (newWin2) {
           is(newWin2.gBrowser.browsers.length, 1,
              "Did not restore, as undoCloseWindow() was last called");
           is(TEST_URLS.indexOf(newWin2.gBrowser.browsers[0].currentURI.spec), -1,
              "Did not restore, as undoCloseWindow() was last called (2)");
           browserWindowsCount([2, 3], "browser windows while running testOpenCloseRestoreFromPopup");
           // Cleanup
           newWin.close();
           newWin2.close();
           browserWindowsCount([0, 1], "browser windows while running testOpenCloseRestoreFromPopup");
           // Next please
           executeSoon(nextFn);
         });
       });
     });
   }
   /**
    * Test 7: Check whether the right number of notifications was received during
    *         the tests
    */
   function testNotificationCount(nextFn) {
     is(observing["browser-lastwindow-close-requested"], NOTIFICATIONS_EXPECTED,
        "browser-lastwindow-close-requested notifications observed");
     // -request must be one more as we cancel the first one we hit,
     // and hence won't produce a corresponding -grant
     // @see observer.observe
     is(observing["browser-lastwindow-close-requested"],
        observing["browser-lastwindow-close-granted"] + 1,
        "Notification count for -request and -grant matches");
     executeSoon(nextFn);
   }
   /**
    * Test 8: Test if closing can be denied on Mac
    *         Futhermore prepares the testNotificationCount test (Test 7)
    * @note: Mac only
    */
   function testMacNotifications(nextFn, iteration) {
     iteration = iteration || 1;
     setupTestAndRun(false, function(newWin) {
       // close the window
       // window.close doesn't push any close events,
       // so use BrowserTryToCloseWindow
       newWin.BrowserTryToCloseWindow();
       if (iteration == 1) {
         ok(!newWin.closed, "First close attempt denied");
         if (!newWin.closed) {
           newWin.BrowserTryToCloseWindow();
           ok(newWin.closed, "Second close attempt granted");
         }
       }
       if (iteration < NOTIFICATIONS_EXPECTED - 1) {
         executeSoon(function() testMacNotifications(nextFn, ++iteration));
       }
       else {
         executeSoon(nextFn);
       }
     });
   }
   // Execution starts here
   setupTestsuite();
   if (navigator.platform.match(/Mac/)) {
     // Mac tests
     testMacNotifications(function () {
       testNotificationCount(function () {
         cleanupTestsuite();
         browserWindowsCount(1, "Only one browser window should be open eventually");
         finish();
       });
     });
   }
   else {
     // Non-Mac Tests
     testOpenCloseNormal(function () {
       browserWindowsCount([0, 1], "browser windows after testOpenCloseNormal");
       testOpenClosePrivateBrowsing(function () {
         browserWindowsCount([0, 1], "browser windows after testOpenClosePrivateBrowsing");
         testOpenCloseWindowAndPopup(function () {
           browserWindowsCount([0, 1], "browser windows after testOpenCloseWindowAndPopup");
           testOpenCloseOnlyPopup(function () {
             browserWindowsCount([0, 1], "browser windows after testOpenCloseOnlyPopup");
             testOpenCloseRestoreFromPopup(function () {
               browserWindowsCount([0, 1], "browser windows after testOpenCloseRestoreFromPopup");
               testNotificationCount(function () {
                 cleanupTestsuite();
                 browserWindowsCount(1, "browser windows after testNotificationCount");
                 finish();
               });
             });
           });
         });
       });
     });
   }
 }