DevTools: remove Object.observe usage, it is being deprecated.

third_party/WebKit/Source/devtools/front_end/common/Settings.js

 /*
  * Copyright (C) 2009 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 12 matching lines @@
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 /**
  * @constructor
- * @param {!Object<string, string>} prefs
+ * @param {!WebInspector.SettingsStorage} storage
  */
-WebInspector.Settings = function(prefs)
+WebInspector.Settings = function(storage)
 {
-    this._settingsStorage = prefs;
+    this._settingsStorage = storage;
+    this._localStorage = new WebInspector.SettingsStorage(window.localStorage || {});
+
     this._eventSupport = new WebInspector.Object();
     /** @type {!Map<string, !WebInspector.Setting>} */
     this._registry = new Map();
     /** @type {!Map<string, !WebInspector.Setting>} */
     this._moduleSettings = new Map();
     self.runtime.extensions("setting").forEach(this._registerModuleSetting.bind(this));
 }
 
 WebInspector.Settings.prototype = {
     /**
@@ skipping 36 matching lines @@
 
     /**
      * @param {string} key
      * @param {*} defaultValue
      * @param {boolean=} isLocal
      * @return {!WebInspector.Setting}
      */
     createSetting: function(key, defaultValue, isLocal)
     {
         if (!this._registry.get(key))
-            this._registry.set(key, new WebInspector.Setting(this, key, defaultValue, this._eventSupport, isLocal ? (window.localStorage || {}) : this._settingsStorage));
+            this._registry.set(key, new WebInspector.Setting(this, key, defaultValue, this._eventSupport, isLocal ? this._localStorage : this._settingsStorage));
         return /** @type {!WebInspector.Setting} */ (this._registry.get(key));
     },
 
     /**
      * @param {string} key
      * @param {*} defaultValue
      * @return {!WebInspector.Setting}
      */
     createLocalSetting: function(key, defaultValue)
     {
         return this.createSetting(key, defaultValue, true);
     },
 
     /**
      * @param {string} key
      * @param {string} defaultValue
      * @param {string=} regexFlags
      * @param {boolean=} isLocal
      * @return {!WebInspector.RegExpSetting}
      */
     createRegExpSetting: function(key, defaultValue, regexFlags, isLocal)
     {
         if (!this._registry.get(key))
-            this._registry.set(key, new WebInspector.RegExpSetting(this, key, defaultValue, this._eventSupport, isLocal ? (window.localStorage || {}) : this._settingsStorage, regexFlags));
+            this._registry.set(key, new WebInspector.RegExpSetting(this, key, defaultValue, this._eventSupport, isLocal ? this._localStorage : this._settingsStorage, regexFlags));
         return /** @type {!WebInspector.RegExpSetting} */ (this._registry.get(key));
     },
 
     clearAll: function()
     {
-        if (window.localStorage)
-            window.localStorage.clear();
-        for (var key in this._settingsStorage)
-            delete this._settingsStorage[key];
+        this._settingsStorage.removeAll();
+        this._localStorage.removeAll();
         var versionSetting = WebInspector.settings.createSetting(WebInspector.VersionController._currentVersionName, 0);
         versionSetting.set(WebInspector.VersionController.currentVersion);
     }
 }
 
 /**
  * @constructor
+ * @param {!Object} object
+ * @param {function(string, string)=} setCallback
+ * @param {function(string)=} removeCallback
+ * @param {function(string)=} removeAllCallback
+ */
+WebInspector.SettingsStorage = function(object, setCallback, removeCallback, removeAllCallback)
+{
+    this._object = object;
+    this._setCallback = setCallback || function() {};
+    this._removeCallback = removeCallback || function() {};
+    this._removeAllCallback = removeAllCallback || function() {};
+}
+
+WebInspector.SettingsStorage.prototype = {
+    /**
+     * @param {string} name
+     * @param {string} value
+     */
+    set: function(name, value)
+    {
+        this._object[name] = value;
+        this._setCallback(name, value);
+    },
+
+    /**
+     * @param {string} name
+     * @return {boolean}
+     */
+    has: function(name)
+    {
+        return name in this._object;
+    },
+
+    /**
+     * @param {string} name
+     * @return {string}
+     */
+    get: function(name)
+    {
+        return this._object[name];
+    },
+
+    /**
+     * @param {string} name
+     */
+    remove: function(name)
+    {
+        delete this._object[name];
+        this._removeCallback(name);
+    },
+
+    removeAll: function()
+    {
+        this._object = {};
+        this._removeAllCallback();
+    },
+
+    _dumpSizes: function()
+    {
+        WebInspector.console.log("Ten largest settings: ");
+
+        var sizes = { __proto__: null };
+        for (var key in this._object)
+            sizes[key] = this._object[key].length;
+        var keys = Object.keys(sizes);
+
+        function comparator(key1, key2)
+        {
+            return sizes[key2] - sizes[key1];
+        }
+
+        keys.sort(comparator);
+
+        for (var i = 0; i < 10 && i < keys.length; ++i)
+            WebInspector.console.log("Setting: '" + keys[i] + "', size: " + sizes[keys[i]]);
+    }
+}
+
+/**
+ * @constructor
  * @param {!WebInspector.Settings} settings
  * @param {string} name
  * @param {V} defaultValue
  * @param {!WebInspector.Object} eventSupport
- * @param {!Object} storage
+ * @param {!WebInspector.SettingsStorage} storage
  * @template V
  */
 WebInspector.Setting = function(settings, name, defaultValue, eventSupport, storage)
 {
     this._settings = settings;
     this._name = name;
     this._defaultValue = defaultValue;
     this._eventSupport = eventSupport;
     this._storage = storage;
 }
