Issue 7257 - Throttle badge updates

lib/stats.js

 /*
  * This file is part of Adblock Plus <https://adblockplus.org/>,
  * Copyright (C) 2006-present 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/>.
  */
 
 /** @module stats */
 
 "use strict";
 
 const {Prefs} = require("./prefs");
 const {BlockingFilter} = require("../adblockpluscore/lib/filterClasses");
 const {filterNotifier} = require("../adblockpluscore/lib/filterNotifier");
 const {port} = require("./messaging");
 
 const badgeColor = "#646464";
-
-// 4 fps.
 const badgeRefreshRate = 4;
 
 let blockedPerPage = new ext.PageMap();
 
 let getBlockedPerPage =
 /**
  * Gets the number of requests blocked on the given page.
  *
  * @param  {Page} page
  * @return {Number}
  */
 exports.getBlockedPerPage = page => blockedPerPage.get(page) || 0;
 
-// The ID of the focused window. If all windows lose focus, this is the ID of
-// the last focused window.
-let focusedWindowId = -1;
+let activeTabIds = new Set();
+let activeTabIdByWindowId = new Map();
 
-// The ID of the active tab in the focused window. This can be unknown (-1) on
-// startup and (briefly) when the focus shifts to a different window.
-let activeTabId = -1;
+let badgeUpdateScheduled = false;
 
-let Scheduler = function()
+function updateBadge(tabId)
 {
-  this.scheduled = false;
-};
-Scheduler.prototype = {
-  schedule(delay, func)
-  {
-    setTimeout(() =>
-    {
-      this.scheduled = false;
-      func();
-    },
-    delay);
-
-    this.scheduled = true;
-  }
-};
-
-let badgeUpdateScheduler = new Scheduler();
-
-function updateBadgeNow()
-{
-  if (activeTabId == -1)
+  if (!Prefs.show_statsinicon)
     return;
 
-  let page = new ext.Page({id: activeTabId});
-  let blockedCount = blockedPerPage.get(page);
+  for (let id of (typeof tabId == "undefined" ? activeTabIds : [tabId]))
+  {
+    let page = new ext.Page({id});
+    let blockedCount = blockedPerPage.get(page);
 
-  page.browserAction.setBadge(blockedCount && {
-    color: badgeColor,
-    number: blockedCount
-  });
-}
-
-function updateBadge(tabId = -1)
-{
-  if (!badgeUpdateScheduler.scheduled &&
-      (tabId == activeTabId || tabId == -1) && activeTabId != -1 &&
-      Prefs.show_statsinicon)
-  {
-    // Schedule an update.
-    badgeUpdateScheduler.schedule(1000 / badgeRefreshRate, updateBadgeNow);
+    page.browserAction.setBadge(blockedCount && {
+      color: badgeColor,
+      number: blockedCount
+    });
   }
 }
 
-function findAndUpdateActiveTab()
+function scheduleBadgeUpdate(tabId)
 {
-  browser.tabs.query({active: true, lastFocusedWindow: true}, ([tab]) =>
+  if (!badgeUpdateScheduled && Prefs.show_statsinicon &&
+      (typeof tabId == "undefined" || activeTabIds.has(tabId)))
   {
-    if (tab && activeTabId != tab.id)
-    {
-      activeTabId = tab.id;
-      focusedWindowId = tab.windowId;
-
-      updateBadge();
-    }
-  });
+    setTimeout(() => { badgeUpdateScheduled = false; updateBadge(); },
+               1000 / badgeRefreshRate);
+    badgeUpdateScheduled = true;
+  }
 }
 
 // Once nagivation for the tab has been committed to (e.g. it's no longer
 // being prerendered) we clear its badge, or if some requests were already
 // blocked beforehand we display those on the badge now.
 browser.webNavigation.onCommitted.addListener(details =>
 {
   if (details.frameId == 0)
     updateBadge(details.tabId);
 });
 
 filterNotifier.on("filter.hitCount", (filter, newValue, oldValue, tabIds) =>
 {
   if (!(filter instanceof BlockingFilter))
     return;
 
   for (let tabId of tabIds)
   {
     let page = new ext.Page({id: tabId});
     let blocked = blockedPerPage.get(page) || 0;
 
     blockedPerPage.set(page, ++blocked);
-    updateBadge(tabId);
+    scheduleBadgeUpdate(tabId);
   }
 
   Prefs.blocked_total++;
 });
 
 Prefs.on("show_statsinicon", () =>
 {
   browser.tabs.query({}, tabs =>
   {
     for (let tab of tabs)
     {
       let page = new ext.Page(tab);
 
       if (Prefs.show_statsinicon)
         updateBadge(tab.id);
       else
         page.browserAction.setBadge(null);
     }
   });
 });
 
 port.on("stats.getBlockedPerPage",
         message => getBlockedPerPage(new ext.Page(message.tab)));
 
+browser.tabs.query({active: true}, tabs =>
+{
+  for (let tab of tabs)
+  {
+    activeTabIds.add(tab.id);
+    activeTabIdByWindowId.set(tab.windowId, tab.id);
+  }
+
+  scheduleBadgeUpdate();
+});
+
 browser.tabs.onActivated.addListener(tab =>
 {
-  if (tab.windowId == focusedWindowId && activeTabId != tab.tabId)
-  {
-    activeTabId = tab.tabId;
-    updateBadge();
-  }
+  let lastActiveTabId = activeTabIdByWindowId.get(tab.windowId);
+  if (typeof lastActiveTabId != "undefined")
+    activeTabIds.delete(lastActiveTabId);
+
+  activeTabIds.add(tab.tabId);
+  activeTabIdByWindowId.set(tab.windowId, tab.tabId);
+
+  scheduleBadgeUpdate();
 });
 
 if ("windows" in browser)
 {
-  browser.windows.onFocusChanged.addListener(windowId =>
+  browser.windows.onRemoved.addListener(windowId =>
   {
-    if (windowId == browser.windows.WINDOW_ID_NONE)
-      return;
-
-    focusedWindowId = windowId;
-    activeTabId = -1;
-
-    findAndUpdateActiveTab();
+    activeTabIds.delete(activeTabIdByWindowId.get(windowId));
+    activeTabIdByWindowId.delete(windowId);
   });
 }
-
-findAndUpdateActiveTab();