DevTools: use semicolons after each statement.

third_party/WebKit/Source/devtools/front_end/sdk/DebuggerModel.js

 /*
  * Copyright (C) 2010 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 38 matching lines @@
 
     /** @type {!WebInspector.Object} */
     this._breakpointResolvedEventTarget = new WebInspector.Object();
 
     this._isPausing = false;
     WebInspector.moduleSetting("pauseOnExceptionEnabled").addChangeListener(this._pauseOnExceptionStateChanged, this);
     WebInspector.moduleSetting("pauseOnCaughtException").addChangeListener(this._pauseOnExceptionStateChanged, this);
     WebInspector.moduleSetting("enableAsyncStackTraces").addChangeListener(this.asyncStackTracesStateChanged, this);
 
     this.enableDebugger();
-}
+};
 
 /** @typedef {{location: ?WebInspector.DebuggerModel.Location, functionName: string}} */
 WebInspector.DebuggerModel.FunctionDetails;
 
 /**
  * Keep these in sync with WebCore::V8Debugger
  *
  * @enum {string}
  */
 WebInspector.DebuggerModel.PauseOnExceptionsState = {
     DontPauseOnExceptions : "none",
     PauseOnAllExceptions : "all",
     PauseOnUncaughtExceptions: "uncaught"
 };
 
 /** @enum {symbol} */
 WebInspector.DebuggerModel.Events = {
     DebuggerWasEnabled: Symbol("DebuggerWasEnabled"),
     DebuggerWasDisabled: Symbol("DebuggerWasDisabled"),
     BeforeDebuggerPaused: Symbol("BeforeDebuggerPaused"),
     DebuggerPaused: Symbol("DebuggerPaused"),
     DebuggerResumed: Symbol("DebuggerResumed"),
     ParsedScriptSource: Symbol("ParsedScriptSource"),
     FailedToParseScriptSource: Symbol("FailedToParseScriptSource"),
     GlobalObjectCleared: Symbol("GlobalObjectCleared"),
     CallFrameSelected: Symbol("CallFrameSelected"),
     ConsoleCommandEvaluatedInSelectedCallFrame: Symbol("ConsoleCommandEvaluatedInSelectedCallFrame")
-}
+};
 
 /** @enum {string} */
 WebInspector.DebuggerModel.BreakReason = {
     DOM: "DOM",
     EventListener: "EventListener",
     XHR: "XHR",
     Exception: "exception",
     PromiseRejection: "promiseRejection",
     Assert: "assert",
     DebugCommand: "debugCommand",
     Other: "other"
-}
+};
 
 WebInspector.DebuggerModel.prototype = {
     /**
      * @return {boolean}
      */
     debuggerEnabled: function()
     {
         return !!this._debuggerEnabled;
     },
 
@@ skipping 596 matching lines @@
         }
     },
 
     /**
      * @param {!DebuggerAgent.BreakpointId} breakpointId
      * @param {function(!WebInspector.Event)} listener
      * @param {!Object=} thisObject
      */
     addBreakpointListener: function(breakpointId, listener, thisObject)
     {
-        this._breakpointResolvedEventTarget.addEventListener(breakpointId, listener, thisObject)
+        this._breakpointResolvedEventTarget.addEventListener(breakpointId, listener, thisObject);
     },
 
     /**
      * @param {!DebuggerAgent.BreakpointId} breakpointId
      * @param {function(!WebInspector.Event)} listener
      * @param {!Object=} thisObject
      */
     removeBreakpointListener: function(breakpointId, listener, thisObject)
     {
         this._breakpointResolvedEventTarget.removeEventListener(breakpointId, listener, thisObject);
@@ skipping 58 matching lines @@
          * @param {function()} fulfill
          * @this {WebInspector.DebuggerModel}
          */
         function promiseBody(fulfill)
         {
             this.enableDebugger(fulfill);
         }
     },
 
     __proto__: WebInspector.SDKModel.prototype
