chrome://settings - Provide method for pages to prevent themselves being shown.

chrome/browser/resources/options/options_page.js

 // Copyright (c) 2011 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() {
   /////////////////////////////////////////////////////////////////////////////
   // OptionsPage class:
 
   /**
    * Base class for options page.
@@ skipping 25 matching lines @@
    */
   OptionsPage.registeredOverlayPages = {};
 
   /**
    * Whether or not |initialize| has been called.
    * @private
    */
   OptionsPage.initialized_ = false;
 
   /**
+   * Gets the default page (to be shown on initial load).
+   */
+  OptionsPage.getDefaultPage = function() {
+    return BrowserOptions.getInstance();
+  };
+
+  /**
    * Shows the default page.
    */
   OptionsPage.showDefaultPage = function() {
-    this.navigateToPage(BrowserOptions.getInstance().name);
+    this.navigateToPage(this.getDefaultPage().name);
   };
 
   /**
    * "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.
    */
   OptionsPage.navigateToPage = function(pageName) {
     this.showPageByName(pageName, true);
   };
 
   /**
    * Shows a registered page. This handles both top-level pages and sub-pages.
    * @param {string} pageName Page name.
    * @param {boolean} updateHistory True if we should update the history after
    *     showing the page.
    * @private
    */
   OptionsPage.showPageByName = function(pageName, updateHistory) {
     var targetPage = this.registeredPages[pageName];
-    if (!targetPage) {
-      this.showOverlay_(pageName);
-      if (updateHistory)
-        this.updateHistoryState_();
-      return;
+    if (!targetPage || !targetPage.canShowPage()) {
+      // If it's not a page, try it as an overlay.
+      if (this.showOverlay_(pageName)) {

[stuartmorgan, 2011/02/12 01:09:06]

Change to |if (!targetPage && this.showOverlay_(pageName))|? Seems weird to call
showOverlay_ when we already know it was a page that we couldn't show.

[Evan Stade, 2011/02/12 03:06:42]

Done.

+        if (updateHistory)
+          this.updateHistoryState_();
+        return;
+      } else {
+        targetPage = this.getDefaultPage();
+      }
     }
 
+    pageName = targetPage.name;

[stuartmorgan, 2011/02/12 01:09:06]

Setting paramaters generally makes code harder to understand. Use a new variable
instead, and have everything after use that.

[Evan Stade, 2011/02/12 03:06:42]

on the other hand, I don't want someone coming in and adding new code that uses
pageName because they don't realize it's no longer valid (this is a rather long
function). Most likely if they do this, their code will still appear to work
because it's only in unusual cases that pageName is invalidated.

+
     // Determine if the root page is 'sticky', meaning that it
     // shouldn't change when showing a sub-page.  This can happen for special
     // pages like Search.
     var rootPage = null;
     for (var name in this.registeredPages) {
       var page = this.registeredPages[name];
       if (page.visible && !page.parentPage) {
         rootPage = page;
         break;
       }
@@ skipping 55 matching lines @@
     // Override this with the new page.
     var historyFunction = path ? window.history.pushState :
                                  window.history.replaceState;
     historyFunction.call(window.history,
                          {pageName: page.name},
                          page.title,
                          '/' + page.name);
   };
 
   /**
-   * Called on load. Dispatch the URL hash to the given page's handleHash
-   * function.
-   * @param {string} pageName The string name of the (registered) options page.
-   * @param {string} hash The value of the hash component of the URL.
-   */
-  OptionsPage.handleHashForPage = function(pageName, hash) {
-    var page = this.registeredPages[pageName];
-    page.handleHash(hash);
-  };
-
-  /**
    * Shows a registered Overlay page. Does not update history.
    * @param {string} overlayName Page name.
+   * @return {boolean} whether we showed an overlay.
    */
   OptionsPage.showOverlay_ = function(overlayName) {
     var overlay = this.registeredOverlayPages[overlayName];
+    if (!overlay || !overlay.canShowPage())
+      return false;
 
     if (overlay.parentPage)
       this.showPageByName(overlay.parentPage.name, false);
 
     this.registeredOverlayPages[overlayName].visible = true;
+    return true;
   };
 
   /**
    * Returns whether or not an overlay is visible.
    * @return {boolean} True if an overlay is visible.
    * @private
    */
   OptionsPage.isOverlayVisible_ = function() {
     return this.getVisibleOverlay_() != null;
   };
@@ skipping 536 matching lines @@
       var parent = page.parentPage;
       while (parent) {
         if (parent == this)
           return true;
         parent = parent.parentPage;
       }
       return false;
     },
 
     /**
-     * Handles a hash value in the URL (such as bar in
-     * chrome://options/foo#bar). Called on page load.
-     * @param {string} hash The hash value.
+     * Whether it should be possible to show the page.
+     * @return {boolean} True if the page should be shown
      */
-    handleHash: function(hash) {
+    canShowPage: function() {
+      return true;
     },
   };
 
   // Export
   return {
     OptionsPage: OptionsPage
   };
 });