Merge pull request #4482 from Snuffleupagus/prefs-async-v2

Rewrite 'Preferences' to make it async

extensions/firefox/content/PdfStreamConverter.jsm

@@ -452,7 +452,7 @@ ChromeActions.prototype = {
     getChromeWindow(this.domWindow).gFindBar
                                    .updateControlState(result, findPrevious);
   },
-  setPreferences: function(prefs) {
+  setPreferences: function(prefs, sendResponse) {
     var defaultBranch = Services.prefs.getDefaultBranch(PREF_PREFIX + '.');
     var numberOfPrefs = 0;
     var prefValue, prefName;
@@ -483,8 +483,11 @@ ChromeActions.prototype = {
           break;
       }
     }
+    if (sendResponse) {
+      sendResponse(true);
+    }
   },
-  getPreferences: function(prefs) {
+  getPreferences: function(prefs, sendResponse) {
     var defaultBranch = Services.prefs.getDefaultBranch(PREF_PREFIX + '.');
     var currentPrefs = {}, numberOfPrefs = 0;
     var prefValue, prefName;
@@ -510,7 +513,11 @@ ChromeActions.prototype = {
           break;
       }
     }
-    return JSON.stringify(currentPrefs);
+    if (sendResponse) {
+      sendResponse(JSON.stringify(currentPrefs));
+    } else {
+      return JSON.stringify(currentPrefs);
+    }
   }
 };
 

web/default_preferences.js

@@ -21,5 +21,6 @@
 var DEFAULT_PREFERENCES = {
   showPreviousViewOnLoad: true,
   defaultZoomValue: '',
-  ifAvailableShowOutlineOnLoad: false
+  ifAvailableShowOutlineOnLoad: false,
+  enableHandToolOnLoad: false
 };

web/firefoxcom.js

@@ -104,15 +104,17 @@ var DownloadManager = (function DownloadManagerClosure() {
   return DownloadManager;
 })();
 
