DevTools: use semicolons after each statement.

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 26 matching lines @@
     this._settingsStorage = storage;
     var clearLocalStorage = window.localStorage ? window.localStorage.clear.bind(window.localStorage) : undefined;
     this._localStorage = new WebInspector.SettingsStorage(window.localStorage || {}, undefined, undefined, clearLocalStorage);
 
     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 = {
     /**
      * @param {!Runtime.Extension} extension
      */
     _registerModuleSetting: function(extension)
     {
         var descriptor = extension.descriptor();
         var settingName = descriptor["settingName"];
         var settingType = descriptor["settingType"];
@@ skipping 64 matching lines @@
         return /** @type {!WebInspector.RegExpSetting} */ (this._registry.get(key));
     },
 
     clearAll: function()
     {
         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);
@@ skipping 44 matching lines @@
         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 {!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;
-}
+};
 
 WebInspector.Setting.prototype = {
     /**
      * @param {function(!WebInspector.Event)} listener
      * @param {!Object=} thisObject
      */
     addChangeListener: function(listener, thisObject)
     {
         this._eventSupport.addEventListener(this._name, listener, thisObject);
     },
@@ skipping 62 matching lines @@
      * @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);
         this._storage._dumpSizes();
     }
-}
+};
 
 /**
  * @constructor
  * @extends {WebInspector.Setting}
  * @param {!WebInspector.Settings} settings
  * @param {string} name
  * @param {string} defaultValue
  * @param {!WebInspector.Object} eventSupport
  * @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 = {
     /**
      * @override
      * @return {string}
      */
     get: function()
     {
         var result = [];
         var items = this.getAsArray();
@@ skipping 42 matching lines @@
         try {
             var pattern = this.get();
             if (pattern)
                 this._regex = new RegExp(pattern, this._regexFlags || "");
         } catch (e) {
         }
         return this._regex;
     },
 
     __proto__: WebInspector.Setting.prototype
-}
+};
 
 /**
  * @constructor
  */
 WebInspector.VersionController = function()
 {
-}
+};
 
 WebInspector.VersionController._currentVersionName = "inspectorVersion";
 WebInspector.VersionController.currentVersion = 20;
 
 WebInspector.VersionController.prototype = {
     updateVersion: function()
     {
         var localStorageVersion = window.localStorage ? window.localStorage[WebInspector.VersionController._currentVersionName] : 0;
         var versionSetting = WebInspector.settings.createSetting(WebInspector.VersionController._currentVersionName, 0);
         var currentVersion = WebInspector.VersionController.currentVersion;
@@ skipping 346 matching lines @@
      * @param {!WebInspector.Setting} breakpointsSetting
      * @param {number} maxBreakpointsCount
      */
     _clearBreakpointsWhenTooMany: function(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([]);
     }
-}
+};
 
 /**
  * @type {!WebInspector.Settings}
  */
 WebInspector.settings;
 
 /**
  * @param {string} settingName
  * @return {!WebInspector.Setting}
  */
 WebInspector.moduleSetting = function(settingName)
 {
     return WebInspector.settings.moduleSetting(settingName);
-}
+};
 
 /**
  * @param {string} settingName
  * @return {!WebInspector.Setting}
  */
 WebInspector.settingForTest = function(settingName)
 {
     return WebInspector.settings.settingForTest(settingName);
-}
+};