DevTools: use semicolons after each statement.

third_party/WebKit/Source/devtools/front_end/Runtime.js

 /*
  * Copyright (C) 2014 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 79 matching lines @@
             if (xhr.readyState !== XMLHttpRequest.DONE)
                 return;
 
             if ([0, 200, 304].indexOf(xhr.status) === -1)  // Testing harness file:/// results in 0.
                 reject(new Error("While loading from url " + url + " server responded with a status of " + xhr.status));
             else
                 fulfill(e.target.response);
         }
         xhr.send(null);
     }
-}
+};
 
 /**
  * http://tools.ietf.org/html/rfc3986#section-5.2.4
  * @param {string} path
  * @return {string}
  */
 Runtime.normalizePath = function(path)
 {
     if (path.indexOf("..") === -1 && path.indexOf(".") === -1)
         return path;
@@ skipping 11 matching lines @@
     }
     var normalizedPath = normalizedSegments.join("/");
     if (normalizedPath[normalizedPath.length - 1] === "/")
         return normalizedPath;
     if (path[0] === "/" && normalizedPath)
         normalizedPath = "/" + normalizedPath;
     if ((path[path.length - 1] === "/") || (segments[segments.length - 1] === ".") || (segments[segments.length - 1] === ".."))
         normalizedPath = normalizedPath + "/";
 
     return normalizedPath;
-}
+};
 
 /**
  * @param {!Array.<string>} scriptNames
  * @param {string=} base
  * @return {!Promise.<undefined>}
  */
 Runtime._loadScriptsPromise = function(scriptNames, base)
 {
     /** @type {!Array<!Promise<undefined>>} */
     var promises = [];
@@ skipping 39 matching lines @@
     function evaluateScript(sourceURL, scriptSource)
     {
         _loadedScripts[sourceURL] = true;
         if (!scriptSource) {
             // Do not reject, as this is normal in the hosted mode.
             console.error("Empty response arrived for script '" + sourceURL + "'");
             return;
         }
         self.eval(scriptSource + "\n//# sourceURL=" + sourceURL);
     }
-}
+};
 
 /**
  * @type {!Object.<string, string>}
  */
 Runtime._queryParamsObject = { __proto__: null };
 
 Runtime._instanceSymbol = Symbol("instance");
 Runtime._extensionSymbol = Symbol("extension");
 
 /**
@@ skipping 16 matching lines @@
      */
     function cacheResource(path, content)
     {
         if (!content) {
             console.error("Failed to load resource: " + path);
             return;
         }
         var sourceURL = appendSourceURL ? Runtime.resolveSourceURL(path) : "";
         Runtime.cachedResources[path] = content + sourceURL;
     }
-}
+};
 
 /**
  * @param {string} appName
  * @return {!Promise.<undefined>}
  */
 Runtime.startApplication = function(appName)
 {
     console.timeStamp("Runtime.startApplication");
 
     var allDescriptorsByName = {};
@@ skipping 43 matching lines @@
                 moduleDescriptors[i].name = configuration[i]["name"];
                 moduleDescriptors[i].condition = configuration[i]["condition"];
                 moduleDescriptors[i].remote = configuration[i]["type"] === "remote";
             }
             self.runtime = new Runtime(moduleDescriptors);
             if (coreModuleNames)
                 return /** @type {!Promise<undefined>} */ (self.runtime._loadAutoStartModules(coreModuleNames));
             return Promise.resolve();
         }
     }
