Options: maintain history entries on the parent frame.

chrome/browser/resources/options/options_page.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.
 
 cr.define('options', function() {
   /** @const */ var FocusOutlineManager = cr.ui.FocusOutlineManager;
 
   /////////////////////////////////////////////////////////////////////////////
   // OptionsPage class:
 
@@ skipping 53 matching lines @@
 
   /**
    * Gets the default page (to be shown on initial load).
    */
   OptionsPage.getDefaultPage = function() {
     return BrowserOptions.getInstance();
   };
 
   /**
    * Shows the default page.
+   * @param {Object=} opt_propertyBag An optional bag of properties including
+   *     replaceState (if history state should be replaced instead of pushed).
    */
-  OptionsPage.showDefaultPage = function() {
-    this.navigateToPage(this.getDefaultPage().name);
+  OptionsPage.showDefaultPage = function(opt_propertyBag) {
+    opt_propertyBag = opt_propertyBag || {};
+    this.navigateToPage(this.getDefaultPage().name,
+                        {replaceState: opt_propertyBag.replaceState});
   };
 
   /**
    * "Navigates" to a page, meaning that the page will be shown and the
    * appropriate entry is placed in the history.
    * @param {string} pageName Page name.
+   * @param {Object=} opt_propertyBag An optional bag of properties including
+   *     replaceState (if history state should be replaced instead of pushed).
    */
-  OptionsPage.navigateToPage = function(pageName) {
-    this.showPageByName(pageName, true);
+  OptionsPage.navigateToPage = function(pageName, opt_propertyBag) {
+    opt_propertyBag = opt_propertyBag || {};
+    this.showPageByName(pageName, true,
+                        {replaceState: opt_propertyBag.replaceState});
   };
 
   /**
    * Shows a registered page. This handles both top-level and overlay pages.
    * @param {string} pageName Page name.
    * @param {boolean} updateHistory True if we should update the history after
    *     showing the page.
    * @param {Object=} opt_propertyBag An optional bag of properties including
    *     replaceState (if history state should be replaced instead of pushed).
    * @private
@@ skipping 17 matching lines @@
       }
     }
 
     // Find the target page.
     var targetPage = this.registeredPages[pageName.toLowerCase()];
     if (!targetPage || !targetPage.canShowPage()) {
       // If it's not a page, try it as an overlay.
       if (!targetPage && this.showOverlay_(pageName, rootPage)) {
         if (updateHistory)
           this.updateHistoryState_(!!opt_propertyBag.replaceState);
+        this.updateTitle_();
         return;
       } else {
         targetPage = this.getDefaultPage();
       }
     }
 
     pageName = targetPage.name.toLowerCase();
     var targetPageWasVisible = targetPage.visible;
 
     // Determine if the root page is 'sticky', meaning that it
@@ skipping 26 matching lines @@
                  this.registeredOverlayPages[name];
       if (!page.parentPage && isRootPageLocked)
         continue;
       page.visible = name == pageName || page.isAncestorOfPage(targetPage);
     }
 
     // Update the history and current location.
     if (updateHistory)
       this.updateHistoryState_(!!opt_propertyBag.replaceState);
 
-    // Update tab title.
-    this.setTitle_(targetPage.title);
-
     // Update focus if any other control was focused on the previous page,
     // or the previous page is not known.
     if (document.activeElement != document.body &&
         (!rootPage || rootPage.pageDiv.contains(document.activeElement))) {
       targetPage.focus();
     }
 
     // Notify pages if they were shown.
     for (var i = 0; i < allPageNames.length; ++i) {
       var name = allPageNames[i];
       var page = this.registeredPages[name] ||
                  this.registeredOverlayPages[name];
       if (!page.parentPage && isRootPageLocked)
         continue;
       if (!targetPageWasVisible && page.didShowPage &&
           (name == pageName || page.isAncestorOfPage(targetPage))) {
         page.didShowPage();
       }
     }
+
+    // Update the document title. Do this after didShowPage was called, in case
+    // a page decides to change its title.
+    this.updateTitle_();
   };
 
   /**
-   * Sets the title of the page. This is accomplished by calling into the
-   * parent page API.
-   * @param {string} title The title string.
-   * @private
-   */
-  OptionsPage.setTitle_ = function(title) {
-    uber.invokeMethodOnParent('setTitle', {title: title});
-  };
-
-  /**
    * Scrolls the page to the correct position (the top when opening an overlay,
    * or the old scroll position a previously hidden overlay becomes visible).
    * @private
    */
   OptionsPage.updateScrollPosition_ = function() {
     var container = $('page-container');
     var scrollTop = container.oldScrollTop || 0;
     container.oldScrollTop = undefined;
     window.scroll(scrollLeftForDocument(document), scrollTop);
   };
 
   /**
-   * Pushes the current page onto the history stack, overriding the last page
-   * if it is the generic chrome://settings/.
+   * Updates the title to title of the current page.
+   * @private
+   */
+  OptionsPage.updateTitle_ = function() {
+    var page = this.getTopmostVisiblePage();
+    uber.setTitle(page.title);
+  };
+
+  /**
+   * Pushes the current page onto the history stack, replacing the current entry
+   * if appropriate.
    * @param {boolean} replace If true, allow no history events to be created.
    * @param {object=} opt_params A bag of optional params, including:
    *     {boolean} ignoreHash Whether to include the hash or not.
    * @private
    */
   OptionsPage.updateHistoryState_ = function(replace, opt_params) {
     if (OptionsPage.isDialog)
       return;
 
     var page = this.getTopmostVisiblePage();
     var path = window.location.pathname + window.location.hash;
     if (path)
       path = path.slice(1).replace(/\/(?:#|$)/, '');  // Remove trailing slash.
 
-    // Update tab title.
-    this.setTitle_(page.title);

[davidben, 2014/05/19 22:38:33]

This is replaced by an explicit updateTitle_ call. Just so it's unified between
the updateHistory and non-updateHistory cases.

-
     // The page is already in history (the user may have clicked the same link
     // twice). Do nothing.
     if (path == page.name && !OptionsPage.isLoading())
       return;
 
     var hash = opt_params && opt_params.ignoreHash ? '' : window.location.hash;
 
-    // If settings are embedded, tell the outer page to set its "path" to the
-    // inner frame's path.
-    var outerPath = (page == this.getDefaultPage() ? '' : page.name) + hash;
-    uber.invokeMethodOnParent('setPath', {path: outerPath});
-
-    // If there is no path, the current location is chrome://settings/.
-    // Override this with the new page.

[davidben, 2014/05/19 22:38:33]

This special-case is replaced with the new replaceState parameter to
showDefaultPage. The old one relied on the child not getting the 'settings' ->
'' special-case while the parent did.

-    var historyFunction = path && !replace ? window.history.pushState :
-                                             window.history.replaceState;
-    historyFunction.call(window.history,
-                         {pageName: page.name},
-                         page.title,
-                         '/' + page.name + hash);
+    var newPath = (page == this.getDefaultPage() ? '' : page.name) + hash;
+    var historyFunction = replace ? uber.replaceState : uber.pushState;
+    historyFunction.call(uber, {pageName: page.name}, newPath);
   };
 
   /**
    * Shows a registered Overlay page. Does not update history.
    * @param {string} overlayName Page name.
    * @param {OptionPage} rootPage The currently visible root-level page.
    * @return {boolean} whether we showed an overlay.
    */
   OptionsPage.showOverlay_ = function(overlayName, rootPage) {
     var overlay = this.registeredOverlayPages[overlayName.toLowerCase()];
     if (!overlay || !overlay.canShowPage())
       return false;
 
     // Save the currently focused element in the page for restoration later.
     var currentPage = this.getTopmostVisiblePage();
     if (currentPage)
       currentPage.lastFocusedElement = document.activeElement;
 
     if ((!rootPage || !rootPage.sticky) &&
         overlay.parentPage &&
         !overlay.parentPage.visible) {
       this.showPageByName(overlay.parentPage.name, false);
     }
 
     if (!overlay.visible) {
       overlay.visible = true;
       if (overlay.didShowPage) overlay.didShowPage();
     }
 
-    // Update tab title.
-    this.setTitle_(overlay.title);

[davidben, 2014/05/19 22:38:33]

This is replaced by the updateTitle_ call later. It needs to happen after
updateHistoryState_ (if it happens) otherwise the previous history item gets the
wrong title.

-
     // Change focus to the overlay if any other control was focused by keyboard
     // before. Otherwise, no one should have focus.
     if (document.activeElement != document.body) {
       if (FocusOutlineManager.forDocument(document).visible) {
         overlay.focus();
       } else if (!overlay.pageDiv.contains(document.activeElement)) {
         document.activeElement.blur();
       }
     }
 
@@ skipping 46 matching lines @@
    */
   OptionsPage.closeOverlay = function() {
     var overlay = this.getVisibleOverlay_();
     if (!overlay)
       return;
 
     overlay.visible = false;
 
     if (overlay.didClosePage) overlay.didClosePage();
     this.updateHistoryState_(false, {ignoreHash: true});
+    this.updateTitle_();
 
     this.restoreLastFocusedElement_();
   };
 
   /**
    * Closes all overlays and updates the history after each closed overlay.
    */
   OptionsPage.closeAllOverlays = function() {
     while (this.isOverlayVisible_()) {
       this.closeOverlay();
@@ skipping 656 matching lines @@
     canShowPage: function() {
       return true;
     },
   };
 
   // Export
   return {
     OptionsPage: OptionsPage
   };
 });