Options: maintain history entries on the parent frame.

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 369 matching lines @@
   /**
    * Verifies that the correct pages are currently open/visible.
    * @param {!Array.<string>} expectedPages An array of page names expected to
    *     be open, with the topmost listed last.
    * @param {string=} 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, expectedUrl) {

[Dan Beam, 2014/05/19 23:06:49]

nit: opt_expectedUrl

[davidben, 2014/05/19 23:32:28]

Done.

     // Check the topmost page.
     assertEquals(null, OptionsPage.getVisibleBubble());
     var currentPage = OptionsPage.getTopmostVisiblePage();
 
     var lastExpected = expectedPages[expectedPages.length - 1];
     assertEquals(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 fullExpectedUrl = 'chrome://settings-frame/' +
-                          (expectedUrl ? expectedUrl : lastExpected);
+    expectedUrl = (expectedUrl == undefined) ? lastExpected : expectedUrl;

[Dan Beam, 2014/05/19 23:06:49]

can L395-404 be:

  expectedUrl = expectedUrl || expectedPages.slice(-1)[0];

?

[davidben, 2014/05/19 23:32:28]

Problem is the empty string is falsey.

[Dan Beam, 2014/05/19 23:49:10]

yeah, ok, can you use `=== undefined` or `typeof expectedUrl == 'undefined'`
here instead?

[davidben, 2014/05/20 00:12:55]

Done.

+    var fullExpectedUrl = 'chrome://settings-frame/' + expectedUrl;
     assertEquals(fullExpectedUrl, window.location.href);

[Dan Beam, 2014/05/19 23:06:49]

i think these should be expect*() rather than assert*()

[davidben, 2014/05/19 23:32:28]

...that would explain why they failed by hanging rather aborting. Done.

 
     // Collect open pages.
     var allPageNames = Object.keys(OptionsPage.registeredPages).concat(
                        Object.keys(OptionsPage.registeredOverlayPages));
     var openPages = [];
     for (var i = 0; i < allPageNames.length; ++i) {
       var name = allPageNames[i];
       var page = OptionsPage.registeredPages[name] ||
                  OptionsPage.registeredOverlayPages[name];
       if (page.visible)
@@ skipping 59 matching lines @@
 // Test disabled because it's flaky. crbug.com/303841
 TEST_F('OptionsWebUIExtendedTest', 'DISABLED_ShowSearchPageNoQuery',
        function() {
   OptionsPage.showPageByName('search');
   this.verifyOpenPages_(['settings']);
   this.verifyHistory_(['settings'], testDone);
 });
 
 // Show a page without updating history.
 TEST_F('OptionsWebUIExtendedTest', 'ShowPageNoHistory', function() {
-  this.verifyOpenPages_(['settings']);
+  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
   // 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'], 'settings#query');

[Dan Beam, 2014/05/19 23:06:49]

i'm generally confused, why s/settings//g ?

[davidben, 2014/05/19 23:32:28]

The settings OptionsPage is kind of weird in that, although page.name is
'settings', it appears in the top-level URL as empty. I.e., the URL is
chrome://settings/ and not chrome://settings/settings. This used to happen as a
special case in updateHistoryState_ where the inner path had the extra
"settings", but the outer path didn't; note how chrome://settings-frame/
rewrites to chrome://settings-frame/settings today, but chrome://settings
doesn't rewrite to chrome://settings/settings. This is the page ==
this.getDefaultPage() check.

Since the inner/outer syncing is now done within uber.pushState, that
special-case is gone. Probably not a bad plan anyway since this means that these
tests actually assert on URLs that (assuming uber_utils.js works correctly) are
analogous to what end up in the address bar.

(settings -> search is because that's another discrepancy between the two
frames. search is the version the outer frame sees, so the inner frame now gets
that too.)

+  this.verifyOpenPages_(['settings', 'search'], 'search#query');
   var self = this;
-  this.verifyHistory_(['settings', 'settings#query'], function() {
+  this.verifyHistory_(['', 'search#query'], function() {
     OptionsPage.showPageByName('settings', false);
-    self.verifyOpenPages_(['settings'], 'settings#query');
-    self.verifyHistory_(['settings', 'settings#query'], testDone);
+    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_(['settings', 'settings#query'], function() {
+  this.verifyHistory_(['', 'search#query'], function() {
     OptionsPage.showPageByName('settings', true);
-    self.verifyOpenPages_(['settings'], 'settings#query');
-    self.verifyHistory_(['settings', 'settings#query', 'settings#query'],
+    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_(['settings', 'settings#query'], function() {
+  this.verifyHistory_(['', 'search#query'], function() {
     OptionsPage.showPageByName('settings', true, {'replaceState': true});
-    self.verifyOpenPages_(['settings'], 'settings#query');
-    self.verifyHistory_(['settings', 'settings#query'], testDone);
+    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_(['settings', 'settings#query'], function() {
+  this.verifyHistory_(['', 'search#query'], function() {
     OptionsPage.navigateToPage('settings');
-    self.verifyOpenPages_(['settings'], 'settings#query');
-    self.verifyHistory_(['settings', 'settings#query', 'settings#query'],
+    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);
-  this.verifyOpenPages_(['settings', 'languages'], 'settings');
+  this.verifyOpenPages_(['settings', 'languages'], '');
 
   var self = this;
-  this.verifyHistory_(['settings'], function() {
+  this.verifyHistory_([''], function() {
     // Open a layer-2 overlay for which the layer-1 is a parent, not updating
     // history.
     OptionsPage.showPageByName('addLanguage', false);
     self.verifyOpenPages_(['settings', 'languages', 'addLanguage'],
-                          'settings');
-    self.verifyHistory_(['settings'], testDone);
+                          '');
+    self.verifyHistory_([''], testDone);
   });
 });
 
 TEST_F('OptionsWebUIExtendedTest', 'ShowOverlayWithHistory', function() {
   // Open a layer-1 overlay, updating history.
   OptionsPage.showPageByName('languages', true);
   this.verifyOpenPages_(['settings', 'languages']);
 
   var self = this;
-  this.verifyHistory_(['settings', 'languages'], function() {
+  this.verifyHistory_(['', 'languages'], function() {
     // Open a layer-2 overlay, updating history.
     OptionsPage.showPageByName('addLanguage', true);
     self.verifyOpenPages_(['settings', 'languages', 'addLanguage']);
-    self.verifyHistory_(['settings', 'languages', 'addLanguage'], testDone);
+    self.verifyHistory_(['', 'languages', 'addLanguage'], testDone);
   });
 });
 
 TEST_F('OptionsWebUIExtendedTest', 'ShowOverlayReplaceHistory', function() {
   // Open a layer-1 overlay, updating history.
   OptionsPage.showPageByName('languages', true);
   var self = this;
-  this.verifyHistory_(['settings', 'languages'], function() {
+  this.verifyHistory_(['', 'languages'], function() {
     // Open a layer-2 overlay, replacing history.
     OptionsPage.showPageByName('addLanguage', true, {'replaceState': true});
     self.verifyOpenPages_(['settings', 'languages', 'addLanguage']);
-    self.verifyHistory_(['settings', 'addLanguage'], testDone);
+    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);
   this.verifyOpenPages_(['settings', 'languages', 'addLanguage']);
   var self = this;
-  this.verifyHistory_(['settings', 'addLanguage'], testDone);
+  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);
   this.verifyOpenPages_(['settings', 'languages']);
 
   var self = this;
-  this.verifyHistory_(['settings', 'languages'], function() {
+  this.verifyHistory_(['', 'languages'], function() {
     // Open an unrelated layer-2 overlay.
     OptionsPage.showPageByName('cookies', true);
     self.verifyOpenPages_(['settings', 'content', 'cookies']);
-    self.verifyHistory_(['settings', 'languages', 'cookies'], testDone);
+    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);
   this.verifyOpenPages_(['settings', 'languages']);
   OptionsPage.showPageByName('addLanguage', true);
   this.verifyOpenPages_(['settings', 'languages', 'addLanguage']);
 
   var self = this;
-  this.verifyHistory_(['settings', 'languages', 'addLanguage'], function() {
+  this.verifyHistory_(['', 'languages', 'addLanguage'], function() {
     // Close the layer-2 overlay.
     OptionsPage.closeOverlay();
     self.verifyOpenPages_(['settings', 'languages']);
     self.verifyHistory_(
-        ['settings', 'languages', 'addLanguage', 'languages'],
+        ['', 'languages', 'addLanguage', 'languages'],
         function() {
       // Close the layer-1 overlay.
       OptionsPage.closeOverlay();
-      self.verifyOpenPages_(['settings']);
+      self.verifyOpenPages_(['settings'], '');
       self.verifyHistory_(
-          ['settings', 'languages', 'addLanguage', 'languages', 'settings'],
+          ['', 'languages', 'addLanguage', 'languages', ''],
           testDone);
     });
   });
 });
 
 // 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);
   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);
   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);
   var self = this;
 
   // Go back twice, then forward twice.
   self.verifyOpenPages_(['settings', 'languages', 'addLanguage']);
-  self.verifyHistory_(['settings', 'languages', 'addLanguage'], function() {
+  self.verifyHistory_(['', 'languages', 'addLanguage'], function() {
     window.history.back();
     waitForPopstate(function() {
       self.verifyOpenPages_(['settings', 'languages']);
-      self.verifyHistory_(['settings', 'languages'], function() {
+      self.verifyHistory_(['', 'languages'], function() {
         window.history.back();
         waitForPopstate(function() {
-          self.verifyOpenPages_(['settings']);
-          self.verifyHistory_(['settings'], function() {
+          self.verifyOpenPages_(['settings'], '');
+          self.verifyHistory_([''], function() {
             window.history.forward();
             waitForPopstate(function() {
               self.verifyOpenPages_(['settings', 'languages']);
-              self.verifyHistory_(['settings', 'languages'], function() {
+              self.verifyHistory_(['', 'languages'], function() {
                 window.history.forward();
                 waitForPopstate(function() {
                   self.verifyOpenPages_(
                       ['settings', 'languages', 'addLanguage']);
                   self.verifyHistory_(
-                      ['settings', 'languages', 'addLanguage'], testDone);
+                      ['', 'languages', 'addLanguage'], testDone);
                 });
               });
             });
           });
         });
       });
     });
   });
 });
 
 // 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);
   var self = this;
 
   self.verifyOpenPages_(['settings', 'languages', 'addLanguage']);
-  self.verifyHistory_(['settings', 'languages', 'addLanguage'], function() {
+  self.verifyHistory_(['', 'languages', 'addLanguage'], function() {
     // Close the top overlay, then go back to it.
     OptionsPage.closeOverlay();
     self.verifyOpenPages_(['settings', 'languages']);
     self.verifyHistory_(
-        ['settings', 'languages', 'addLanguage', 'languages'],
+        ['', '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_(['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);
   var self = this;
   self.verifyOpenPages_(['settings', 'content', 'cookies']);
-  self.verifyHistory_(['settings', 'languages', 'cookies'], function() {
+  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() {
@@ skipping 24 matching lines @@
   chrome.send('optionsTestSetPref', [MANAGED_USERS_PREF, {key: 'value'}]);
   waitForResponse(BrowserOptions, 'updateManagesSupervisedUsers', function() {
     assertFalse($('profiles-supervised-dashboard-tip').hidden);
     chrome.send('optionsTestSetPref', [MANAGED_USERS_PREF, {}]);
     waitForResponse(BrowserOptions, 'updateManagesSupervisedUsers', function() {
       assertTrue($('profiles-supervised-dashboard-tip').hidden);
       testDone();
     });
   });
 });