Run clang-format on ui/webui/resources

ui/webui/resources/js/cr/ui/page_manager/page_manager.js

 // Copyright 2014 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('cr.ui.pageManager', function() {
   /**
    * PageManager contains a list of root Page and overlay Page objects and
    * handles "navigation" by showing and hiding these pages and overlays. On
    * initial load, PageManager can use the path to open the correct hierarchy
    * of pages and overlay(s). Handlers for user events, like pressing buttons,
@@ skipping 43 matching lines @@
     initialize: function(defaultPage) {
       this.defaultPage_ = defaultPage;
 
       cr.ui.FocusOutlineManager.forDocument(document);
       document.addEventListener('scroll', this.handleScroll_.bind(this));
 
       // Trigger the scroll handler manually to set the initial state.
       this.handleScroll_();
 
       // Shake the dialog if the user clicks outside the dialog bounds.
-      var containers = /** @type {!NodeList<!HTMLElement>} */(
+      var containers = /** @type {!NodeList<!HTMLElement>} */ (
           document.querySelectorAll('body > .overlay'));
       for (var i = 0; i < containers.length; i++) {
         var overlay = containers[i];
         cr.ui.overlay.setupOverlay(overlay);
-        overlay.addEventListener('cancelOverlay',
-                                 this.cancelOverlay.bind(this));
+        overlay.addEventListener(
+            'cancelOverlay', this.cancelOverlay.bind(this));
       }
 
       cr.ui.overlay.globalInitialization();
     },
 
     /**
      * Registers new page.
      * @param {!cr.ui.pageManager.Page} page Page to register.
      */
     register: function(page) {
       this.registeredPages[page.name.toLowerCase()] = page;
       page.initializePage();
     },
 
     /**
      * Registers a new Overlay page.
      * @param {!cr.ui.pageManager.Page} overlay Overlay to register.
      * @param {cr.ui.pageManager.Page} parentPage Associated parent page for
      *     this overlay.
      * @param {Array} associatedControls Array of control elements associated
      *     with this page.
      */
