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 195 matching lines @@
  *
  * @type {number}
  */
 defaults.last_updates_page_displayed = 0;
 
 /**
   * @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/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)
+    {
+      delete overrides[preference];
+      return browser.storage.local.remove(prefToKey(preference));
+    }
+
+    overrides[preference] = value;
+    return (customSave.get(preference) || savePref)(preference);
+  },
+
   /**
    * Adds a callback that is called when the
    * value of a specified preference changed.
    *
    * @param {string}   preference
    * @param {function} callback
    */
   on(preference, callback)
   {
     eventEmitter.on(preference, callback);
@@ skipping 28 matching lines @@
   return key.substr(keyPrefix.length);
 }
 
 function prefToKey(pref)
 {
   return keyPrefix + pref;
 }
 
 function savePref(pref)
 {
-  ext.storage.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)
-      return;
-
-    let callback = () =>
-    {
-      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;
+    if (!promise)
+    {
+      promise = new Promise((resolve, reject) =>
+      {
+        setTimeout(
+          () =>
+          {
+            lastUpdate = performance.now();
+            promise = null;
+            savePref(pref).then(resolve, reject);
+          },
+          lastUpdate + MIN_UPDATE_INTERVAL - performance.now()
+        );
+      });
     }
-    else
-      callback();
+    return promise;
   });
 }
 
 function addPreference(pref)
 {
   Object.defineProperty(Prefs, pref, {
     get() { return (pref in overrides ? overrides : defaults)[pref]; },
     set(value)
     {
-      let defaultValue = defaults[pref];
-
-      if (typeof value != typeof defaultValue)
-        throw new Error("Attempt to change preference type");
-
-      if (value == defaultValue)
-      {
-        delete overrides[pref];
-        ext.storage.remove(prefToKey(pref));
-      }
-      else
-      {
-        overrides[pref] = value;
-        (customSave.get(pref) || savePref)(pref);
-      }
+      Prefs.set(pref, value);
     },
     enumerable: true
   });
 }
 
 function init()
 {
   let prefs = Object.keys(defaults);
   prefs.forEach(addPreference);
 
-  let localLoaded = new Promise((resolve, reject) =>
-  {
-    ext.storage.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();