Refactor the Preferences classes to utilize async methods rather than manually returning Promises

web/chromecom.js

@@ -300,7 +300,7 @@ function setReferer(url, callback) {
 let storageArea = chrome.storage.sync || chrome.storage.local;
 
 class ChromePreferences extends BasePreferences {
-  _writeToStorage(prefObj) {
+  async _writeToStorage(prefObj) {
     return new Promise((resolve) => {
       if (prefObj === this.defaults) {
         let keysToRemove = Object.keys(this.defaults);
@@ -317,7 +317,7 @@ class ChromePreferences extends BasePreferences {
     });
   }
 
-  _readFromStorage(prefObj) {
+  async _readFromStorage(prefObj) {
     return new Promise((resolve) => {
       let getPreferences = (defaultPrefs) => {
         if (chrome.runtime.lastError) {

web/firefoxcom.js

@@ -124,13 +124,13 @@ class DownloadManager {
 }
 
 class FirefoxPreferences extends BasePreferences {
-  _writeToStorage(prefObj) {
+  async _writeToStorage(prefObj) {
     return new Promise(function(resolve) {
       FirefoxCom.request('setPreferences', prefObj, resolve);
     });
   }
 
-  _readFromStorage(prefObj) {
+  async _readFromStorage(prefObj) {
     return new Promise(function(resolve) {
       FirefoxCom.request('getPreferences', prefObj, function(prefStr) {
         let readPrefs = JSON.parse(prefStr);

web/genericcom.js

@@ -26,18 +26,12 @@ if (typeof PDFJSDev !== 'undefined' && !PDFJSDev.test('GENERIC')) {
 let GenericCom = {};
 
 class GenericPreferences extends BasePreferences {
-  _writeToStorage(prefObj) {
+  async _writeToStorage(prefObj) {
-    return new Promise(function(resolve) {
+    localStorage.setItem('pdfjs.preferences', JSON.stringify(prefObj));
-      localStorage.setItem('pdfjs.preferences', JSON.stringify(prefObj));
-      resolve();
-    });
   }
 
-  _readFromStorage(prefObj) {
+  async _readFromStorage(prefObj) {
-    return new Promise(function(resolve) {
+    return JSON.parse(localStorage.getItem('pdfjs.preferences'));
-      let readPrefs = JSON.parse(localStorage.getItem('pdfjs.preferences'));
-      resolve(readPrefs);
-    });
   }
 }
 

web/preferences.js

@@ -83,8 +83,8 @@ class BasePreferences {
    * @return {Promise} A promise that is resolved when the preference values
    *                   have been written.
    */
-  _writeToStorage(prefObj) {
+  async _writeToStorage(prefObj) {
-    return Promise.reject(new Error('Not implemented: _writeToStorage'));
+    throw new Error('Not implemented: _writeToStorage');
   }
 
   /**
@@ -93,8 +93,8 @@ class BasePreferences {
    * @return {Promise} A promise that is resolved with an {Object} containing
    *                   the preferences that have been read.
    */
-  _readFromStorage(prefObj) {
+  async _readFromStorage(prefObj) {
-    return Promise.reject(new Error('Not implemented: _readFromStorage'));
+    throw new Error('Not implemented: _readFromStorage');
   }
 
   /**
@@ -102,11 +102,10 @@ class BasePreferences {
    * @return {Promise} A promise that is resolved when the preference values
    *                   have been reset.
    */
-  reset() {
+  async reset() {
-    return this._initializedPromise.then(() => {
+    await this._initializedPromise;
-      this.prefs = Object.assign(Object.create(null), this.defaults);
+    this.prefs = Object.assign(Object.create(null), this.defaults);
-      return this._writeToStorage(this.defaults);
+    return this._writeToStorage(this.defaults);
-    });
   }
 
   /**
@@ -116,31 +115,32 @@ class BasePreferences {
    * @return {Promise} A promise that is resolved when the value has been set,
    *                   provided that the preference exists and the types match.
    */
-  set(name, value) {
+  async set(name, value) {
-    return this._initializedPromise.then(() => {
+    await this._initializedPromise;
-      if (this.defaults[name] === undefined) {
+    let defaultValue = this.defaults[name];
-        throw new Error(`Set preference: "${name}" is undefined.`);
-      } else if (value === undefined) {
-        throw new Error('Set preference: no value is specified.');
-      }
-      let valueType = typeof value;
-      let defaultType = typeof this.defaults[name];
 
-      if (valueType !== defaultType) {
+    if (defaultValue === undefined) {
-        if (valueType === 'number' && defaultType === 'string') {
+      throw new Error(`Set preference: "${name}" is undefined.`);
-          value = value.toString();
+    } else if (value === undefined) {
-        } else {
+      throw new Error('Set preference: no value is specified.');
-          throw new Error(`Set preference: "${value}" is a ${valueType}, ` +
+    }
-                          `expected a ${defaultType}.`);
+    let valueType = typeof value;
-        }
+    let defaultType = typeof defaultValue;
+
+    if (valueType !== defaultType) {
+      if (valueType === 'number' && defaultType === 'string') {
+        value = value.toString();
       } else {
-        if (valueType === 'number' && !Number.isInteger(value)) {
+        throw new Error(`Set preference: "${value}" is a ${valueType}, ` +
-          throw new Error(`Set preference: "${value}" must be an integer.`);
+                        `expected a ${defaultType}.`);
-        }
       }
-      this.prefs[name] = value;
+    } else {
-      return this._writeToStorage(this.prefs);
+      if (valueType === 'number' && !Number.isInteger(value)) {
-    });
+        throw new Error(`Set preference: "${value}" must be an integer.`);
+      }
+    }
+    this.prefs[name] = value;
+    return this._writeToStorage(this.prefs);
   }
 
   /**
@@ -149,21 +149,20 @@ class BasePreferences {
    * @return {Promise} A promise that is resolved with a {boolean|number|string}
    *                   containing the value of the preference.
    */
-  get(name) {
+  async get(name) {
-    return this._initializedPromise.then(() => {
+    await this._initializedPromise;
-      let defaultValue = this.defaults[name];
+    let defaultValue = this.defaults[name];
 
-      if (defaultValue === undefined) {
+    if (defaultValue === undefined) {
-        throw new Error(`Get preference: "${name}" is undefined.`);
+      throw new Error(`Get preference: "${name}" is undefined.`);
-      } else {
+    } else {
-        let prefValue = this.prefs[name];
+      let prefValue = this.prefs[name];
 
-        if (prefValue !== undefined) {
+      if (prefValue !== undefined) {
-          return prefValue;
+        return prefValue;
-        }
       }
-      return defaultValue;
+    }
-    });
+    return defaultValue;
   }
 
   /**
@@ -171,10 +170,9 @@ class BasePreferences {
    * @return {Promise} A promise that is resolved with an {Object} containing
    *                   the values of all preferences.
    */
-  getAll() {
+  async getAll() {
-    return this._initializedPromise.then(() => {
+    await this._initializedPromise;
-      return Object.assign(Object.create(null), this.defaults, this.prefs);
+    return Object.assign(Object.create(null), this.defaults, this.prefs);
-    });
   }
 }