-}
+};
 
 WebInspector.DebuggerEventTypes = {
     JavaScriptPause: 0,
     JavaScriptBreakpoint: 1,
     NativeBreakpoint: 2
 };
 
 /**
  * @constructor
  * @implements {DebuggerAgent.Dispatcher}
  * @param {!WebInspector.DebuggerModel} debuggerModel
  */
 WebInspector.DebuggerDispatcher = function(debuggerModel)
 {
     this._debuggerModel = debuggerModel;
-}
+};
 
 WebInspector.DebuggerDispatcher.prototype = {
     /**
      * @override
      * @param {!Array.<!DebuggerAgent.CallFrame>} callFrames
      * @param {string} reason
      * @param {!Object=} auxData
      * @param {!Array.<string>=} breakpointIds
      * @param {!RuntimeAgent.StackTrace=} asyncStackTrace
      */
@@ skipping 51 matching lines @@
 
     /**
      * @override
      * @param {!DebuggerAgent.BreakpointId} breakpointId
      * @param {!DebuggerAgent.Location} location
      */
     breakpointResolved: function(breakpointId, location)
     {
         this._debuggerModel._breakpointResolved(breakpointId, location);
     }
-}
+};
 
 /**
  * @constructor
  * @extends {WebInspector.SDKObject}
  * @param {!WebInspector.DebuggerModel} debuggerModel
  * @param {string} scriptId
  * @param {number} lineNumber
  * @param {number=} columnNumber
  */
 WebInspector.DebuggerModel.Location = function(debuggerModel, scriptId, lineNumber, columnNumber)
 {
     WebInspector.SDKObject.call(this, debuggerModel.target());
     this._debuggerModel = debuggerModel;
     this.scriptId = scriptId;
     this.lineNumber = lineNumber;
     this.columnNumber = columnNumber || 0;
-}
+};
 
 /**
  * @param {!WebInspector.DebuggerModel} debuggerModel
  * @param {!DebuggerAgent.Location} payload
  * @return {!WebInspector.DebuggerModel.Location}
  */
 WebInspector.DebuggerModel.Location.fromPayload = function(debuggerModel, payload)
 {
     return new WebInspector.DebuggerModel.Location(debuggerModel, payload.scriptId, payload.lineNumber, payload.columnNumber);
-}
+};
 
 WebInspector.DebuggerModel.Location.prototype = {
     /**
      * @return {!DebuggerAgent.Location}
      */
     payload: function()
     {
         return { scriptId: this.scriptId, lineNumber: this.lineNumber, columnNumber: this.columnNumber };
     },
 
@@ skipping 12 matching lines @@
 
     /**
      * @return {string}
      */
     id: function()
     {
         return this.target().id() + ":" + this.scriptId + ":" + this.lineNumber + ":" + this.columnNumber;
     },
 
     __proto__: WebInspector.SDKObject.prototype
-}
+};
 
 /**
  * @constructor
  * @extends {WebInspector.SDKObject}
  * @param {!WebInspector.DebuggerModel} debuggerModel
  * @param {!WebInspector.Script} script
  * @param {!DebuggerAgent.CallFrame} payload
  */
 WebInspector.DebuggerModel.CallFrame = function(debuggerModel, script, payload)
 {
     var target = debuggerModel.target();
     WebInspector.SDKObject.call(this, target);
     this.debuggerModel = debuggerModel;
     this._debuggerAgent = debuggerModel._agent;
     this._script = script;
     this._payload = payload;
     this._location = WebInspector.DebuggerModel.Location.fromPayload(debuggerModel, payload.location);
     this._scopeChain = [];
     this._localScope = null;
     for (var i = 0; i < payload.scopeChain.length; ++i) {
         var scope = new WebInspector.DebuggerModel.Scope(this, i);
         this._scopeChain.push(scope);
         if (scope.type() === DebuggerAgent.ScopeType.Local)
             this._localScope = scope;
     }
     if (payload.functionLocation)
         this._functionLocation = WebInspector.DebuggerModel.Location.fromPayload(debuggerModel, payload.functionLocation);
-}
+};
 
 /**
  * @param {!WebInspector.DebuggerModel} debuggerModel
  * @param {!Array.<!DebuggerAgent.CallFrame>} callFrames
  * @return {!Array.<!WebInspector.DebuggerModel.CallFrame>}
  */
 WebInspector.DebuggerModel.CallFrame.fromPayloadArray = function(debuggerModel, callFrames)
 {
     var result = [];
     for (var i = 0; i < callFrames.length; ++i) {
         var callFrame = callFrames[i];
         var script = debuggerModel.scriptForId(callFrame.location.scriptId);
         if (script)
             result.push(new WebInspector.DebuggerModel.CallFrame(debuggerModel, script, callFrame));
     }
     return result;
-}
+};
 
 WebInspector.DebuggerModel.CallFrame.prototype = {
     /**
      * @return {!WebInspector.Script}
      */
     get script()
     {
         return this._script;
     },
 
@@ skipping 128 matching lines @@
         var scopeChain = this.scopeChain();
         var pendingRequests = scopeChain.length;
         for (var i = 0; i < scopeChain.length; ++i) {
             var scope = scopeChain[i];
             var object = scope.object();
             object.getAllProperties(false, propertiesCollected);
         }
     },
 
     __proto__: WebInspector.SDKObject.prototype