-Preferences.prototype.writeToStorage = function(prefObj) {
+Preferences._writeToStorage = function (prefObj) {
-  FirefoxCom.requestSync('setPreferences', prefObj);
+  return new Promise(function (resolve) {
+    FirefoxCom.request('setPreferences', prefObj, resolve);
+  });
 };
 
-Preferences.prototype.readFromStorage = function(prefObj) {
+Preferences._readFromStorage = function (prefObj) {
-  var readFromStoragePromise = new Promise(function (resolve) {
+  return new Promise(function (resolve) {
-    var readPrefs = JSON.parse(FirefoxCom.requestSync('getPreferences',
+    FirefoxCom.request('getPreferences', prefObj, function (prefStr) {
-                                                      prefObj));
+      var readPrefs = JSON.parse(prefStr);
-    resolve(readPrefs);
+      resolve(readPrefs);
+    });
   });
-  return readFromStoragePromise;
 };

web/hand_tool.js

@@ -14,7 +14,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-/* globals mozL10n, GrabToPan, PDFView, SecondaryToolbar */
+/* globals mozL10n, GrabToPan, PDFView, Preferences, SecondaryToolbar */
 
 'use strict';
 
@@ -43,8 +43,15 @@ var HandTool = {
     });
     if (toggleHandTool) {
       toggleHandTool.addEventListener('click', this.toggle.bind(this), false);
+
+      window.addEventListener('localized', function (evt) {
+        Preferences.get('enableHandToolOnLoad').then(function (prefValue) {
+          if (prefValue) {
+            this.handTool.activate();
+          }
+        }.bind(this));
+      }.bind(this));
     }
-    // TODO: Read global prefs and call this.handTool.activate() if needed.
   },
 
   toggle: function handToolToggle() {

web/preferences.js

@@ -14,51 +14,99 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-/* globals DEFAULT_PREFERENCES, PDFJS, isLocalStorageEnabled, Promise */
+/* globals DEFAULT_PREFERENCES, isLocalStorageEnabled, Promise */
 
 'use strict';
 
 //#include default_preferences.js
 
-var Preferences = (function PreferencesClosure() {
+/**
-  function Preferences() {
+ * Preferences - Utility for storing persistent settings.
-    this.prefs = {};
+ *   Used for settings that should be applied to all opened documents,
-    this.isInitializedPromiseResolved = false;
+ *   or every time the viewer is loaded.
-    this.initializedPromise = this.readFromStorage(DEFAULT_PREFERENCES).then(
+ */
-      function(prefObj) {
+var Preferences = {
-        this.isInitializedPromiseResolved = true;
+  prefs: Object.create(DEFAULT_PREFERENCES),
+  isInitializedPromiseResolved: false,
+  initializedPromise: null,
+
+  /**
+   * Initialize and fetch the current preference values from storage.
+   * @return {Promise} A promise that is resolved when the preferences
+   *                   have been initialized.
+   */
+  initialize: function preferencesInitialize() {
+    return this.initializedPromise =
+        this._readFromStorage(DEFAULT_PREFERENCES).then(function(prefObj) {
+      this.isInitializedPromiseResolved = true;
+      if (prefObj) {
+        this.prefs = prefObj;
+      }
+    }.bind(this));
+  },
+
+  /**
+   * Stub function for writing preferences to storage.
+   * NOTE: This should be overridden by a build-specific function defined below.
+   * @param {Object} prefObj The preferences that should be written to storage.
+   * @return {Promise} A promise that is resolved when the preference values
+   *                   have been written.
+   */
+  _writeToStorage: function preferences_writeToStorage(prefObj) {
+    return Promise.resolve();
+  },
+
+  /**
+   * Stub function for reading preferences from storage.
+   * NOTE: This should be overridden by a build-specific function defined below.
+   * @param {Object} prefObj The preferences that should be read from storage.
+   * @return {Promise} A promise that is resolved with an {Object} containing
+   *                   the preferences that have been read.
+   */
+  _readFromStorage: function preferences_readFromStorage(prefObj) {
+    return Promise.resolve();
+  },
+
+  /**
+   * Reset the preferences to their default values and update storage.
+   * @return {Promise} A promise that is resolved when the preference values
+   *                   have been reset.
+   */
+  reset: function preferencesReset() {
+    return this.initializedPromise.then(function() {
+      this.prefs = Object.create(DEFAULT_PREFERENCES);
+      return this._writeToStorage(DEFAULT_PREFERENCES);
+    }.bind(this));
+  },
+
+  /**
+   * Replace the current preference values with the ones from storage.
+   * @return {Promise} A promise that is resolved when the preference values
+   *                   have been updated.
+   */
+  reload: function preferencesReload() {
+    return this.initializedPromise.then(function () {
+      this._readFromStorage(DEFAULT_PREFERENCES).then(function(prefObj) {
         if (prefObj) {
           this.prefs = prefObj;
         }
       }.bind(this));
-  }
+    }.bind(this));
-
+  },
-  Preferences.prototype = {
-    writeToStorage: function Preferences_writeToStorage(prefObj) {
-      return;
-    },
 
-    readFromStorage: function Preferences_readFromStorage(prefObj) {
+  /**
-      var readFromStoragePromise = Promise.resolve();
+   * Set the value of a preference.
-      return readFromStoragePromise;
+   * @param {string} name The name of the preference that should be changed.
-    },
+   * @param {boolean|number|string} value The new value of the preference.
-
+   * @return {Promise} A promise that is resolved when the value has been set,
-    reset: function Preferences_reset() {
+   *                   provided that the preference exists and the types match.
-      if (this.isInitializedPromiseResolved) {
+   */
-        this.prefs = {};
+  set: function preferencesSet(name, value) {
-        this.writeToStorage(DEFAULT_PREFERENCES);
+    return this.initializedPromise.then(function () {
-      }
+      if (DEFAULT_PREFERENCES[name] === undefined) {
-    },
+        throw new Error('preferencesSet: \'' + name + '\' is undefined.');
-
-    set: function Preferences_set(name, value) {
-      if (!this.isInitializedPromiseResolved) {
-        return;
-      } else if (DEFAULT_PREFERENCES[name] === undefined) {
-        console.error('Preferences_set: \'' + name + '\' is undefined.');
-        return;
       } else if (value === undefined) {
-        console.error('Preferences_set: no value is specified.');
+        throw new Error('preferencesSet: no value is specified.');
-        return;
       }
       var valueType = typeof value;
       var defaultType = typeof DEFAULT_PREFERENCES[name];
@@ -67,71 +115,79 @@ var Preferences = (function PreferencesClosure() {
         if (valueType === 'number' && defaultType === 'string') {
           value = value.toString();
         } else {
-          console.error('Preferences_set: \'' + value + '\' is a \"' +
+          throw new Error('Preferences_set: \'' + value + '\' is a \"' +
-                        valueType + '\", expected a \"' + defaultType + '\".');
+                          valueType + '\", expected \"' + defaultType + '\".');
-          return;
         }
       } else {
         if (valueType === 'number' && (value | 0) !== value) {
-          console.error('Preferences_set: \'' + value +
+          throw new Error('Preferences_set: \'' + value +
-                        '\' must be an \"integer\".');
+                          '\' must be an \"integer\".');
-          return;
         }
       }
       this.prefs[name] = value;
-      this.writeToStorage(this.prefs);
+      return this._writeToStorage(this.prefs);
-    },
+    }.bind(this));
+  },
 
-    get: function Preferences_get(name) {
+  /**
-      var defaultPref = DEFAULT_PREFERENCES[name];
+   * Get the value of a preference.
+   * @param {string} name The name of the preference whose value is requested.
+   * @return {Promise} A promise that is resolved with a {boolean|number|string}
+   *                   containing the value of the preference.
+   */
+  get: function preferencesGet(name) {
+    return this.initializedPromise.then(function () {
+      var defaultValue = DEFAULT_PREFERENCES[name];
 
-      if (defaultPref === undefined) {
+      if (defaultValue === undefined) {
-        console.error('Preferences_get: \'' + name + '\' is undefined.');
+        throw new Error('preferencesGet: \'' + name + '\' is undefined.');
-        return;
+      } else {
-      } else if (this.isInitializedPromiseResolved) {
+        var prefValue = this.prefs[name];
-        var pref = this.prefs[name];
 
-        if (pref !== undefined) {
+        if (prefValue !== undefined) {
-          return pref;
+          return prefValue;
         }
       }
-      return defaultPref;
+      return defaultValue;
-    }
+    }.bind(this));
-  };
+  }
-
+};
-  return Preferences;
-})();
 
 //#if B2G
-//Preferences.prototype.writeToStorage = function(prefObj) {
+//Preferences._writeToStorage = function (prefObj) {
-//  asyncStorage.setItem('pdfjs.preferences', JSON.stringify(prefObj));
+//  return new Promise(function (resolve) {
+//    asyncStorage.setItem('pdfjs.preferences', JSON.stringify(prefObj),
+//                         resolve);
+//  });
 //};
 //
-//Preferences.prototype.readFromStorage = function(prefObj) {
+//Preferences._readFromStorage = function (prefObj) {
-//  var readFromStoragePromise = new Promise(function (resolve) {
+//  return new Promise(function (resolve) {
-//    asyncStorage.getItem('pdfjs.preferences', function(prefStr) {
+//    asyncStorage.getItem('pdfjs.preferences', function (prefStr) {
 //      var readPrefs = JSON.parse(prefStr);
 //      resolve(readPrefs);
 //    });
 //  });
-//  return readFromStoragePromise;
 //};
 //#endif
 
 //#if !(FIREFOX || MOZCENTRAL || B2G)
-Preferences.prototype.writeToStorage = function(prefObj) {
+Preferences._writeToStorage = function (prefObj) {
-  if (isLocalStorageEnabled) {
+  return new Promise(function (resolve) {
-    localStorage.setItem('pdfjs.preferences', JSON.stringify(prefObj));
+    if (isLocalStorageEnabled) {
-  }
+      localStorage.setItem('pdfjs.preferences', JSON.stringify(prefObj));
+    }
+    resolve();
+  });
 };
 
-Preferences.prototype.readFromStorage = function(prefObj) {
+Preferences._readFromStorage = function (prefObj) {
-  var readFromStoragePromise = new Promise(function (resolve) {
+  return new Promise(function (resolve) {
+    var readPrefs;
     if (isLocalStorageEnabled) {
-      var readPrefs = JSON.parse(localStorage.getItem('pdfjs.preferences'));
+      readPrefs = JSON.parse(localStorage.getItem('pdfjs.preferences'));
-      resolve(readPrefs);
     }
+    resolve(readPrefs);
   });
-  return readFromStoragePromise;
 };
 //#endif

web/viewer.js

@@ -140,6 +140,8 @@ var PDFView = {
     this.watchScroll(thumbnailContainer, this.thumbnailViewScroll,
                      this.renderHighestPriority.bind(this));
 
+    Preferences.initialize();
+
     PDFFindBar.initialize({
       bar: document.getElementById('findbar'),
       toggleButton: document.getElementById('viewFind'),
@@ -583,6 +585,9 @@ var PDFView = {
                              pdfDataRangeTransport, args) {
     if (this.pdfDocument) {
       this.close();
+
+      // Reload the preferences if a document was previously opened.
+      Preferences.reload();
     }
 
     var parameters = {password: password};
@@ -904,7 +909,6 @@ var PDFView = {
       mozL10n.get('page_of', {pageCount: pagesCount}, 'of {{pageCount}}');
     document.getElementById('pageNumber').max = pagesCount;
 
-    var prefs = PDFView.prefs = new Preferences();
     PDFView.documentFingerprint = id;
     var store = PDFView.store = new ViewHistory(id);
 
@@ -973,15 +977,26 @@ var PDFView = {
       PDFView.loadingBar.setWidth(container);
 
       PDFFindController.resolveFirstPage();
+
+      // Initialize the browsing history.
+      PDFHistory.initialize(self.documentFingerprint);
     });
 
-    var prefsPromise = prefs.initializedPromise;
+    // Fetch the necessary preference values.
-    var storePromise = store.initializedPromise;
+    var showPreviousViewOnLoad;
-    Promise.all([firstPagePromise, prefsPromise, storePromise]).
+    var showPreviousViewOnLoadPromise =
-        then(function() {
+      Preferences.get('showPreviousViewOnLoad').then(function (prefValue) {
-      var showPreviousViewOnLoad = prefs.get('showPreviousViewOnLoad');
+        showPreviousViewOnLoad = prefValue;
-      var defaultZoomValue = prefs.get('defaultZoomValue');
+      });
+    var defaultZoomValue;
+    var defaultZoomValuePromise =
+      Preferences.get('defaultZoomValue').then(function (prefValue) {
+        defaultZoomValue = prefValue;
+      });
 
+    var storePromise = store.initializedPromise;
+    Promise.all([firstPagePromise, storePromise, showPreviousViewOnLoadPromise,
+                 defaultZoomValuePromise]).then(function resolved() {
       var storedHash = null;
       if (showPreviousViewOnLoad && store.get('exists', false)) {
         var pageNum = store.get('page', '1');
@@ -994,9 +1009,6 @@ var PDFView = {
       } else if (defaultZoomValue) {
         storedHash = 'page=1&zoom=' + defaultZoomValue;
       }
-      // Initialize the browsing history.
-      PDFHistory.initialize(self.documentFingerprint);
-
       self.setInitialView(storedHash, scale);
 
       // Make all navigation keys work on document load,
@@ -1007,6 +1019,12 @@ var PDFView = {
 //      self.container.blur();
 //#endif
       }
+    }, function rejected(errorMsg) {
+      console.error(errorMsg);
+
+      firstPagePromise.then(function () {
+        self.setInitialView(null, scale);
+      });
     });
 
     pagesPromise.then(function() {
@@ -1045,11 +1063,16 @@ var PDFView = {
         self.outline = new DocumentOutlineView(outline);
         document.getElementById('viewOutline').disabled = !outline;
 
-        if (outline && prefs.get('ifAvailableShowOutlineOnLoad')) {
+        if (outline) {
-          if (!self.sidebarOpen) {
+          Preferences.get('ifAvailableShowOutlineOnLoad').then(
-            document.getElementById('sidebarToggle').click();
+            function (prefValue) {
-          }
+              if (prefValue) {
-          self.switchSidebarView('outline');
+                if (!self.sidebarOpen) {
+                  document.getElementById('sidebarToggle').click();
+                }
+                self.switchSidebarView('outline');
+              }
+            });
         }
       });
     });