-}
+};
 
 /**
  * @param {string} appName
  * @return {!Promise.<undefined>}
  */
 Runtime.startWorker = function(appName)
 {
     return Runtime.startApplication(appName).then(sendWorkerReady);
 
     function sendWorkerReady()
     {
         self.postMessage("workerReady");
     }
-}
+};
 
 /** @type {?function(!MessagePort)} */
 Runtime._sharedWorkerNewPortCallback = null;
 /** @type {!Array<!MessagePort>} */
 Runtime._sharedWorkerConnectedPorts = [];
 
 /**
  * @param {string} appName
  */
 Runtime.startSharedWorker = function(appName)
 {
     var startPromise = Runtime.startApplication(appName);
 
     /**
      * @param {!MessageEvent} event
      */
     self.onconnect = function(event)
     {
         var newPort = /** @type {!MessagePort} */ (event.ports[0]);
         startPromise.then(sendWorkerReadyAndContinue);
 
         function sendWorkerReadyAndContinue()
         {
             newPort.postMessage("workerReady");
             if (Runtime._sharedWorkerNewPortCallback)
                 Runtime._sharedWorkerNewPortCallback.call(null, newPort);
             else
                 Runtime._sharedWorkerConnectedPorts.push(newPort);
         }
-    }
-}
+    };
+};
 
 /**
  * @param {function(!MessagePort)} callback
  */
 Runtime.setSharedWorkerNewPortCallback = function(callback)
 {
     Runtime._sharedWorkerNewPortCallback = callback;
     while (Runtime._sharedWorkerConnectedPorts.length) {
         var port = Runtime._sharedWorkerConnectedPorts.shift();
         callback.call(null, port);
     }
-}
+};
 
 /**
  * @param {string} name
  * @return {?string}
  */
 Runtime.queryParam = function(name)
 {
     return Runtime._queryParamsObject[name] || null;
-}
+};
 
 /**
  * @return {!Object}
  */
 Runtime._experimentsSetting = function()
 {
     try {
         return /** @type {!Object} */ (JSON.parse(self.localStorage && self.localStorage["experiments"] ? self.localStorage["experiments"] : "{}"));
     } catch (e) {
         console.error("Failed to parse localStorage['experiments']");
         return {};
     }
-}
+};
 
 Runtime._console = console;
 Runtime._originalAssert = console.assert;
 Runtime._assert = function(value, message)
 {
     if (value)
         return;
     Runtime._originalAssert.call(Runtime._console, value, message + " " + new Error().stack);
-}
+};
 
 Runtime._platform = "";
 
 /**
  * @param {string} platform
  */
 Runtime.setPlatform = function(platform)
 {
     Runtime._platform = platform;
-}
+};
 
 Runtime.prototype = {
     useTestBase: function()
     {
         Runtime._remoteBase = "http://localhost:8000/inspector-sources/";
         if (Runtime.queryParam("debugFrontend"))
             Runtime._remoteBase += "debug/";
     },
 
     /**
@@ skipping 180 matching lines @@
      * @return {!Object}
      */
     sharedInstance: function(constructorFunction)
     {
         if (Runtime._instanceSymbol in constructorFunction)
             return constructorFunction[Runtime._instanceSymbol];
         var instance = new constructorFunction();
         constructorFunction[Runtime._instanceSymbol] = instance;
         return instance;
     }
-}
+};
 
 /**
  * @constructor
  */
 Runtime.ModuleDescriptor = function()
 {
     /**
      * @type {string}
      */
     this.name;
@@ skipping 15 matching lines @@
 
     /**
      * @type {string|undefined}
      */
     this.condition;
 
     /**
      * @type {boolean|undefined}
      */
     this.remote;
-}
+};
 
 /**
  * @constructor
  */
 Runtime.ExtensionDescriptor = function()
 {
     /**
      * @type {string}
      */
     this.type;
 
     /**
      * @type {string|undefined}
      */
     this.className;
 
     /**
      * @type {string|undefined}
      */
     this.factoryName;
 
     /**
      * @type {!Array.<string>|undefined}
      */
     this.contextTypes;
-}
+};
 
 /**
  * @constructor
  * @param {!Runtime} manager
  * @param {!Runtime.ModuleDescriptor} descriptor
  */
 Runtime.Module = function(manager, descriptor)
 {
     this._manager = manager;
     this._descriptor = descriptor;
     this._name = descriptor.name;
     /** @type {!Array<!Runtime.Extension>} */
     this._extensions = [];
 
     /** @type {!Map<string, !Array<!Runtime.Extension>>} */
     this._extensionsByClassName = new Map();
     var extensions = /** @type {?Array.<!Runtime.ExtensionDescriptor>} */ (descriptor.extensions);
     for (var i = 0; extensions && i < extensions.length; ++i) {
         var extension = new Runtime.Extension(this, extensions[i]);
         this._manager._extensions.push(extension);
         this._extensions.push(extension);
     }
     this._loadedForTest = false;
-}
+};
 
 Runtime.Module.prototype = {
     /**
      * @return {string}
      */
     name: function()
     {
         return this._name;
     },
 
@@ skipping 92 matching lines @@
     substituteURL: function(value)
     {
         var base = this._remoteBase() || "";
         return value.replace(/@url\(([^\)]*?)\)/g, convertURL.bind(this));
 
         function convertURL(match, url)
         {
             return base + this._modularizeURL(url);
         }
     }