-    registerOverlay: function(overlay,
-                              parentPage,
-                              associatedControls) {
+    registerOverlay: function(overlay, parentPage, associatedControls) {
       this.registeredOverlayPages[overlay.name.toLowerCase()] = overlay;
       overlay.parentPage = parentPage;
       if (associatedControls) {
         overlay.associatedControls = associatedControls;
         if (associatedControls.length) {
           overlay.associatedSection =
               this.findSectionForNode_(associatedControls[0]);
         }
 
         // Sanity check.
         for (var i = 0; i < associatedControls.length; ++i) {
           assert(associatedControls[i], 'Invalid element passed.');
         }
       }
 
       overlay.tab = undefined;
       overlay.isOverlay = true;
 
       overlay.reverseButtonStrip();
       overlay.initializePage();
     },
 
     /**
      * Shows the default page.
      * @param {boolean=} opt_updateHistory If we should update the history after
      *     showing the page (defaults to true).
      */
     showDefaultPage: function(opt_updateHistory) {
-      assert(this.defaultPage_ instanceof cr.ui.pageManager.Page,
-             'PageManager must be initialized with a default page.');
+      assert(
+          this.defaultPage_ instanceof cr.ui.pageManager.Page,
+          'PageManager must be initialized with a default page.');
       this.showPageByName(this.defaultPage_.name, opt_updateHistory);
     },
 
     /**
      * Shows a registered page. This handles both root and overlay pages.
      * @param {string} pageName Page name.
      * @param {boolean=} opt_updateHistory If we should update the history after
      *     showing the page (defaults to true).
      * @param {Object=} opt_propertyBag An optional bag of properties including
      *     replaceState (if history state should be replaced instead of pushed).
      *     hash (a hash state to attach to the page).
      */
-    showPageByName: function(pageName,
-                             opt_updateHistory,
-                             opt_propertyBag) {
+    showPageByName: function(pageName, opt_updateHistory, opt_propertyBag) {
       opt_updateHistory = opt_updateHistory !== false;
       opt_propertyBag = opt_propertyBag || {};
 
       // If a bubble is currently being shown, hide it.
       this.hideBubble();
 
       // Find the currently visible root-level page.
       var rootPage = null;
       for (var name in this.registeredPages) {
         var page = this.registeredPages[name];
@@ skipping 30 matching lines @@
       this.forEachPage_(!isRootPageLocked, function(page) {
         if (page.name != pageName && !this.isAncestorOfPage(page, targetPage))
           page.willHidePage();
       });
 
       // Update the page's hash.
       targetPage.hash = opt_propertyBag.hash || '';
 
       // Update visibilities to show only the hierarchy of the target page.
       this.forEachPage_(!isRootPageLocked, function(page) {
-        page.visible = page.name == pageName ||
-                       this.isAncestorOfPage(page, targetPage);
+        page.visible =
+            page.name == pageName || this.isAncestorOfPage(page, targetPage);
       });
 
       // Update the history and current location.
       if (opt_updateHistory)
         this.updateHistoryState_(!!opt_propertyBag.replaceState);
 
       // 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))) {
@@ skipping 66 matching lines @@
     },
 
     /**
      * Returns true if the page is a direct descendent of a root page, or if
      * the page is considered always on top. Doesn't consider visibility.
      * @param {cr.ui.pageManager.Page} page Page to check.
      * @return {boolean} True if |page| is a top-level overlay.
      */
     isTopLevelOverlay: function(page) {
       return page.isOverlay &&
-            (page.alwaysOnTop || this.getNestingLevel(page) == 1);
+          (page.alwaysOnTop || this.getNestingLevel(page) == 1);
     },
 
     /**
      * Called when an page is shown or hidden to update the root page
      * based on the page's new visibility.
      * @param {cr.ui.pageManager.Page} page The page being made visible or
      *     invisible.
      */
     onPageVisibilityChanged: function(page) {
       this.updateRootPageFreezeState();
@@ skipping 112 matching lines @@
     /**
      * Callback for window.onpopstate to handle back/forward navigations.
      * @param {string} pageName The current page name.
      * @param {string} hash The hash to pass into the page.
      * @param {Object} data State data pushed into history.
      */
     setState: function(pageName, hash, data) {
       var currentOverlay = this.getVisibleOverlay_();
       var lowercaseName = pageName.toLowerCase();
       var newPage = this.registeredPages[lowercaseName] ||
-                    this.registeredOverlayPages[lowercaseName] ||
-                    this.defaultPage_;
+          this.registeredOverlayPages[lowercaseName] || this.defaultPage_;
       if (currentOverlay && !this.isAncestorOfPage(currentOverlay, newPage)) {
         currentOverlay.visible = false;
         currentOverlay.didClosePage();
       }
       this.showPageByName(pageName, false, {hash: hash});
     },
 
 
     /**
      * Whether the page is still loading (i.e. onload hasn't finished running).
@@ skipping 20 matching lines @@
     updateRootPageFreezeState: function() {
       var topPage = this.getTopmostVisiblePage();
       if (topPage)
         this.setRootPageFrozen_(topPage.isOverlay);
     },
 
     /**
      * Change the horizontal offset used to reposition elements while showing an
      * overlay from the default.
      */
-    set horizontalOffset(value) {
-      this.horizontalOffset_ = value;
-    },
+    set horizontalOffset(value) { this.horizontalOffset_ = value; },
 
     /**
      * @param {!cr.ui.pageManager.PageManager.Observer} observer The observer to
      *     register.
      */
-    addObserver: function(observer) {
-      this.observers_.push(observer);
-    },
+    addObserver: function(observer) { this.observers_.push(observer); },
 
     /**
      * Shows a registered overlay page. Does not update history.
      * @param {string} overlayName Page name.
      * @param {string} hash The hash state to associate with the overlay.
      * @param {cr.ui.pageManager.Page} rootPage The currently visible root-level
      *     page.
      * @return {boolean} Whether we showed an overlay.
      * @private
      */
     showOverlay_: function(overlayName, hash, rootPage) {
       var overlay = this.registeredOverlayPages[overlayName.toLowerCase()];
       if (!overlay || !overlay.canShowPage())
         return false;
 
       var focusOutlineManager = cr.ui.FocusOutlineManager.forDocument(document);
 
       // Save the currently focused element in the page for restoration later.
       var currentPage = this.getTopmostVisiblePage();
       if (currentPage && focusOutlineManager.visible)
         currentPage.lastFocusedElement = document.activeElement;
 
-      if ((!rootPage || !rootPage.sticky) &&
-          overlay.parentPage &&
+      if ((!rootPage || !rootPage.sticky) && overlay.parentPage &&
           !overlay.parentPage.visible) {
         this.showPageByName(overlay.parentPage.name, false);
       }
 
       overlay.hash = hash;
       if (!overlay.visible) {
         overlay.visible = true;
         overlay.didShowPage();
       } else {
         overlay.didChangeHash();
@@ skipping 12 matching lines @@
       }
 
       return true;
     },
 
     /**
      * Returns whether or not an overlay is visible.
      * @return {boolean} True if an overlay is visible.
      * @private
      */
-    isOverlayVisible_: function() {
-      return this.getVisibleOverlay_() != null;
-    },
+    isOverlayVisible_: function() { return this.getVisibleOverlay_() != null; },
 
     /**
      * Returns the currently visible overlay, or null if no page is visible.
      * @return {cr.ui.pageManager.Page} The visible overlay.
      * @private
      */
     getVisibleOverlay_: function() {
       var topmostPage = null;
       for (var name in this.registeredOverlayPages) {
         var page = this.registeredOverlayPages[name];
         if (!page.visible)
           continue;
 
         if (page.alwaysOnTop)
           return page;
 
         if (!topmostPage ||
-             this.getNestingLevel(page) > this.getNestingLevel(topmostPage)) {
+            this.getNestingLevel(page) > this.getNestingLevel(topmostPage)) {
           topmostPage = page;
         }
       }
       return topmostPage;
     },
 
     /**
      * Returns the topmost visible page (overlays excluded).
      * @return {cr.ui.pageManager.Page} The topmost visible page aside from any
      *     overlays.
@@ skipping 125 matching lines @@
         container.style.right = '';
         container.style.width = '';
       }
     },
 
     /**
      * Called when the page is scrolled; moves elements that are position:fixed
      * but should only behave as if they are fixed for vertical scrolling.
      * @private
      */
-    handleScroll_: function() {
-      this.updateAllFrozenElementPositions_();
-    },
+    handleScroll_: function() { this.updateAllFrozenElementPositions_(); },
 
     /**
      * Updates all frozen pages to match the horizontal scroll position.
      * @private
      */
     updateAllFrozenElementPositions_: function() {
       var frozenElements = document.querySelectorAll('.frozen');
       for (var i = 0; i < frozenElements.length; i++)
         this.updateFrozenElementHorizontalPosition_(frozenElements[i]);
     },
@@ skipping 18 matching lines @@
      *     for the root pages.
      * @param {function(cr.ui.pageManager.Page)} callback The callback.
      * @private
      */
     forEachPage_: function(includeRootPages, callback) {
       var pageNames = Object.keys(this.registeredOverlayPages);
       if (includeRootPages)
         pageNames = Object.keys(this.registeredPages).concat(pageNames);
 
       pageNames.forEach(function(name) {
-        callback.call(this, this.registeredOverlayPages[name] ||
-                            this.registeredPages[name]);
+        callback.call(
+            this,
+            this.registeredOverlayPages[name] || this.registeredPages[name]);
       }, this);
     },
   };
 
   /**
    * An observer of PageManager.
    * @interface
    */
-  PageManager.Observer = function() {}
+  PageManager.Observer = function() {};
 
   PageManager.Observer.prototype = {
     /**
      * Called when a page is being shown or has been hidden.
      * @param {cr.ui.pageManager.Page} page The page being shown or hidden.
      */
     onPageVisibilityChanged: function(page) {},
 
     /**
      * Called when a new title should be set.
      * @param {string} title The title to set.
      */
     updateTitle: function(title) {},
 
     /**
      * Called when a page is navigated to.
      * @param {string} path The path of the page being visited.
      * @param {boolean} replace If true, allow no history events to be created.
      */
     updateHistory: function(path, replace) {},
   };
 
   // Export
-  return {
-    PageManager: PageManager
-  };
+  return {PageManager: PageManager};
 });