MD History/Downloads: convert .bind(this) and function property values to use =>

chrome/browser/resources/md_history/history_list_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.
 
 /**
  * @constructor
  * @param {string} currentPath
  */
 var SelectionTreeNode = function(currentPath) {
   /** @type {string} */
@@ skipping 17 matching lines @@
 
 /** @polymerBehavior */
 var HistoryListBehavior = {
   properties: {
     /**
      * Polymer paths to the history items contained in this list.
      * @type {!Set<string>} selectedPaths
      */
     selectedPaths: {
       type: Object,
-      value: /** @return {!Set<string>} */ function() { return new Set(); }
+      value: /** @return {!Set<string>} */ () => new Set(),
     },
 
     lastSelectedPath: String,
   },
 
   listeners: {
     'history-checkbox-select': 'itemSelected_',
   },
 
   /**
@@ skipping 23 matching lines @@
       return '';
 
     var messageId = searchedTerm !== '' ? 'noSearchResults' : 'noResults';
     return loadTimeData.getString(messageId);
   },
 
   /**
    * Deselect each item in |selectedPaths|.
    */
   unselectAllItems: function() {
-    this.selectedPaths.forEach(function(path) {
-      this.set(path + '.selected', false);
-    }.bind(this));
-
+    this.selectedPaths.forEach(path => this.set(path + '.selected', false));
     this.selectedPaths.clear();
   },
 
   /**
    * Performs a request to the backend to delete all selected items. If
    * successful, removes them from the view. Does not prompt the user before
    * deleting -- see <history-list-container> for a version of this method which
    * does prompt.
    */
   deleteSelected: function() {
     var toBeRemoved =
-        Array.from(this.selectedPaths.values()).map(function(path) {
-          return this.get(path);
-        }.bind(this));
+        Array.from(this.selectedPaths.values()).map(path => this.get(path));
 
     md_history.BrowserService.getInstance()
         .deleteItems(toBeRemoved)
-        .then(function() {
+        .then(() => {
           this.removeItemsByPath(Array.from(this.selectedPaths));
           this.fire('unselect-all');
-        }.bind(this));
+        });
   },
 
   /**
    * Removes the history items in |paths|. Assumes paths are of a.0.b.0...
    * structure.
    *
    * We want to use notifySplices to update the arrays for performance reasons
    * which requires manually batching and sending the notifySplices for each
    * level. To do this, we build a tree where each node is an array and then
    * depth traverse it to remove items. Each time a node has all children
@@ skipping 47 matching lines @@
    * they become empty.
    * @param {SelectionTreeNode} node
    * @return {boolean} Whether this node's array should be deleted.
    * @private
    */
   removeItemsBeneathNode_: function(node) {
     var array = this.get(node.currentPath);
     var splices = [];
 
     node.indexes.sort(function(a, b) { return b - a; });
-    node.indexes.forEach(function(index) {
+    node.indexes.forEach(index => {
       if (node.leaf || this.removeItemsBeneathNode_(node.children[index])) {
         var item = array.splice(index, 1)[0];
         splices.push({
           index: index,
           removed: [item],
           addedCount: 0,
           object: array,
           type: 'splice'
         });
       }
-    }.bind(this));
+    });
 
     if (array.length == 0 && node.currentPath.indexOf('.') != -1)
       return true;
 
     // notifySplices gives better performance than individually splicing as it
     // batches all of the updates together.
     this.notifySplices(node.currentPath, splices);
     return false;
   },
 
@@ skipping 21 matching lines @@
           paths.push(itemArrayPath + '.' + i);
         }
       }
     }
 
     if (paths.length == 0)
       paths.push(item.path);
 
     var selected = !this.selectedPaths.has(item.path);
 
-    paths.forEach(function(path) {
+    paths.forEach(path => {
       this.set(path + '.selected', selected);
 
       if (selected) {
         this.selectedPaths.add(path);
         return;
       }
 
       this.selectedPaths.delete(path);
-    }.bind(this));
+    });
 
     this.lastSelectedPath = itemPath;
   },
 };