DevTools: use semicolons after each statement.

third_party/WebKit/Source/devtools/front_end/sdk/RemoteObject.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 20 matching lines @@
  /**
  * @typedef {{object: ?WebInspector.RemoteObject, wasThrown: (boolean|undefined)}}
  */
 WebInspector.CallFunctionResult;
 
 /**
  * This may not be an interface due to "instanceof WebInspector.RemoteObject" checks in the code.
  *
  * @constructor
  */
-WebInspector.RemoteObject = function() { }
+WebInspector.RemoteObject = function() { };
 
 WebInspector.RemoteObject.prototype = {
 
     /**
      * @return {?RuntimeAgent.CustomPreview}
      */
     customPreview: function()
     {
         return null;
     },
@@ skipping 223 matching lines @@
         throw new Error("DebuggerModel-less object");
     },
 
     /**
      * @return {boolean}
      */
     isNode: function()
     {
         return false;
     }
-}
+};
 
 /**
  * @param {*} value
  * @return {!WebInspector.RemoteObject}
  */
 WebInspector.RemoteObject.fromLocalObject = function(value)
 {
     return new WebInspector.LocalJSONObject(value);
-}
+};
 
 /**
  * @param {!WebInspector.RemoteObject} remoteObject
  * @return {string}
  */
 WebInspector.RemoteObject.type = function(remoteObject)
 {
     if (remoteObject === null)
         return "null";
 
     var type = typeof remoteObject;
     if (type !== "object" && type !== "function")
         return type;
 
     return remoteObject.type;
-}
+};
 
 /**
  * @param {!WebInspector.RemoteObject|!RuntimeAgent.RemoteObject|!RuntimeAgent.ObjectPreview} object
  * @return {number}
  */
 WebInspector.RemoteObject.arrayLength = function(object)
 {
     if (object.subtype !== "array" && object.subtype !== "typedarray")
         return 0;
     var matches = object.description.match(/\[([0-9]+)\]/);
     if (!matches)
         return 0;
     return parseInt(matches[1], 10);
-}
+};
 
 /**
  * @param {!RuntimeAgent.RemoteObject|!WebInspector.RemoteObject|number|string|boolean|undefined|null} object
  * @return {!RuntimeAgent.CallArgument}
  */
 WebInspector.RemoteObject.toCallArgument = function(object)
 {
     var type = typeof object;
     if (type === "undefined")
         return {};
@@ skipping 19 matching lines @@
         return { unserializableValue: object.unserializableValue };
     if (typeof object._unserializableValue !== "undefined")
         return { unserializableValue: object._unserializableValue };
 
     if (typeof object.objectId !== "undefined")
         return { objectId: object.objectId };
     if (typeof object._objectId !== "undefined")
         return { objectId: object._objectId };
 
     return { value: object.value };
-}
+};
 
 /**
  * @constructor
  * @extends {WebInspector.RemoteObject}
  * @param {!WebInspector.Target} target
  * @param {string|undefined} objectId
  * @param {string} type
  * @param {string|undefined} subtype
  * @param {*} value
  * @param {!RuntimeAgent.UnserializableValue=} unserializableValue
@@ skipping 30 matching lines @@
                 unserializableValue === RuntimeAgent.UnserializableValue.NaN) {
                 this.value = Number(unserializableValue);
             } else {
                 this.value = unserializableValue;
             }
         } else {
             this.value = value;
         }
     }
     this._customPreview = customPreview || null;
-}
+};
 
 WebInspector.RemoteObjectImpl.prototype = {
 
     /**
      * @override
      * @return {?RuntimeAgent.CustomPreview}
      */
     customPreview: function()
     {
         return this._customPreview;
@@ skipping 582 matching lines @@
 
 /**
  * @constructor
  * @param {number} number
  * @param {string=} callFrameId
  */
 WebInspector.ScopeRef = function(number, callFrameId)
 {
     this.number = number;
     this.callFrameId = callFrameId;
-}
+};
 
 /**
  * @constructor
  * @param {string} name
  * @param {?WebInspector.RemoteObject} value
  * @param {boolean=} enumerable
  * @param {boolean=} writable
  * @param {boolean=} isOwn
  * @param {boolean=} wasThrown
  * @param {boolean=} synthetic
  * @param {?WebInspector.RemoteObject=} symbol
  */
 WebInspector.RemoteObjectProperty = function(name, value, enumerable, writable, isOwn, wasThrown, symbol, synthetic)
 {
     this.name = name;
     if (value !== null)
         this.value = value;
     this.enumerable = typeof enumerable !== "undefined" ? enumerable : true;
     this.writable = typeof writable !== "undefined" ? writable : true;
     this.isOwn = !!isOwn;
     this.wasThrown = !!wasThrown;
     if (symbol)
         this.symbol = symbol;
     this.synthetic = !!synthetic;
-}
+};
 
 WebInspector.RemoteObjectProperty.prototype = {
     /**
      * @return {boolean}
      */
     isAccessorProperty: function()
     {
         return !!(this.getter || this.setter);
     }
 };
 
 // Below is a wrapper around a local object that implements the RemoteObject interface,
 // which can be used by the UI code (primarily ObjectPropertiesSection).
 // Note that only JSON-compliant objects are currently supported, as there's no provision
 // for traversing prototypes, extracting class names via constructor, handling properties
 // or functions.
 
 /**
  * @constructor
  * @extends {WebInspector.RemoteObject}
  * @param {*} value
  */
 WebInspector.LocalJSONObject = function(value)
 {
     WebInspector.RemoteObject.call(this);
     this._value = value;
-}
+};
 
 WebInspector.LocalJSONObject.prototype = {
     /**
      * @override
      * @return {string}
      */
     get description()
     {
         if (this._cachedDescription)
             return this._cachedDescription;
@@ skipping 223 matching lines @@
         try {
             result = functionDeclaration.apply(target, rawArgs);
         } catch (e) {
             result = null;
         }
 
         callback(result);
     },
 
     __proto__: WebInspector.RemoteObject.prototype
-}
+};
 
 /**
  * @constructor
  * @param {!WebInspector.RemoteObject} object
  */
 WebInspector.RemoteArray = function(object)
 {
     this._object = object;
 };
 
 /**
  * @param {?WebInspector.RemoteObject} object
  * @return {!WebInspector.RemoteArray}
  */
 WebInspector.RemoteArray.objectAsArray = function(object)
 {
     if (!object || object.type !== "object" || (object.subtype !== "array" && object.subtype !== "typedarray"))
         throw new Error("Object is empty or not an array");
     return new WebInspector.RemoteArray(object);
-}
+};
 
 /**
  * @param {!Array<!WebInspector.RemoteObject>} objects
  * @return {!Promise<!WebInspector.RemoteArray>}
  */
 WebInspector.RemoteArray.createFromRemoteObjects = function(objects)
 {
     if (!objects.length)
         throw new Error("Input array is empty");
     var objectArguments = [];
     for (var i = 0; i < objects.length; ++i)
-        objectArguments.push(WebInspector.RemoteObject.toCallArgument(objects[i]))
+        objectArguments.push(WebInspector.RemoteObject.toCallArgument(objects[i]));
     return objects[0].callFunctionPromise(createArray, objectArguments).then(returnRemoteArray);
 
     /**
      * @return {!Array<*>}
      */
     function createArray()
     {
         if (arguments.length > 1)
             return new Array(arguments);
         return [arguments[0]];
     }
 
     /**
      * @param {!WebInspector.CallFunctionResult} result
      * @return {!WebInspector.RemoteArray}
      */
     function returnRemoteArray(result)
     {
         if (result.wasThrown || !result.object)
             throw new Error("Call function throws exceptions or returns empty value");
         return WebInspector.RemoteArray.objectAsArray(result.object);
     }
-}
+};
 
 WebInspector.RemoteArray.prototype = {
     /**
      * @param {number} index
      * @return {!Promise<!WebInspector.RemoteObject>}
      */
     at: function(index)
     {
         if (index < 0 || index > this._object.arrayLength())
             throw new Error("Out of range");
@@ skipping 43 matching lines @@
         return Promise.all(promises);
     },
 
     /**
      * @return {!WebInspector.RemoteObject}
      */
     object: function()
     {
         return this._object;
     }
-}
+};
 
 /**
  * @constructor
  * @param {!WebInspector.RemoteObject} object
  */
 WebInspector.RemoteFunction = function(object)
 {
     this._object = object;
-}
+};
 
 /**
  * @param {?WebInspector.RemoteObject} object
  * @return {!WebInspector.RemoteFunction}
  */
 WebInspector.RemoteFunction.objectAsFunction = function(object)
 {
     if (!object || object.type !== "function")
         throw new Error("Object is empty or not a function");
     return new WebInspector.RemoteFunction(object);
-}
+};
 
 WebInspector.RemoteFunction.prototype = {
     /**
      * @return {!Promise<!WebInspector.RemoteObject>}
      */
     targetFunction: function()
     {
         return this._object.getOwnPropertiesPromise().then(targetFunction.bind(this));
 
         /**
@@ skipping 45 matching lines @@
         }
     },
 
     /**
      * @return {!WebInspector.RemoteObject}
      */
     object: function()
     {
         return this._object;
     }
-}
+};