DevTools: make disable javascript setting temporary

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 19 matching lines @@
 
 /**
  * @unrestricted
  */
 Common.Settings = class {
   /**
    * @param {!Common.SettingsStorage} globalStorage
    * @param {!Common.SettingsStorage} localStorage
    */
   constructor(globalStorage, localStorage) {
-    this._settingsStorage = globalStorage;
+    this._globalStorage = globalStorage;
     this._localStorage = localStorage;
+    this._sessionStorage = new Common.SettingsStorage({});
 
     this._eventSupport = new Common.Object();
     /** @type {!Map<string, !Common.Setting>} */
     this._registry = new Map();
     /** @type {!Map<string, !Common.Setting>} */
     this._moduleSettings = new Map();
     self.runtime.extensions('setting').forEach(this._registerModuleSetting.bind(this));
   }
 
   /**
    * @param {!Runtime.Extension} extension
    */
   _registerModuleSetting(extension) {
     var descriptor = extension.descriptor();
     var settingName = descriptor['settingName'];
-    var settingType = descriptor['settingType'];
+    var isRegex = descriptor['settingType'] === 'regex';
     var defaultValue = descriptor['defaultValue'];
-    var isLocal = !!descriptor['local'];
-    var setting = settingType === 'regex' ? this.createRegExpSetting(settingName, defaultValue, undefined, isLocal) :
-                                            this.createSetting(settingName, defaultValue, isLocal);
+    var storageType;
+    switch (descriptor['storageType']) {
+      case ('local'):
+        storageType = Common.SettingStorageType.Local;
+        break;
+      case ('session'):
+        storageType = Common.SettingStorageType.Session;
+        break;
+      case ('global'):
+        storageType = Common.SettingStorageType.Global;
+        break;
+      default:
+        storageType = Common.SettingStorageType.Global;
+    }
+    var setting = isRegex ? this.createRegExpSetting(settingName, defaultValue, undefined, storageType) :
+                            this.createSetting(settingName, defaultValue, storageType);
     if (descriptor['title'])
       setting.setTitle(descriptor['title']);
     this._moduleSettings.set(settingName, setting);
   }
 
   /**
    * @param {string} settingName
    * @return {!Common.Setting}
    */
   moduleSetting(settingName) {
@@ skipping 10 matching lines @@
   settingForTest(settingName) {
     var setting = this._registry.get(settingName);
     if (!setting)
       throw new Error('No setting registered: ' + settingName);
     return setting;
   }
 
   /**
    * @param {string} key
    * @param {*} defaultValue
-   * @param {boolean=} isLocal
+   * @param {!Common.SettingStorageType=} storageType
    * @return {!Common.Setting}
    */
-  createSetting(key, defaultValue, isLocal) {
-    if (!this._registry.get(key)) {
-      this._registry.set(
-          key, new Common.Setting(
-                   this, key, defaultValue, this._eventSupport, isLocal ? this._localStorage : this._settingsStorage));
-    }
+  createSetting(key, defaultValue, storageType) {
+    var storage = this._storageFromType(storageType);
+    if (!this._registry.get(key))
+      this._registry.set(key, new Common.Setting(this, key, defaultValue, this._eventSupport, storage));
     return /** @type {!Common.Setting} */ (this._registry.get(key));
   }
 
   /**
    * @param {string} key
    * @param {*} defaultValue
    * @return {!Common.Setting}
    */
   createLocalSetting(key, defaultValue) {
-    return this.createSetting(key, defaultValue, true);
+    return this.createSetting(key, defaultValue, Common.SettingStorageType.Local);
   }
 
   /**
    * @param {string} key
    * @param {string} defaultValue
    * @param {string=} regexFlags
-   * @param {boolean=} isLocal
+   * @param {!Common.SettingStorageType=} storageType
    * @return {!Common.RegExpSetting}
    */
-  createRegExpSetting(key, defaultValue, regexFlags, isLocal) {
+  createRegExpSetting(key, defaultValue, regexFlags, storageType) {
     if (!this._registry.get(key)) {
       this._registry.set(
-          key, new Common.RegExpSetting(
-                   this, key, defaultValue, this._eventSupport, isLocal ? this._localStorage : this._settingsStorage,
-                   regexFlags));
+          key,
+          new Common.RegExpSetting(
+              this, key, defaultValue, this._eventSupport, this._storageFromType(storageType), regexFlags));
     }
     return /** @type {!Common.RegExpSetting} */ (this._registry.get(key));
   }
 
   clearAll() {
-    this._settingsStorage.removeAll();
+    this._globalStorage.removeAll();
     this._localStorage.removeAll();
     var versionSetting = Common.settings.createSetting(Common.VersionController._currentVersionName, 0);
     versionSetting.set(Common.VersionController.currentVersion);
   }
+
+  /**
+   * @param {!Common.SettingStorageType=} storageType
+   * @return {!Common.SettingsStorage}
+   */
+  _storageFromType(storageType) {
+    switch (storageType) {
+      case (Common.SettingStorageType.Local):
+        return this._localStorage;
+      case (Common.SettingStorageType.Session):
+        return this._sessionStorage;
+      case (Common.SettingStorageType.Global):
+        return this._globalStorage;
+    }
+    return this._globalStorage;
+  }
 };
 
 /**
  * @unrestricted
  */
 Common.SettingsStorage = class {
   /**
    * @param {!Object} object
    * @param {function(string, string)=} setCallback
    * @param {function(string)=} removeCallback
@@ skipping 600 matching lines @@
       'watchExpressions', 'workspaceExcludedFolders', 'xhrBreakpoints'
     ]);
     if (!window.localStorage)
       return;
 
     for (var key in window.localStorage) {
       if (localSettings.has(key))
         continue;
       var value = window.localStorage[key];
       window.localStorage.removeItem(key);
-      Common.settings._settingsStorage[key] = value;
+      Common.settings._globalStorage[key] = value;
     }
   }
 
   /**
    * @param {!Common.Setting} breakpointsSetting
    * @param {number} maxBreakpointsCount
    */
   _clearBreakpointsWhenTooMany(breakpointsSetting, maxBreakpointsCount) {
     // If there are too many breakpoints in a storage, it is likely due to a recent bug that caused
     // periodical breakpoints duplication leading to inspector slowness.
     if (breakpointsSetting.get().length > maxBreakpointsCount)
       breakpointsSetting.set([]);
   }
 };
 
 Common.VersionController._currentVersionName = 'inspectorVersion';
 Common.VersionController.currentVersion = 24;
 
 /**
  * @type {!Common.Settings}
  */
 Common.settings;
 
 /**
+ * @enum {symbol}
+ */
+Common.SettingStorageType = {
+  Global: Symbol('Global'),
+  Local: Symbol('Local'),
+  Session: Symbol('Session')
+};
+
+/**
  * @param {string} settingName
  * @return {!Common.Setting}
  */
 Common.moduleSetting = function(settingName) {
   return Common.settings.moduleSetting(settingName);
 };
 
 /**
  * @param {string} settingName
  * @return {!Common.Setting}
  */
 Common.settingForTest = function(settingName) {
   return Common.settings.settingForTest(settingName);
 };