Issue 4795 - Use modern JavaScript syntax

chrome/ext/background.js

 /*
  * This file is part of Adblock Plus <https://adblockplus.org/>,
  * Copyright (C) 2006-2016 Eyeo GmbH
  *
  * Adblock Plus is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 3 as
  * published by the Free Software Foundation.
  *
  * Adblock Plus is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with Adblock Plus.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+"use strict";
+
 {
   /* Pages */
 
   let Page = ext.Page = function(tab)
   {
     this.id = tab.id;
     this._url = tab.url && new URL(tab.url);
 
     this.browserAction = new BrowserAction(tab.id);
     this.contextMenus = new ContextMenus(this);
@@ skipping 10 matching lines @@
       // In that case we get the url from top frame of the tab, recorded by
       // the onBeforeRequest handler.
       let frames = framesOfTabs[this.id];
       if (frames)
       {
         let frame = frames[0];
         if (frame)
           return frame.url;
       }
     },
-    sendMessage: function(message, responseCallback)
+    sendMessage(message, responseCallback)
     {
       chrome.tabs.sendMessage(this.id, message, responseCallback);
     }
   };
 
   ext.getPage = id => new Page({id: parseInt(id, 10)});
 
   function afterTabLoaded(callback)
   {
      return openedTab =>
      {
        let onUpdated = (tabId, changeInfo, tab) =>
        {
          if (tabId == openedTab.id && changeInfo.status == "complete")
          {
            chrome.tabs.onUpdated.removeListener(onUpdated);
            callback(new Page(openedTab));
          }
        };
        chrome.tabs.onUpdated.addListener(onUpdated);
      };
   }
 
   ext.pages = {
-    open: (url, callback) =>
+    open(url, callback)
     {
       chrome.tabs.create({url: url}, callback && afterTabLoaded(callback));
     },
-    query: (info, callback) =>
+    query(info, callback)
     {
       let rawInfo = {};
       for (let property in info)
       {
         switch (property)
         {
           case "active":
           case "lastFocusedWindow":
             rawInfo[property] = info[property];
         }
@@ skipping 100 matching lines @@
 
 
   /* Browser actions */
 
   let BrowserAction = function(tabId)
   {
     this._tabId = tabId;
     this._changes = null;
   };
   BrowserAction.prototype = {
-    _applyChanges: function()
+    _applyChanges()
     {
       if ("iconPath" in this._changes)
       {
         chrome.browserAction.setIcon({
           tabId: this._tabId,
           path: {
             16: this._changes.iconPath.replace("$size", "16"),
             19: this._changes.iconPath.replace("$size", "19"),
             20: this._changes.iconPath.replace("$size", "20"),
             32: this._changes.iconPath.replace("$size", "32"),
@@ skipping 14 matching lines @@
       if ("badgeColor" in this._changes)
       {
         chrome.browserAction.setBadgeBackgroundColor({
           tabId: this._tabId,
           color: this._changes.badgeColor
         });
       }
 
       this._changes = null;
     },
-    _queueChanges: function()
+    _queueChanges()
     {
       chrome.tabs.get(this._tabId, function()
       {
         // If the tab is prerendered, chrome.tabs.get() sets
         // chrome.runtime.lastError and we have to delay our changes
         // until the currently visible tab is replaced with the
         // prerendered tab. Otherwise chrome.browserAction.set* fails.
         if (chrome.runtime.lastError)
         {
           let onReplaced = (addedTabId, removedTabId) =>
           {
             if (addedTabId == this._tabId)
             {
               chrome.tabs.onReplaced.removeListener(onReplaced);
               this._applyChanges();
             }
           };
           chrome.tabs.onReplaced.addListener(onReplaced);
         }
         else
         {
           this._applyChanges();
         }
       }.bind(this));
     },
-    _addChange: function(name, value)
+    _addChange(name, value)
     {
       if (!this._changes)
       {
         this._changes = {};
         this._queueChanges();
       }
 
       this._changes[name] = value;
     },
-    setIcon: function(path)
+    setIcon(path)
     {
       this._addChange("iconPath", path);
     },
-    setBadge: function(badge)
+    setBadge(badge)
     {
       if (!badge)
       {
         this._addChange("badgeText", "");
       }
       else
       {
         if ("number" in badge)
           this._addChange("badgeText", badge.number.toString());
 
@@ skipping 28 matching lines @@
         let items = contextMenuItems.get({id: tabs[0].id});
 
         if (!items)
           return;
 
         items.forEach(item =>
         {
           chrome.contextMenus.create({
             title: item.title,
             contexts: item.contexts,
-            onclick: (info, tab) =>
+            onclick(info, tab)
             {
               item.onclick(new Page(tab));
             }
           });
         });
       });
     });
   };
 
   let ContextMenus = function(page)
   {
     this._page = page;
   };
   ContextMenus.prototype = {
-    create: function(item)
+    create(item)
     {
       let items = contextMenuItems.get(this._page);
       if (!items)
         contextMenuItems.set(this._page, items = []);
 
       items.push(item);
       updateContextMenu();
     },
-    remove: function(item)
+    remove(item)
     {
       let items = contextMenuItems.get(this._page);
       if (items)
       {
         let index = items.indexOf(item);
         if (index != -1)
         {
           items.splice(index, 1);
           updateContextMenu();
         }
@@ skipping 31 matching lines @@
       chrome.webNavigation.onBeforeNavigate.removeListener(propagateHandlerBehaviorChange);
       chrome.webRequest.handlerBehaviorChanged();
 
       handlerBehaviorChangedQuota--;
       setTimeout(() => { handlerBehaviorChangedQuota++; }, 600000);
     }
   }
 
   ext.webRequest = {
     onBeforeRequest: new ext._EventTarget(),
-    handlerBehaviorChanged: () =>
+    handlerBehaviorChanged()
     {
       // Defer handlerBehaviorChanged() until navigation occurs.
       // There wouldn't be any visible effect when calling it earlier,
       // but it's an expensive operation and that way we avoid to call
       // it multiple times, if multiple filters are added/removed.
       let onBeforeNavigate = chrome.webNavigation.onBeforeNavigate;
       if (!onBeforeNavigate.hasListener(propagateHandlerBehaviorChange))
         onBeforeNavigate.addListener(propagateHandlerBehaviorChange);
     }
   };
@@ skipping 93 matching lines @@
       };
     }
 
     return ext.onMessage._dispatch(message, sender, sendResponse).indexOf(true) != -1;
   });
 
 
   /* Storage */
 
   ext.storage = {
-    get: (keys, callback) =>
+    get(keys, callback)
     {
       chrome.storage.local.get(keys, callback);
     },
-    set: (key, value, callback) =>
+    set(key, value, callback)
     {
       let items = {};
       items[key] = value;
       chrome.storage.local.set(items, callback);
     },
-    remove: (key, callback) =>
+    remove(key, callback)
     {
       chrome.storage.local.remove(key, callback);
     },
     onChanged: chrome.storage.onChanged
   };
 
   /* Options */
 
   if ("openOptionsPage" in chrome.runtime)
   {
@@ skipping 57 matching lines @@
           {
             ext.pages.open(optionsUrl, callback);
           }
         });
       });
     };
   }
 
   /* Windows */
   ext.windows = {
-    create: (createData, callback) =>
+    create(createData, callback)
     {
       chrome.windows.create(createData, createdWindow =>
       {
         afterTabLoaded(callback)(createdWindow.tabs[0]);
       });
     }
   };
 }