MD Settings: Show/hide spinner when searching starts/ends.

chrome/browser/resources/settings/search_settings.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.
 
 /** @typedef {{id: number, rawQuery: ?string, regExp: ?RegExp}} */
 var SearchContext;
 
 cr.define('settings', function() {
   /** @const {string} */
   var WRAPPER_CSS_CLASS = 'search-highlight-wrapper';
@@ skipping 213 matching lines @@
       subpageTemplate.id = subpageTemplate.id || this.node.getAttribute('name');
       assert(!this.node.if);
       this.node.if = true;
 
       return new Promise(function(resolve, reject) {
         var parent = this.node.parentNode;
         parent.async(function() {
           var renderedNode = parent.querySelector('#' + subpageTemplate.id);
           // Register a SearchAndHighlightTask for the part of the DOM that was
           // just rendered.
           SearchManager.getInstance().queue_.addSearchAndHighlightTask(

[Dan Beam, 2016/07/19 00:06:26]

nit: can we re-use getSearchManager() in other places now as well?

[dpapad, 2016/07/19 00:36:42]

Done.

               new SearchAndHighlightTask(this.context, assert(renderedNode)));
           resolve();
         }.bind(this));
       }.bind(this));
     },
   };
 
   /**
    * @constructor
    * @extends {Task}
@@ skipping 106 matching lines @@
 
     /** @private */
     consumePending_: function() {
       if (this.running_)
         return;
 
       while (1) {
         var task = this.popNextTask_();
         if (!task) {
           this.running_ = false;
+          getSearchManager().notifyCallback(false);
           return;
         }
 
+        this.running_ = true;
         window.requestIdleCallback(function() {
           function startNextTask() {
             this.running_ = false;
             this.consumePending_();
           }
           if (task.context.id ==
               SearchManager.getInstance().activeContext_.id) {
             task.exec().then(startNextTask.bind(this));
           } else {
             // Dropping this task without ever executing it, since a new search
             // has been issued since this task was queued.
             startNextTask.call(this);
           }
         }.bind(this));
         return;
       }
     },
   };
 
   /**
    * @constructor
    */
   var SearchManager = function() {
     /** @private {!TaskQueue} */
     this.queue_ = new TaskQueue();
 
     /** @private {!SearchContext} */
     this.activeContext_ = {id: 0, rawQuery: null, regExp: null};
+
+    /** @private {?function(boolean):void} */
+    this.callbackFn_ = null;
   };
   cr.addSingletonGetter(SearchManager);
 
   /** @private @const {!RegExp} */
   SearchManager.SANITIZE_REGEX_ = /[-[\]{}()*+?.,\\^$|#\s]/g;
 
   SearchManager.prototype = {
     /**
+     * Registers a callback function that will be called every time search
+     * starts/finishes.
+     * @param {?function(boolean):void} callbackFn
+     */
+    setCallback: function(callbackFn) {
+      this.callbackFn_ = callbackFn;
+    },
+
+    /** @param {boolean} isRunning */
+    notifyCallback: function(isRunning) {
+      if (this.callbackFn_)
+        this.callbackFn_(isRunning);
+    },
+
+    /**
      * @param {string} text The text to search for.
      * @param {!Node} page
      */
     search: function(text, page) {
       if (this.activeContext_.rawQuery != text) {
         var newId = this.activeContext_.id + 1;
 
         var regExp = null;
         // Generate search text by escaping any characters that would be
         // problematic for regular expressions.
         var searchText = text.trim().replace(
             SearchManager.SANITIZE_REGEX_, '\\$&');
         if (searchText.length > 0)
           regExp = new RegExp('(' + searchText + ')', 'i');
 
         this.activeContext_ = {id: newId, rawQuery: text, regExp: regExp};
 
         // Drop all previously scheduled tasks, since a new search was just
         // issued.
         this.queue_.reset();
+        this.notifyCallback(true);
       }
 
       this.queue_.addTopLevelSearchTask(
           new TopLevelSearchTask(this.activeContext_, page));
     },
   };
 
-  /**
-   * @param {string} text
-   * @param {!Node} page
-   */
-  function search(text, page) {
-    SearchManager.getInstance().search(text, page);
+  /** @return {!SearchManager} */
+  function getSearchManager() {
+    return SearchManager.getInstance();
   }
 
   return {
-    search: search,
+    getSearchManager: getSearchManager,
   };
 });