-}
+};
 
 /**
  * @param {!Object} descriptor
  * @return {boolean}
  */
 Runtime._isDescriptorEnabled = function(descriptor)
 {
     var activatorExperiment = descriptor["experiment"];
     if (activatorExperiment === "*")
         return Runtime.experiments.supportEnabled();
     if (activatorExperiment && activatorExperiment.startsWith("!") && Runtime.experiments.isEnabled(activatorExperiment.substring(1)))
         return false;
     if (activatorExperiment && !activatorExperiment.startsWith("!") && !Runtime.experiments.isEnabled(activatorExperiment))
         return false;
     var condition = descriptor["condition"];
     if (condition && !condition.startsWith("!") && !Runtime.queryParam(condition))
         return false;
     if (condition && condition.startsWith("!") && Runtime.queryParam(condition.substring(1)))
         return false;
     return true;
-}
+};
 
 /**
  * @constructor
  * @param {!Runtime.Module} module
  * @param {!Runtime.ExtensionDescriptor} descriptor
  */
 Runtime.Extension = function(module, descriptor)
 {
     this._module = module;
     this._descriptor = descriptor;
 
     this._type = descriptor.type;
     this._hasTypeClass = this._type.charAt(0) === "@";
 
     /**
      * @type {?string}
      */
     this._className = descriptor.className || null;
     this._factoryName = descriptor.factoryName || null;
-}
+};
 
 Runtime.Extension.prototype = {
     /**
      * @return {!Object}
      */
     descriptor: function()
     {
         return this._descriptor;
     },
 
@@ skipping 73 matching lines @@
     {
         var contextTypes = this.descriptor().contextTypes;
         if (!contextTypes)
             return false;
         for (var i = 0; i < contextTypes.length; ++i) {
             if (contextType === this._module._manager._resolve(contextTypes[i]))
                 return true;
         }
         return false;
     }
-}
+};
 
 /**
  * @constructor
  */
 Runtime.ExperimentsSupport = function()
 {
     this._supportEnabled = Runtime.queryParam("experiments") !== null;
     this._experiments = [];
     this._experimentNames = {};
     this._enabledTransiently = {};
-}
+};
 
 Runtime.ExperimentsSupport.prototype = {
     /**
      * @return {!Array.<!Runtime.Experiment>}
      */
     allConfigurableExperiments: function()
     {
         var result = [];
         for (var i = 0; i < this._experiments.length; i++) {
             var experiment = this._experiments[i];
@@ skipping 100 matching lines @@
         this._setExperimentsSetting(cleanedUpExperimentSetting);
     },
 
     /**
      * @param {string} experimentName
      */
     _checkExperiment: function(experimentName)
     {
         Runtime._assert(this._experimentNames[experimentName], "Unknown experiment " + experimentName);
     }
-}
+};
 
 /**
  * @constructor
  * @param {!Runtime.ExperimentsSupport} experiments
  * @param {string} name
  * @param {string} title
  * @param {boolean} hidden
  */
 Runtime.Experiment = function(experiments, name, title, hidden)
 {
     this.name = name;
     this.title = title;
     this.hidden = hidden;
     this._experiments = experiments;
-}
+};
 
 Runtime.Experiment.prototype = {
     /**
      * @return {boolean}
      */
     isEnabled: function()
     {
         return this._experiments.isEnabled(this.name);
     },
 
     /**
      * @param {boolean} enabled
      */
     setEnabled: function(enabled)
     {
         this._experiments.setEnabled(this.name, enabled);
     }
-}
+};
 
 {(function parseQueryParameters()
 {
     var queryParams = location.search;
     if (!queryParams)
         return;
     var params = queryParams.substring(1).split("&");
     for (var i = 0; i < params.length; ++i) {
         var pair = params[i].split("=");
         var name = pair.shift();
@@ skipping 20 matching lines @@
  * @param {string} path
  * @return {string}
  */
 Runtime.resolveSourceURL = function(path)
 {
     var sourceURL = self.location.href;
     if (self.location.search)
         sourceURL = sourceURL.replace(self.location.search, "");
     sourceURL = sourceURL.substring(0, sourceURL.lastIndexOf("/") + 1) + path;
     return "\n/*# sourceURL=" + sourceURL + " */";
-}
+};
 
 /**
  * @interface
  */
 function ServicePort() { }
 
 ServicePort.prototype = {
     /**
      * @param {function(string)} messageHandler
      * @param {function(string)} closeHandler
      */
     setHandlers: function(messageHandler, closeHandler) { },
 
     /**
      * @param {string} message
      * @return {!Promise<boolean>}
      */
     send: function(message) { },
 
     /**
      * @return {!Promise<boolean>}
      */
     close: function() { }
-}
+};
 
 /** @type {!Runtime} */
 var runtime;