MD Settings: Convert all usages of .bind(this) to use ES6 arrow function.

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.
 
 cr.exportPath('settings');
 
 /**
  * A data structure used by callers to combine the results of multiple search
  * requests.
  *
@@ skipping 286 matching lines @@
 
     /** @override */
     exec() {
       var routePath = this.node.getAttribute('route-path');
       var subpageTemplate =
           this.node['_content'].querySelector('settings-subpage');
       subpageTemplate.setAttribute('route-path', routePath);
       assert(!this.node.if);
       this.node.if = true;
 
-      return new Promise(function(resolve, reject) {
+      return new Promise((resolve, reject) => {
         var parent = this.node.parentNode;
-        parent.async(function() {
+        parent.async(() => {
           var renderedNode =
               parent.querySelector('[route-path="' + routePath + '"]');
           // Register a SearchAndHighlightTask for the part of the DOM that was
           // just rendered.
           this.request.queue_.addSearchAndHighlightTask(
               new SearchAndHighlightTask(this.request, assert(renderedNode)));
           resolve();
-        }.bind(this));
-      }.bind(this));
+        });
+      });
     }
   }
 
   class SearchAndHighlightTask extends Task {
     /**
      * @param {!settings.SearchRequest} request
      * @param {!Node} node
      */
     constructor(request, node) {
       super(request, node);
@@ skipping 116 matching lines @@
       while (1) {
         var task = this.popNextTask_();
         if (!task) {
           this.running_ = false;
           if (this.onEmptyCallback_)
             this.onEmptyCallback_();
           return;
         }
 
         this.running_ = true;
-        window.requestIdleCallback(function() {
+        window.requestIdleCallback(() => {
           if (!this.request_.canceled) {
-            task.exec().then(function() {
+            task.exec().then(() => {
               this.running_ = false;
               this.consumePending_();
-            }.bind(this));
+            });
           }
           // Nothing to do otherwise. Since the request corresponding to this
           // queue was canceled, the queue is disposed along with the request.
-        }.bind(this));
+        });
         return;
       }
     }
   }
 
   class SearchRequest {
     /**
      * @param {string} rawQuery
      * @param {!HTMLElement} root
      */
@@ skipping 14 matching lines @@
       this.canceled = false;
 
       /** @private {boolean} */
       this.foundMatches_ = false;
 
       /** @type {!PromiseResolver} */
       this.resolver = new PromiseResolver();
 
       /** @private {!TaskQueue} */
       this.queue_ = new TaskQueue(this);
-      this.queue_.onEmpty(function() {
+      this.queue_.onEmpty(() => {
         this.resolver.resolve(this);
-      }.bind(this));
+      });
     }
 
     /**
      * Fires this search request.
      */
     start() {
       this.queue_.addTopLevelSearchTask(
           new TopLevelSearchTask(this, this.root_));
     }
 
@@ skipping 69 matching lines @@
           request.canceled = true;
           request.resolver.resolve(request);
         });
         this.activeRequests_.clear();
       }
 
       this.lastSearchedText_ = text;
       var request = new SearchRequest(text, page);
       this.activeRequests_.add(request);
       request.start();
-      return request.resolver.promise.then(function() {
+      return request.resolver.promise.then(() => {
         // Stop tracking requests that finished.
         this.activeRequests_.delete(request);
         return request;
-      }.bind(this));
+      });
     }
   }
   cr.addSingletonGetter(SearchManagerImpl);
 
   /** @return {!SearchManager} */
   function getSearchManager() {
     return SearchManagerImpl.getInstance();
   }
 
   /**
    * Sets the SearchManager singleton instance, useful for testing.
    * @param {!SearchManager} searchManager
    */
   function setSearchManagerForTesting(searchManager) {
     SearchManagerImpl.instance_ = searchManager;
   }
 
   return {
     getSearchManager: getSearchManager,
     setSearchManagerForTesting: setSearchManagerForTesting,
     SearchRequest: SearchRequest,
   };
 });