[MD settings] rename lastRoutChangeWasPopstate var

chrome/browser/resources/settings/settings_page/main_page_behavior.js

 // Copyright 2016 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.
 
 /**
  * Responds to route changes by expanding, collapsing, or scrolling to sections
  * on the page. Expanded sections take up the full height of the container. At
  * most one section should be expanded at any given time.
  * @polymerBehavior MainPageBehavior
  */
 var MainPageBehaviorImpl = {
   properties: {
     /**
      * Help CSS to alter style during the horizontal swipe animation.
      * Note that this is unrelated to the |currentAnimation_| (which refers to
-     * the vertical exapand animation).
+     * the vertical expand animation).
      */
     isSubpageAnimating: {
       reflectToAttribute: true,
       type: Boolean,
     },
 
     /**
      * Whether a search operation is in progress or previous search results are
      * being displayed.
      * @private {boolean}
      */
     inSearchMode: {
       type: Boolean,
       value: false,
       observer: 'inSearchModeChanged_',
     },
   },
 
   /** @type {?HTMLElement} The scrolling container. */
   scroller: null,
 
-  listeners: {
-    'neon-animation-finish': 'onNeonAnimationFinish_'
-  },
+  listeners: {'neon-animation-finish': 'onNeonAnimationFinish_'},
 
   /** @override */
   attached: function() {
     this.scroller = this.domHost ? this.domHost.parentNode : document.body;
   },
 
   /**
    * Remove the is-animating attribute once the animation is complete.
    * This may catch animations finishing more often than needed, which is not
    * known to cause any issues (e.g. when animating from a shallower page to a
@@ skipping 23 matching lines @@
 
       // When navigating to the About page, we need to scroll to the top, and
       // still do the rest of section management.
       if (newRoute == settings.Route.ABOUT)
         this.scroller.scrollTop = 0;
     }
 
     // Scroll to the section except for back/forward. Also scroll for any
     // in-page back/forward navigations (from a section or the root page).
     // Also always scroll when coming from either the About or root page.
-    var scrollToSection = !settings.lastRouteChangeWasPopstate() ||
+    var scrollToSection = !settings.wasLastRouteChangePopstate() ||
         oldRouteWasSection || oldRoute == settings.Route.BASIC ||
         oldRoute == settings.Route.ABOUT;
 
     // TODO(dschuyler): This doesn't set the flag in the case of going to or
     // from the main page. It seems sensible to set the flag in those cases,
     // unfortunately bug 708465 happens. Figure out why that is and then set
     // this flag more broadly.
     if (oldRoute && oldRoute.isSubpage() && newRoute.isSubpage())
       this.isSubpageAnimating = true;
 
     // For previously uncreated pages (including on first load), allow the page
     // to render before scrolling to or expanding the section.
     if (!oldRoute || this.scrollHeight == 0)
       setTimeout(this.tryTransitionToSection_.bind(this, scrollToSection));
     else
       this.tryTransitionToSection_(scrollToSection);
   },
 
   /**
    * When exiting search mode, we need to make another attempt to scroll to
    * the correct section, since it has just been re-rendered.
    * @private
    */
   inSearchModeChanged_: function(inSearchMode) {
     if (!this.isAttached)
       return;
 
     if (!inSearchMode)
-      this.tryTransitionToSection_(!settings.lastRouteChangeWasPopstate());
+      this.tryTransitionToSection_(!settings.wasLastRouteChangePopstate());
   },
 
   /**
    * If possible, transitions to the current route's section (by expanding or
    * scrolling to it). If another transition is running, finishes or cancels
    * that one, then schedules this function again. This ensures the current
    * section is quickly shown, without getting the page into a broken state --
    * if currentRoute changes in between calls, just transition to the new route.
    * @param {boolean} scrollToSection
    * @private
@@ skipping 168 matching lines @@
     }
 
     // Play the actual collapse animation.
     return new Promise(function(resolve, reject) {
       // Wait for the other sections to show up so we can scroll properly.
       setTimeout(function() {
         var newSection = settings.getCurrentRoute().section &&
             this.getSection(settings.getCurrentRoute().section);
 
         // Scroll to the new section or the original position.
-        if (newSection && !settings.lastRouteChangeWasPopstate() &&
+        if (newSection && !settings.wasLastRouteChangePopstate() &&
             !settings.getCurrentRoute().isSubpage()) {
           newSection.scrollIntoView();
         } else {
           this.scroller.scrollTop = this.origScrollTop_;
         }
 
         this.currentAnimation_ = section.animateCollapse(
             /** @type {!HTMLElement} */(this.scroller));
 
         this.currentAnimation_.finished.catch(function() {
@@ skipping 36 matching lines @@
     return /** @type {?SettingsSectionElement} */(
         this.$$('settings-section[section="' + section + '"]'));
   },
 };
 
 /** @polymerBehavior */
 var MainPageBehavior = [
   settings.RouteObserverBehavior,
   MainPageBehaviorImpl,
 ];