Issue 6599 - Detect data corruption of storage.local

lib/prefs.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
@@ skipping 201 matching lines @@
   * @namespace
   * @static
   */
 let Prefs = exports.Prefs = {
   /**
    * Sets the given preference.
    *
    * @param {string} preference
    * @param {any}    value
    * @return {Promise} A promise that resolves when the underlying
-                       browser.storage.local.set() operation completes
+                       browser.storage.local.set/remove() operation completes
    */
   set(preference, value)
   {
     let defaultValue = defaults[preference];
 
     if (typeof value != typeof defaultValue)
       throw new Error("Attempt to change preference type");
 
     if (value == defaultValue)
     {
@@ skipping 46 matching lines @@
   return key.substr(keyPrefix.length);
 }
 
 function prefToKey(pref)
 {
   return keyPrefix + pref;
 }
 
 function savePref(pref)
 {
-  return browser.storage.local.set(prefToKey(pref), overrides[pref]);
+  return browser.storage.local.set({[prefToKey(pref)]: overrides[pref]});
 }
 
 let customSave = new Map();
 if (require("../buildtools/info").platform == "gecko")
 {
   // Saving one storage value causes all others to be saved as well on Gecko.
   // Make sure that updating ad counter doesn't cause the filters data to be
   // saved frequently as a side-effect.
   const MIN_UPDATE_INTERVAL = 60 * 1000;
   let lastUpdate = -MIN_UPDATE_INTERVAL;
-  let updateScheduled = false;
+  let promise = null;
   customSave.set("blocked_total", pref =>
   {
-    if (!updateScheduled)
-    {
-      let callback = () =>
+    if (!promise)
+    {
+      promise = new Promise((resolve, reject) =>
       {
-        lastUpdate = performance.now();
-        updateScheduled = false;
-        savePref(pref);
-      };
-
-      let timeElapsed = performance.now() - lastUpdate;
-      if (timeElapsed < MIN_UPDATE_INTERVAL)
-      {
-        setTimeout(callback, MIN_UPDATE_INTERVAL - timeElapsed);
-        updateScheduled = true;
-      }
-      else
-        callback();
+        setTimeout(
+          () =>
+          {
+            lastUpdate = performance.now();
+            promise = null;
+            savePref(pref).then(resolve, reject);
+          },
+          lastUpdate + MIN_UPDATE_INTERVAL - performance.now()
+        );
+      });
     }
-    return Promise.resolve();
+    return promise;
   });
 }
 
 function addPreference(pref)
 {
   Object.defineProperty(Prefs, pref, {
     get() { return (pref in overrides ? overrides : defaults)[pref]; },
     set(value)
     {
       Prefs.set(pref, value);
     },
     enumerable: true
   });
 }
 
 function init()
 {
   let prefs = Object.keys(defaults);
   prefs.forEach(addPreference);
 
-  let localLoaded = new Promise((resolve, reject) =>
-  {
-    browser.storage.local.get(prefs.map(prefToKey)).then(items =>
+  let localLoaded = browser.storage.local.get(prefs.map(prefToKey)).then(
+    items =>
     {
       for (let key in items)
         overrides[keyToPref(key)] = items[key];
-
-      resolve();
-    }, reject);
-  });
-
-  let managedLoaded = new Promise(resolve =>
-  {
-    if ("managed" in browser.storage)
-    {
-      browser.storage.managed.get(null, items =>
+    }
+  );
+
+  let managedLoaded;
+  if ("managed" in browser.storage)
+  {
+    managedLoaded = browser.storage.managed.get(null).then(
+      items =>
       {
-        // Opera doesn't support browser.storage.managed, but instead simply
-        // removing the API, Opera sets browser.runtime.lastError when using it.
-        // So we have to retrieve that error, to prevent it from showing up
-        // in the console.
-        browser.runtime.lastError;
-
         for (let key in items)
           defaults[key] = items[key];
-
-        resolve();
-      });
-    }
-    else
-    {
-      resolve();
-    }
-  });
+      },
+
+      // Opera doesn't support browser.storage.managed, but instead of simply
+      // removing the API, it gives an asynchronous error which we ignore here.
+      () => {}
+    );
+  }
+  else
+  {
+    managedLoaded = Promise.resolve();
+  }
 
   function onLoaded()
   {
-    ext.storage.onChanged.addListener(changes =>
+    browser.storage.onChanged.addListener(changes =>
     {
       for (let key in changes)
       {
         let pref = keyToPref(key);
         if (pref && pref in defaults)
         {
           let change = changes[key];
           if ("newValue" in change && change.newValue != defaults[pref])
             overrides[pref] = change.newValue;
           else
             delete overrides[pref];
 
           eventEmitter.emit(pref);
         }
       }
     });
   }
 
   Prefs.untilLoaded = Promise.all([localLoaded, managedLoaded]).then(onLoaded);
 }
 
 init();