@@ skipping 24 matching lines @@
 
     /**
      * @return {V}
      */
     get: function()
     {
         if (typeof this._value !== "undefined")
             return this._value;
 
         this._value = this._defaultValue;
-        if (this._name in this._storage) {
+        if (this._storage.has(this._name)) {
             try {
-                this._value = JSON.parse(this._storage[this._name]);
+                this._value = JSON.parse(this._storage.get(this._name));
             } catch(e) {
                 this.remove();
             }
         }
         return this._value;
     },
 
     /**
      * @param {V} value
      */
     set: function(value)
     {
         this._value = value;
         try {
             var settingString = JSON.stringify(value);
             try {
-                this._storage[this._name] = settingString;
+                this._storage.set(this._name, settingString);
             } catch(e) {
                 this._printSettingsSavingError(e.message, this._name, settingString);
             }
         } catch(e) {
             WebInspector.console.error("Cannot stringify setting with name: " + this._name + ", error: " + e.message);
         }
         this._eventSupport.dispatchEventToListeners(this._name, value);
     },
 
     remove: function()
     {
         this._settings._registry.delete(this._name);
         this._settings._moduleSettings.delete(this._name);
-        delete this._storage[this._name];
+        this._storage.remove(this._name);
     },
 
     /**
      * @param {string} message
      * @param {string} name
      * @param {string} value
      */
     _printSettingsSavingError: function(message, name, value)
     {
         var errorMessage = "Error saving setting with name: " + this._name + ", value length: " + value.length + ". Error: " + message;
         console.error(errorMessage);
         WebInspector.console.error(errorMessage);
-        WebInspector.console.log("Ten largest settings: ");
-
-        var sizes = { __proto__: null };
-        for (var key in this._storage)
-            sizes[key] = this._storage[key].length;
-        var keys = Object.keys(sizes);
-
-        function comparator(key1, key2)
-        {
-            return sizes[key2] - sizes[key1];
-        }
-
-        keys.sort(comparator);
-
-        for (var i = 0; i < 10 && i < keys.length; ++i)
-            WebInspector.console.log("Setting: '" + keys[i] + "', size: " + sizes[keys[i]]);
+        this._storage._dumpSizes();
     }
 }
 
 /**
  * @constructor
  * @extends {WebInspector.Setting}
  * @param {!WebInspector.Settings} settings
  * @param {string} name
  * @param {string} defaultValue
  * @param {!WebInspector.Object} eventSupport
- * @param {!Object<string, string>} storage
+ * @param {!WebInspector.SettingsStorage} storage
  * @param {string=} regexFlags
  */
 WebInspector.RegExpSetting = function(settings, name, defaultValue, eventSupport, storage, regexFlags)
 {
     WebInspector.Setting.call(this, settings, name, defaultValue ? [{ pattern: defaultValue }] : [], eventSupport, storage);
     this._regexFlags = regexFlags;
 }
 
 WebInspector.RegExpSetting.prototype = {
     /**
@@ skipping 381 matching lines @@
 }
 
 /**
  * @param {string} settingName
  * @return {!WebInspector.Setting}
  */
 WebInspector.settingForTest = function(settingName)
 {
     return WebInspector.settings.settingForTest(settingName);
 }