-}
+};
 
 /**
  * @constructor
  * @param {!WebInspector.DebuggerModel.CallFrame} callFrame
  * @param {number} ordinal
  */
 WebInspector.DebuggerModel.Scope = function(callFrame, ordinal)
 {
     this._callFrame = callFrame;
     this._payload = callFrame._payload.scopeChain[ordinal];
     this._type = this._payload.type;
     this._name = this._payload.name;
     this._ordinal = ordinal;
     this._startLocation = this._payload.startLocation ? WebInspector.DebuggerModel.Location.fromPayload(callFrame.debuggerModel, this._payload.startLocation) : null;
     this._endLocation = this._payload.endLocation ? WebInspector.DebuggerModel.Location.fromPayload(callFrame.debuggerModel, this._payload.endLocation) : null;
-}
+};
 
 WebInspector.DebuggerModel.Scope.prototype = {
     /**
      * @return {!WebInspector.DebuggerModel.CallFrame}
      */
     callFrame: function()
     {
         return this._callFrame;
     },
 
@@ skipping 48 matching lines @@
     },
 
     /**
      * @return {string}
      */
     description: function()
     {
         var declarativeScope = this._type !== DebuggerAgent.ScopeType.With && this._type !== DebuggerAgent.ScopeType.Global;
         return declarativeScope ? "" : (this._payload.object.description || "");
     }
-}
+};
 
 /**
  * @constructor
  * @extends {WebInspector.SDKObject}
  * @param {!WebInspector.DebuggerModel} debuggerModel
  * @param {!Array.<!DebuggerAgent.CallFrame>} callFrames
  * @param {string} reason
  * @param {!Object|undefined} auxData
  * @param {!Array.<string>} breakpointIds
  * @param {!RuntimeAgent.StackTrace=} asyncStackTrace
  */
 WebInspector.DebuggerPausedDetails = function(debuggerModel, callFrames, reason, auxData, breakpointIds, asyncStackTrace)
 {
     WebInspector.SDKObject.call(this, debuggerModel.target());
     this.debuggerModel = debuggerModel;
     this.callFrames = WebInspector.DebuggerModel.CallFrame.fromPayloadArray(debuggerModel, callFrames);
     this.reason = reason;
     this.auxData = auxData;
     this.breakpointIds = breakpointIds;
     if (asyncStackTrace)
         this.asyncStackTrace = this._cleanRedundantFrames(asyncStackTrace);
-}
+};
 
 WebInspector.DebuggerPausedDetails.prototype = {
     /**
      * @return {?WebInspector.RemoteObject}
      */
     exception: function()
     {
         if (this.reason !== WebInspector.DebuggerModel.BreakReason.Exception && this.reason !== WebInspector.DebuggerModel.BreakReason.PromiseRejection)
             return null;
         return this.target().runtimeModel.createRemoteObject(/** @type {!RuntimeAgent.RemoteObject} */(this.auxData));
@@ skipping 13 matching lines @@
             if (previous && !stack.callFrames.length)
                 previous.parent = stack.parent;
             else
                 previous = stack;
             stack = stack.parent;
         }
         return asyncStackTrace;
     },
 
     __proto__: WebInspector.SDKObject.prototype
-}
+};
 
 /**
  * @return {!Array<!WebInspector.DebuggerModel>}
  */
 WebInspector.DebuggerModel.instances = function()
 {
     var result = [];
     for (var target of WebInspector.targetManager.targets()) {
         var debuggerModel = WebInspector.DebuggerModel.fromTarget(target);
         if (debuggerModel)
             result.push(debuggerModel);
     }
     return result;
-}
+};
 
 /**
  * @param {?WebInspector.Target} target
  * @return {?WebInspector.DebuggerModel}
  */
 WebInspector.DebuggerModel.fromTarget = function(target)
 {
     if (!target || !target.hasJSCapability())
         return null;
     return /** @type {?WebInspector.DebuggerModel} */ (target.model(WebInspector.DebuggerModel));
-}
+};