Split OptionsPage into Page and PageManager

chrome/browser/ui/webui/options/options_browsertest.js

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 GEN('#include "chrome/browser/ui/webui/options/options_browsertest.h"');
 
 /** @const */ var MANAGED_USERS_PREF = 'profile.managed_users';
 
 /**
  * Wait for the method specified by |methodName|, on the |object| object, to be
@@ skipping 148 matching lines @@
  * interstitial is pressed, otherwise the abort button is pressed.
  * @param {boolean} confirmInterstitial Whether to confirm the Do Not Track
  *     interstitial.
  */
 OptionsWebUITest.prototype.testDoNotTrackInterstitial =
     function(confirmInterstitial) {
   Preferences.prefsFetchedCallback({'enable_do_not_track': {'value': false}});
   var buttonToClick = confirmInterstitial ? $('do-not-track-confirm-ok') :
                                             $('do-not-track-confirm-cancel');
   var dntCheckbox = $('do-not-track-enabled');
-  var dntOverlay = OptionsPage.registeredOverlayPages['donottrackconfirm'];
+  var dntOverlay = PageManager.registeredOverlayPages['donottrackconfirm'];
   assertFalse(dntCheckbox.checked);
 
   var visibleChangeCounter = 0;
   var visibleChangeHandler = function() {
     ++visibleChangeCounter;
     switch (visibleChangeCounter) {
       case 1:
         window.setTimeout(function() {
           assertTrue(dntOverlay.visible);
           buttonToClick.click();
@@ skipping 32 matching lines @@
 TEST_F('OptionsWebUITest', 'EnableDoNotTrackAndCancelInterstitial',
        function() {
   this.testDoNotTrackInterstitial(false);
 });
 
 // Check that the "Do not Track" preference can be correctly disabled.
 // In order to do that, we need to enable it first.
 TEST_F('OptionsWebUITest', 'EnableAndDisableDoNotTrack', function() {
   Preferences.prefsFetchedCallback({'enable_do_not_track': {'value': false}});
   var dntCheckbox = $('do-not-track-enabled');
-  var dntOverlay = OptionsPage.registeredOverlayPages.donottrackconfirm;
+  var dntOverlay = PageManager.registeredOverlayPages.donottrackconfirm;
   assertFalse(dntCheckbox.checked);
 
   var visibleChangeCounter = 0;
   var visibleChangeHandler = function() {
     ++visibleChangeCounter;
     switch (visibleChangeCounter) {
       case 1:
         window.setTimeout(function() {
           assertTrue(dntOverlay.visible);
           $('do-not-track-confirm-ok').click();
@@ skipping 29 matching lines @@
 
   dntCheckbox.click();
 });
 
 // Verify that preventDefault() is called on 'Enter' keydown events that trigger
 // the default button. If this doesn't happen, other elements that may get
 // focus (by the overlay closing for instance), will execute in addition to the
 // default button. See crbug.com/268336.
 TEST_F('OptionsWebUITest', 'EnterPreventsDefault', function() {
   var page = HomePageOverlay.getInstance();
-  OptionsPage.showPageByName(page.name);
+  PageManager.showPageByName(page.name);
   var event = new KeyboardEvent('keydown', {
     'bubbles': true,
     'cancelable': true,
     'keyIdentifier': 'Enter'
   });
   assertFalse(event.defaultPrevented);
   page.pageDiv.dispatchEvent(event);
   assertTrue(event.defaultPrevented);
   testDone();
 });
@@ skipping 16 matching lines @@
 
   document.addEventListener('webkitTransitionEnd', function(e) {
     if (e.target != overlay)
       return;
 
     assertFalse(overlay.classList.contains('transparent'));
     expectEquals(numFrozenPages, frozenPages.length);
     testDone();
   });
 
-  OptionsPage.navigateToPage(overlayName);
+  PageManager.showPageByName(overlayName);
   var numFrozenPages = frozenPages.length;
   expectGT(numFrozenPages, 0);
 });
 
 GEN('#if defined(OS_CHROMEOS)');
 // Verify that range inputs respond to touch events. Currently only Chrome OS
 // uses slider options.
 TEST_F('OptionsWebUITest', 'RangeInputHandlesTouchEvents', function() {
   this.mockHandler.expects(once()).setIntegerPref([
     'settings.touchpad.sensitivity2', 1]);
@@ skipping 99 matching lines @@
    * @param {!Array.<string>} expectedPages An array of page names expected to
    *     be open, with the topmost listed last.
    * @param {string=} opt_expectedUrl The URL path, including hash, expected to
    *     be open. If undefined, the topmost (last) page name in |expectedPages|
    *     will be used. In either case, 'chrome://settings-frame/' will be
    *     prepended.
    * @private
    */
   verifyOpenPages_: function(expectedPages, opt_expectedUrl) {
     // Check the topmost page.
-    expectEquals(null, OptionsPage.getVisibleBubble());
-    var currentPage = OptionsPage.getTopmostVisiblePage();
+    expectEquals(null, PageManager.getVisibleBubble());
+    var currentPage = PageManager.getTopmostVisiblePage();
 
     var lastExpected = expectedPages[expectedPages.length - 1];
     expectEquals(lastExpected, currentPage.name);
     // We'd like to check the title too, but we have to load the settings-frame
     // instead of the outer settings page in order to have access to
     // OptionsPage, and setting the title from within the settings-frame fails
     // because of cross-origin access restrictions.
     // TODO(pamg): Add a test fixture that loads chrome://settings and uses
     // UI elements to access sub-pages, so we can test the titles and
     // search-page URLs.
     var expectedUrl = (typeof opt_expectedUrl == 'undefined') ?
         lastExpected : opt_expectedUrl;
     var fullExpectedUrl = 'chrome://settings-frame/' + expectedUrl;
     expectEquals(fullExpectedUrl, window.location.href);
 
     // Collect open pages.
-    var allPageNames = Object.keys(OptionsPage.registeredPages).concat(
-                       Object.keys(OptionsPage.registeredOverlayPages));
+    var allPageNames = Object.keys(PageManager.registeredPages).concat(
+                       Object.keys(PageManager.registeredOverlayPages));
     var openPages = [];
     for (var i = 0; i < allPageNames.length; ++i) {
       var name = allPageNames[i];
-      var page = OptionsPage.registeredPages[name] ||
-                 OptionsPage.registeredOverlayPages[name];
+      var page = PageManager.registeredPages[name] ||
+                 PageManager.registeredOverlayPages[name];
       if (page.visible)
         openPages.push(page.name);
     }
 
     this.compareArrays_(expectedPages, openPages, true, 'Open pages');
   },
 
   /*
    * Verifies that the correct URLs are listed in the history. Asynchronous.
    * @param {!Array.<string>} expectedHistory An array of URL paths expected to
@@ skipping 17 matching lines @@
       }
       self.compareArrays_(fullExpectedHistory, results, false, 'History');
       callback();
     };
 
     // The C++ fixture will call verifyHistoryCallback with the results.
     chrome.send('optionsTestReportHistory');
   },
 
   /**
-   * Overrides the page callbacks for the given OptionsPage overlay to verify
+   * Overrides the page callbacks for the given PageManager overlay to verify
    * that they are not called.
    * @param {Object} overlay The singleton instance of the overlay.
    * @private
    */
   prohibitChangesToOverlay_: function(overlay) {
     overlay.initializePage =
         overlay.didShowPage =
         overlay.didClosePage = function() {
           assertTrue(false,
                      'Overlay was affected when changes were prohibited.');
         };
   },
 };
 
 /**
  * Set by verifyHistory_ to incorporate a followup callback, then called by the
  * C++ fixture with the navigation history to be verified.
  * @type {Function}
  */
 OptionsWebUIExtendedTest.verifyHistoryCallback = null;
 
 // Show the search page with no query string, to fall back to the settings page.
 // Test disabled because it's flaky. crbug.com/303841
 TEST_F('OptionsWebUIExtendedTest', 'DISABLED_ShowSearchPageNoQuery',
        function() {
-  OptionsPage.showPageByName('search');
+  PageManager.showPageByName('search');
   this.verifyOpenPages_(['settings']);
   this.verifyHistory_(['settings'], testDone);
 });
 
 // Show a page without updating history.
 TEST_F('OptionsWebUIExtendedTest', 'ShowPageNoHistory', function() {
   this.verifyOpenPages_(['settings'], '');
   // There are only two main pages, 'settings' and 'search'. It's not possible
-  // to show the search page using OptionsPage.showPageByName, because it
+  // to show the search page using PageManager.showPageByName, because it
   // reverts to the settings page if it has no search text set. So we show the
   // search page by performing a search, then test showPageByName.
   $('search-field').onsearch({currentTarget: {value: 'query'}});
 
   // The settings page is also still "open" (i.e., visible), in order to show
   // the search results. Furthermore, the URL hasn't been updated in the parent
   // page, because we've loaded the chrome-settings frame instead of the whole
   // settings page, so the cross-origin call to set the URL fails.
   this.verifyOpenPages_(['settings', 'search'], 'search#query');
   var self = this;
   this.verifyHistory_(['', 'search#query'], function() {
-    OptionsPage.showPageByName('settings', false);
+    PageManager.showPageByName('settings', false);
     self.verifyOpenPages_(['settings'], 'search#query');
     self.verifyHistory_(['', 'search#query'], testDone);
   });
 });
 
 TEST_F('OptionsWebUIExtendedTest', 'ShowPageWithHistory', function() {
   // See comments for ShowPageNoHistory.
   $('search-field').onsearch({currentTarget: {value: 'query'}});
   var self = this;
   this.verifyHistory_(['', 'search#query'], function() {
-    OptionsPage.showPageByName('settings', true);
+    PageManager.showPageByName('settings', true);
     self.verifyOpenPages_(['settings'], '#query');
     self.verifyHistory_(['', 'search#query', '#query'],
                         testDone);
   });
 });
 
 TEST_F('OptionsWebUIExtendedTest', 'ShowPageReplaceHistory', function() {
   // See comments for ShowPageNoHistory.
   $('search-field').onsearch({currentTarget: {value: 'query'}});
   var self = this;
   this.verifyHistory_(['', 'search#query'], function() {
-    OptionsPage.showPageByName('settings', true, {'replaceState': true});
+    PageManager.showPageByName('settings', true, {'replaceState': true});
     self.verifyOpenPages_(['settings'], '#query');
     self.verifyHistory_(['', '#query'], testDone);
   });
 });
 
 // This should be identical to ShowPageWithHisory.
 TEST_F('OptionsWebUIExtendedTest', 'NavigateToPage', function() {
   // See comments for ShowPageNoHistory.
   $('search-field').onsearch({currentTarget: {value: 'query'}});
   var self = this;
   this.verifyHistory_(['', 'search#query'], function() {
-    OptionsPage.navigateToPage('settings');
+    PageManager.showPageByName('settings');
     self.verifyOpenPages_(['settings'], '#query');
     self.verifyHistory_(['', 'search#query', '#query'],
                         testDone);
   });
 });
 
 // Settings overlays are much more straightforward than settings pages, opening
 // normally with none of the latter's quirks in the expected history or URL.
 TEST_F('OptionsWebUIExtendedTest', 'ShowOverlayNoHistory', function() {
   // Open a layer-1 overlay, not updating history.
-  OptionsPage.showPageByName('languages', false);
+  PageManager.showPageByName('languages', false);
   this.verifyOpenPages_(['settings', 'languages'], '');
 
   var self = this;
   this.verifyHistory_([''], function() {
     // Open a layer-2 overlay for which the layer-1 is a parent, not updating
     // history.
-    OptionsPage.showPageByName('addLanguage', false);
+    PageManager.showPageByName('addLanguage', false);
     self.verifyOpenPages_(['settings', 'languages', 'addLanguage'],
                           '');
     self.verifyHistory_([''], testDone);
   });
 });
 
 TEST_F('OptionsWebUIExtendedTest', 'ShowOverlayWithHistory', function() {
   // Open a layer-1 overlay, updating history.
-  OptionsPage.showPageByName('languages', true);
+  PageManager.showPageByName('languages', true);
   this.verifyOpenPages_(['settings', 'languages']);
 
   var self = this;
   this.verifyHistory_(['', 'languages'], function() {
     // Open a layer-2 overlay, updating history.
-    OptionsPage.showPageByName('addLanguage', true);
+    PageManager.showPageByName('addLanguage', true);
     self.verifyOpenPages_(['settings', 'languages', 'addLanguage']);
     self.verifyHistory_(['', 'languages', 'addLanguage'], testDone);
   });
 });
 
 TEST_F('OptionsWebUIExtendedTest', 'ShowOverlayReplaceHistory', function() {
   // Open a layer-1 overlay, updating history.
-  OptionsPage.showPageByName('languages', true);
+  PageManager.showPageByName('languages', true);
   var self = this;
   this.verifyHistory_(['', 'languages'], function() {
     // Open a layer-2 overlay, replacing history.
-    OptionsPage.showPageByName('addLanguage', true, {'replaceState': true});
+    PageManager.showPageByName('addLanguage', true, {'replaceState': true});
     self.verifyOpenPages_(['settings', 'languages', 'addLanguage']);
     self.verifyHistory_(['', 'addLanguage'], testDone);
   });
 });
 
 // Directly show an overlay further above this page, i.e. one for which the
 // current page is an ancestor but not a parent.
 TEST_F('OptionsWebUIExtendedTest', 'ShowOverlayFurtherAbove', function() {
   // Open a layer-2 overlay directly.
-  OptionsPage.showPageByName('addLanguage', true);
+  PageManager.showPageByName('addLanguage', true);
   this.verifyOpenPages_(['settings', 'languages', 'addLanguage']);
   var self = this;
   this.verifyHistory_(['', 'addLanguage'], testDone);
 });
 
 // Directly show a layer-2 overlay for which the layer-1 overlay is not a
 // parent.
 TEST_F('OptionsWebUIExtendedTest', 'ShowUnrelatedOverlay', function() {
   // Open a layer-1 overlay.
-  OptionsPage.showPageByName('languages', true);
+  PageManager.showPageByName('languages', true);
   this.verifyOpenPages_(['settings', 'languages']);
 
   var self = this;
   this.verifyHistory_(['', 'languages'], function() {
     // Open an unrelated layer-2 overlay.
-    OptionsPage.showPageByName('cookies', true);
+    PageManager.showPageByName('cookies', true);
     self.verifyOpenPages_(['settings', 'content', 'cookies']);
     self.verifyHistory_(['', 'languages', 'cookies'], testDone);
   });
 });
 
 // Close an overlay.
 TEST_F('OptionsWebUIExtendedTest', 'CloseOverlay', function() {
   // Open a layer-1 overlay, then a layer-2 overlay on top of it.
-  OptionsPage.showPageByName('languages', true);
+  PageManager.showPageByName('languages', true);
   this.verifyOpenPages_(['settings', 'languages']);
-  OptionsPage.showPageByName('addLanguage', true);
+  PageManager.showPageByName('addLanguage', true);
   this.verifyOpenPages_(['settings', 'languages', 'addLanguage']);
 
   var self = this;
   this.verifyHistory_(['', 'languages', 'addLanguage'], function() {
     // Close the layer-2 overlay.
-    OptionsPage.closeOverlay();
+    PageManager.closeOverlay();
     self.verifyOpenPages_(['settings', 'languages']);
     self.verifyHistory_(
         ['', 'languages', 'addLanguage', 'languages'],
         function() {
       // Close the layer-1 overlay.
-      OptionsPage.closeOverlay();
+      PageManager.closeOverlay();
       self.verifyOpenPages_(['settings'], '');
       self.verifyHistory_(
           ['', 'languages', 'addLanguage', 'languages', ''],
           testDone);
     });
   });
 });
 
 // Test that closing an overlay that did not push history when opening does not
 // again push history.
 TEST_F('OptionsWebUIExtendedTest', 'CloseOverlayNoHistory', function() {
   // Open the do not track confirmation prompt.
-  OptionsPage.showPageByName('doNotTrackConfirm', false);
+  PageManager.showPageByName('doNotTrackConfirm', false);
 
   // Opening the prompt does not add to the history.
   this.verifyHistory_([''], function() {
     // Close the overlay.
-    OptionsPage.closeOverlay();
+    PageManager.closeOverlay();
     // Still no history changes.
     this.verifyHistory_([''], testDone);
   }.bind(this));
 });
 
 // Make sure an overlay isn't closed (even temporarily) when another overlay is
 // opened on top.
 TEST_F('OptionsWebUIExtendedTest', 'OverlayAboveNoReset', function() {
   // Open a layer-1 overlay.
-  OptionsPage.showPageByName('languages', true);
+  PageManager.showPageByName('languages', true);
   this.verifyOpenPages_(['settings', 'languages']);
 
   // Open a layer-2 overlay on top. This should not close 'languages'.
   this.prohibitChangesToOverlay_(options.LanguageOptions.getInstance());
-  OptionsPage.showPageByName('addLanguage', true);
+  PageManager.showPageByName('addLanguage', true);
   this.verifyOpenPages_(['settings', 'languages', 'addLanguage']);
   testDone();
 });
 
 TEST_F('OptionsWebUIExtendedTest', 'OverlayTabNavigation', function() {
   // Open a layer-1 overlay, then a layer-2 overlay on top of it.
-  OptionsPage.showPageByName('languages', true);
-  OptionsPage.showPageByName('addLanguage', true);
+  PageManager.showPageByName('languages', true);
+  PageManager.showPageByName('addLanguage', true);
   var self = this;
 
   // Go back twice, then forward twice.
   self.verifyOpenPages_(['settings', 'languages', 'addLanguage']);
   self.verifyHistory_(['', 'languages', 'addLanguage'], function() {
     window.history.back();
     waitForPopstate(function() {
       self.verifyOpenPages_(['settings', 'languages']);
       self.verifyHistory_(['', 'languages'], function() {
         window.history.back();
@@ skipping 17 matching lines @@
         });
       });
     });
   });
 });
 
 // Going "back" to an overlay that's a child of the current overlay shouldn't
 // close the current one.
 TEST_F('OptionsWebUIExtendedTest', 'OverlayBackToChild', function() {
   // Open a layer-1 overlay, then a layer-2 overlay on top of it.
-  OptionsPage.showPageByName('languages', true);
-  OptionsPage.showPageByName('addLanguage', true);
+  PageManager.showPageByName('languages', true);
+  PageManager.showPageByName('addLanguage', true);
   var self = this;
 
   self.verifyOpenPages_(['settings', 'languages', 'addLanguage']);
   self.verifyHistory_(['', 'languages', 'addLanguage'], function() {
     // Close the top overlay, then go back to it.
-    OptionsPage.closeOverlay();
+    PageManager.closeOverlay();
     self.verifyOpenPages_(['settings', 'languages']);
     self.verifyHistory_(
         ['', 'languages', 'addLanguage', 'languages'],
         function() {
       // Going back to the 'addLanguage' page should not close 'languages'.
       self.prohibitChangesToOverlay_(options.LanguageOptions.getInstance());
       window.history.back();
       waitForPopstate(function() {
         self.verifyOpenPages_(['settings', 'languages', 'addLanguage']);
         self.verifyHistory_(['', 'languages', 'addLanguage'],
                             testDone);
       });
     });
   });
 });
 
 // Going back to an unrelated overlay should close the overlay and its parent.
 TEST_F('OptionsWebUIExtendedTest', 'OverlayBackToUnrelated', function() {
   // Open a layer-1 overlay, then an unrelated layer-2 overlay.
-  OptionsPage.showPageByName('languages', true);
-  OptionsPage.showPageByName('cookies', true);
+  PageManager.showPageByName('languages', true);
+  PageManager.showPageByName('cookies', true);
   var self = this;
   self.verifyOpenPages_(['settings', 'content', 'cookies']);
   self.verifyHistory_(['', 'languages', 'cookies'], function() {
     window.history.back();
     waitForPopstate(function() {
       self.verifyOpenPages_(['settings', 'languages']);
       testDone();
     });
   });
 });
 
 // Verify history changes properly while the page is loading.
 TEST_F('OptionsWebUIExtendedTest', 'HistoryUpdatedAfterLoading', function() {
   var loc = location.href;
 
   document.documentElement.classList.add('loading');
-  assertTrue(OptionsPage.isLoading());
-  OptionsPage.navigateToPage('searchEngines');
+  assertTrue(PageManager.isLoading());
+  PageManager.showPageByName('searchEngines');
   expectNotEquals(loc, location.href);
 
   document.documentElement.classList.remove('loading');
-  assertFalse(OptionsPage.isLoading());
-  OptionsPage.showDefaultPage();
+  assertFalse(PageManager.isLoading());
+  PageManager.showDefaultPage();
   expectEquals(loc, location.href);
 
   testDone();
 });
 
 // A tip should be shown or hidden depending on whether this profile manages any
 // supervised users.
 TEST_F('OptionsWebUIExtendedTest', 'SupervisingUsers', function() {
   // We start managing no supervised users.
   assertTrue($('profiles-supervised-dashboard-tip').hidden);
@@ skipping 25 matching lines @@
   __proto__: OptionsWebUIExtendedTest.prototype,
 
   /** @override */
   browsePreload: 'chrome://settings-frame/nonexistantPage',
 };
 
 TEST_F('OptionsWebUIRedirectTest', 'TestURL', function() {
   assertEquals('chrome://settings-frame/', document.location.href);
   this.verifyHistory_([''], testDone);
 });