src/chrome/browser/resources/options/preferences.js

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 cr.define('options', function() {
   6
   7   /////////////////////////////////////////////////////////////////////////////
   8   // Preferences class:
   9
  10   /**
  11    * Preferences class manages access to Chrome profile preferences.
  12    * @constructor
  13    */
  14   function Preferences() {
  15     // Map of registered preferences.
  16     this.registeredPreferences_ = {};
  17   }
  18
  19   cr.addSingletonGetter(Preferences);
  20
  21   /**
  22    * Sets a Boolean preference and signals its new value.
  23    * @param {string} name Preference name.
  24    * @param {boolean} value New preference value.
  25    * @param {boolean} commit Whether to commit the change to Chrome.
  26    * @param {string} metric User metrics identifier.
  27    */
  28   Preferences.setBooleanPref = function(name, value, commit, metric) {
  29     if (!commit) {
  30       Preferences.getInstance().setPrefNoCommit_(name, 'bool', Boolean(value));
  31       return;
  32     }
  33
  34     var argumentList = [name, Boolean(value)];
  35     if (metric != undefined) argumentList.push(metric);
  36     chrome.send('setBooleanPref', argumentList);
  37   };
  38
  39   /**
  40    * Sets an integer preference and signals its new value.
  41    * @param {string} name Preference name.
  42    * @param {number} value New preference value.
  43    * @param {boolean} commit Whether to commit the change to Chrome.
  44    * @param {string} metric User metrics identifier.
  45    */
  46   Preferences.setIntegerPref = function(name, value, commit, metric) {
  47     if (!commit) {
  48       Preferences.getInstance().setPrefNoCommit_(name, 'int', Number(value));
  49       return;
  50     }
  51
  52     var argumentList = [name, Number(value)];
  53     if (metric != undefined) argumentList.push(metric);
  54     chrome.send('setIntegerPref', argumentList);
  55   };
  56
  57   /**
  58    * Sets a double-valued preference and signals its new value.
  59    * @param {string} name Preference name.
  60    * @param {number} value New preference value.
  61    * @param {boolean} commit Whether to commit the change to Chrome.
  62    * @param {string} metric User metrics identifier.
  63    */
  64   Preferences.setDoublePref = function(name, value, commit, metric) {
  65     if (!commit) {
  66       Preferences.getInstance().setPrefNoCommit_(name, 'double', Number(value));
  67       return;
  68     }
  69
  70     var argumentList = [name, Number(value)];
  71     if (metric != undefined) argumentList.push(metric);
  72     chrome.send('setDoublePref', argumentList);
  73   };
  74
  75   /**
  76    * Sets a string preference and signals its new value.
  77    * @param {string} name Preference name.
  78    * @param {string} value New preference value.
  79    * @param {boolean} commit Whether to commit the change to Chrome.
  80    * @param {string} metric User metrics identifier.
  81    */
  82   Preferences.setStringPref = function(name, value, commit, metric) {
  83     if (!commit) {
  84       Preferences.getInstance().setPrefNoCommit_(name, 'string', String(value));
  85       return;
  86     }
  87
  88     var argumentList = [name, String(value)];
  89     if (metric != undefined) argumentList.push(metric);
  90     chrome.send('setStringPref', argumentList);
  91   };
  92
  93   /**
  94    * Sets a string preference that represents a URL and signals its new value.
  95    * The value will be fixed to be a valid URL when it gets committed to Chrome.
  96    * @param {string} name Preference name.
  97    * @param {string} value New preference value.
  98    * @param {boolean} commit Whether to commit the change to Chrome.
  99    * @param {string} metric User metrics identifier.
 100    */
 101   Preferences.setURLPref = function(name, value, commit, metric) {
 102     if (!commit) {
 103       Preferences.getInstance().setPrefNoCommit_(name, 'url', String(value));
 104       return;
 105     }
 106
 107     var argumentList = [name, String(value)];
 108     if (metric != undefined) argumentList.push(metric);
 109     chrome.send('setURLPref', argumentList);
 110   };
 111
 112   /**
 113    * Sets a JSON list preference and signals its new value.
 114    * @param {string} name Preference name.
 115    * @param {Array} value New preference value.
 116    * @param {boolean} commit Whether to commit the change to Chrome.
 117    * @param {string} metric User metrics identifier.
 118    */
 119   Preferences.setListPref = function(name, value, commit, metric) {
 120     if (!commit) {
 121       Preferences.getInstance().setPrefNoCommit_(name, 'list', value);
 122       return;
 123     }
 124
 125     var argumentList = [name, JSON.stringify(value)];
 126     if (metric != undefined) argumentList.push(metric);
 127     chrome.send('setListPref', argumentList);
 128   };
 129
 130   /**
 131    * Clears the user setting for a preference and signals its new effective
 132    * value.
 133    * @param {string} name Preference name.
 134    * @param {boolean} commit Whether to commit the change to Chrome.
 135    * @param {string} metric User metrics identifier.
 136    */
 137   Preferences.clearPref = function(name, commit, metric) {
 138     if (!commit) {
 139       Preferences.getInstance().clearPrefNoCommit_(name);
 140       return;
 141     }
 142
 143     var argumentList = [name];
 144     if (metric != undefined) argumentList.push(metric);
 145     chrome.send('clearPref', argumentList);
 146   };
 147
 148   Preferences.prototype = {
 149     __proto__: cr.EventTarget.prototype,
 150
 151     /**
 152      * Adds an event listener to the target.
 153      * @param {string} type The name of the event.
 154      * @param {!Function|{handleEvent:Function}} handler The handler for the
 155      *     event. This is called when the event is dispatched.
 156      */
 157     addEventListener: function(type, handler) {
 158       cr.EventTarget.prototype.addEventListener.call(this, type, handler);
 159       if (!(type in this.registeredPreferences_))
 160         this.registeredPreferences_[type] = {};
 161     },
 162
 163     /**
 164      * Initializes preference reading and change notifications.
 165      */
 166     initialize: function() {
 167       var params1 = ['Preferences.prefsFetchedCallback'];
 168       var params2 = ['Preferences.prefsChangedCallback'];
 169       for (var prefName in this.registeredPreferences_) {
 170         params1.push(prefName);
 171         params2.push(prefName);
 172       }
 173       chrome.send('fetchPrefs', params1);
 174       chrome.send('observePrefs', params2);
 175     },
 176
 177     /**
 178      * Helper function for flattening of dictionary passed via fetchPrefs
 179      * callback.
 180      * @param {string} prefix Preference name prefix.
 181      * @param {object} dict Map with preference values.
 182      * @private
 183      */
 184     flattenMapAndDispatchEvent_: function(prefix, dict) {
 185       for (var prefName in dict) {
 186         var value = dict[prefName];
 187         if (typeof value == 'object' &&
 188             !this.registeredPreferences_[prefix + prefName]) {
 189           this.flattenMapAndDispatchEvent_(prefix + prefName + '.', value);
 190         } else if (value) {
 191           var event = new Event(prefix + prefName);
 192           this.registeredPreferences_[prefix + prefName].orig = value;
 193           event.value = value;
 194           this.dispatchEvent(event);
 195         }
 196       }
 197     },
 198
 199     /**
 200      * Sets a preference and signals its new value. The change is propagated
 201      * throughout the UI code but is not committed to Chrome yet. The new value
 202      * and its data type are stored so that commitPref() can later be used to
 203      * invoke the appropriate set*Pref() method and actually commit the change.
 204      * @param {string} name Preference name.
 205      * @param {string} type Preference data type.
 206      * @param {*} value New preference value.
 207      * @private
 208      */
 209     setPrefNoCommit_: function(name, type, value) {
 210       var pref = this.registeredPreferences_[name];
 211       pref.action = 'set';
 212       pref.type = type;
 213       pref.value = value;
 214
 215       var event = new Event(name);
 216       // Decorate pref value as CoreOptionsHandler::CreateValueForPref() does.
 217       event.value = {value: value, uncommitted: true};
 218       if (pref.orig) {
 219         event.value.recommendedValue = pref.orig.recommendedValue;
 220         event.value.disabled = pref.orig.disabled;
 221       }
 222       this.dispatchEvent(event);
 223     },
 224
 225     /**
 226      * Clears a preference and signals its new value. The change is propagated
 227      * throughout the UI code but is not committed to Chrome yet.
 228      * @param {string} name Preference name.
 229      * @private
 230      */
 231     clearPrefNoCommit_: function(name) {
 232       var pref = this.registeredPreferences_[name];
 233       pref.action = 'clear';
 234       delete pref.type;
 235       delete pref.value;
 236
 237       var event = new Event(name);
 238       // Decorate pref value as CoreOptionsHandler::CreateValueForPref() does.
 239       event.value = {controlledBy: 'recommended', uncommitted: true};
 240       if (pref.orig) {
 241         event.value.value = pref.orig.recommendedValue;
 242         event.value.recommendedValue = pref.orig.recommendedValue;
 243         event.value.disabled = pref.orig.disabled;
 244       }
 245       this.dispatchEvent(event);
 246     },
 247
 248     /**
 249      * Commits a preference change to Chrome and signals the new preference
 250      * value. Does nothing if there is no uncommitted change.
 251      * @param {string} name Preference name.
 252      * @param {string} metric User metrics identifier.
 253      */
 254     commitPref: function(name, metric) {
 255       var pref = this.registeredPreferences_[name];
 256       switch (pref.action) {
 257         case 'set':
 258           switch (pref.type) {
 259             case 'bool':
 260               Preferences.setBooleanPref(name, pref.value, true, metric);
 261               break;
 262             case 'int':
 263               Preferences.setIntegerPref(name, pref.value, true, metric);
 264               break;
 265             case 'double':
 266               Preferences.setDoublePref(name, pref.value, true, metric);
 267               break;
 268             case 'string':
 269               Preferences.setStringPref(name, pref.value, true, metric);
 270               break;
 271             case 'url':
 272               Preferences.setURLPref(name, pref.value, true, metric);
 273               break;
 274             case 'list':
 275               Preferences.setListPref(name, pref.value, true, metric);
 276               break;
 277           }
 278           break;
 279         case 'clear':
 280           Preferences.clearPref(name, true, metric);
 281           break;
 282       }
 283       delete pref.action;
 284       delete pref.type;
 285       delete pref.value;
 286     },
 287
 288     /**
 289      * Rolls back a preference change and signals the original preference value.
 290      * Does nothing if there is no uncommitted change.
 291      * @param {string} name Preference name.
 292      */
 293     rollbackPref: function(name) {
 294       var pref = this.registeredPreferences_[name];
 295       if (!pref.action)
 296         return;
 297
 298       delete pref.action;
 299       delete pref.type;
 300       delete pref.value;
 301
 302       var event = new Event(name);
 303       event.value = pref.orig || {};
 304       event.value.uncommitted = true;
 305       this.dispatchEvent(event);
 306     }
 307   };
 308
 309   /**
 310    * Callback for fetchPrefs method.
 311    * @param {object} dict Map of fetched property values.
 312    */
 313   Preferences.prefsFetchedCallback = function(dict) {
 314     Preferences.getInstance().flattenMapAndDispatchEvent_('', dict);
 315   };
 316
 317   /**
 318    * Callback for observePrefs method.
 319    * @param {array} notification An array defining changed preference values.
 320    * notification[0] contains name of the change preference while its new value
 321    * is stored in notification[1].
 322    */
 323   Preferences.prefsChangedCallback = function(notification) {
 324     var event = new Event(notification[0]);
 325     event.value = notification[1];
 326     prefs = Preferences.getInstance();
 327     prefs.registeredPreferences_[notification[0]] = {orig: notification[1]};
 328     if (event.value)
 329       prefs.dispatchEvent(event);
 330   };
 331
 332   // Export
 333   return {
 334     Preferences: Preferences
 335   };
 336
 337 });