DevTools: use semicolons after each statement.

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

 /*
  * Copyright (C) 2011 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 32 matching lines @@
     /** @type {!Map<number, !WebInspector.ConsoleMessage>} */
     this._messageByExceptionId = new Map();
     this._warnings = 0;
     this._errors = 0;
     this._revokedErrors = 0;
     this._logAgent = logAgent;
     if (this._logAgent) {
         target.registerLogDispatcher(new WebInspector.LogDispatcher(this));
         this._logAgent.enable();
     }
-}
+};
 
 /** @enum {symbol} */
 WebInspector.ConsoleModel.Events = {
     ConsoleCleared: Symbol("ConsoleCleared"),
     MessageAdded: Symbol("MessageAdded"),
     MessageUpdated: Symbol("MessageUpdated"),
     CommandEvaluated: Symbol("CommandEvaluated")
-}
+};
 
 WebInspector.ConsoleModel.prototype = {
     /**
      * @param {!WebInspector.ConsoleMessage} msg
      */
     addMessage: function(msg)
     {
         if (this._isBlacklisted(msg))
             return;
 
@@ skipping 97 matching lines @@
 
     /**
      * @return {number}
      */
     warnings: function()
     {
         return this._warnings;
     },
 
     __proto__: WebInspector.SDKModel.prototype
-}
+};
 
 /**
  * @param {!WebInspector.ExecutionContext} executionContext
  * @param {string} text
  * @param {boolean=} useCommandLineAPI
  */
 WebInspector.ConsoleModel.evaluateCommandInConsole = function(executionContext, text, useCommandLineAPI)
 {
     var target = executionContext.target();
     var requestedText = text;
@@ skipping 40 matching lines @@
         } catch (e) {
             return false;
         }
     }
 
     if (looksLikeAnObjectLiteral(text))
         text = "(" + text + ")";
 
     executionContext.evaluate(text, "console", !!useCommandLineAPI, false, false, true, true, printResult);
     WebInspector.userMetrics.actionTaken(WebInspector.UserMetrics.Action.ConsoleEvaluated);
-}
+};
 
 /**
  * @constructor
  * @param {?WebInspector.Target} target
  * @param {string} source
  * @param {?string} level
  * @param {string} messageText
  * @param {string=} type
  * @param {?string=} url
  * @param {number=} line
@@ skipping 33 matching lines @@
     if (this.request) {
         var initiator = this.request.initiator();
         if (initiator) {
             this.stackTrace = initiator.stack || undefined;
             if (initiator.url) {
                 this.url = initiator.url;
                 this.line = initiator.lineNumber || 0;
             }
         }
     }
-}
+};
 
 WebInspector.ConsoleMessage.prototype = {
     /**
      * @return {?WebInspector.Target}
      */
     target: function()
     {
         return this._target;
     },
 
@@ skipping 122 matching lines @@
             return false;
         for (var i = 0, n = callFrames1.length; i < n; ++i) {
             if (callFrames1[i].url !== callFrames2[i].url ||
                 callFrames1[i].functionName !== callFrames2[i].functionName ||
                 callFrames1[i].lineNumber !== callFrames2[i].lineNumber ||
                 callFrames1[i].columnNumber !== callFrames2[i].columnNumber)
                 return false;
         }
         return this._isEqualStackTraces(stackTrace1.parent, stackTrace2.parent);
     }
-}
+};
 
 // Note: Keep these constants in sync with the ones in Console.h
 /**
  * @enum {string}
  */
 WebInspector.ConsoleMessage.MessageSource = {
     XML: "xml",
     JS: "javascript",
     Network: "network",
     ConsoleAPI: "console-api",
     Storage: "storage",
     AppCache: "appcache",
     Rendering: "rendering",
     CSS: "css",
     Security: "security",
     Other: "other",
     Deprecation: "deprecation",
     Worker: "worker"
-}
+};
 
 /**
  * @enum {string}
  */
 WebInspector.ConsoleMessage.MessageType = {
     Log: "log",
     Debug: "debug",
     Info: "info",
     Error: "error",
     Warning: "warning",
     Dir: "dir",
     DirXML: "dirxml",
     Table: "table",
     Trace: "trace",
     Clear: "clear",
     StartGroup: "startGroup",
     StartGroupCollapsed: "startGroupCollapsed",
     EndGroup: "endGroup",
     Assert: "assert",
     Result: "result",
     Profile: "profile",
     ProfileEnd: "profileEnd",
     Command: "command"
-}
+};
 
 /**
  * @enum {string}
  */
 WebInspector.ConsoleMessage.MessageLevel = {
     Log: "log",
     Info: "info",
     Warning: "warning",
     Error: "error",
     Debug: "debug",
     RevokedError: "revokedError"  // This is frontend-only level, used to put exceptions to console.
 };
 
 /**
  * @param {!WebInspector.ConsoleMessage} a
  * @param {!WebInspector.ConsoleMessage} b
  * @return {number}
  */
 WebInspector.ConsoleMessage.timestampComparator = function(a, b)
 {
     return a.timestamp - b.timestamp;
-}
+};
 
 /**
  * @param {!RuntimeAgent.ExceptionDetails} exceptionDetails
  * @return {string}
  */
 WebInspector.ConsoleMessage.simpleTextFromException = function(exceptionDetails)
 {
     var text = exceptionDetails.text;
     if (exceptionDetails.exception && exceptionDetails.exception.description) {
         var description = exceptionDetails.exception.description;
         if (description.indexOf("\n") !== -1)
             description = description.substring(0, description.indexOf("\n"));
         text += " " + description;
     }
     return text;
-}
+};
 
 /**
  * @param {!WebInspector.Target} target
  * @param {!RuntimeAgent.ExceptionDetails} exceptionDetails
  * @param {string=} messageType
  * @param {number=} timestamp
  * @param {string=} forceUrl
  * @return {!WebInspector.ConsoleMessage}
  */
 WebInspector.ConsoleMessage.fromException = function(target, exceptionDetails, messageType, timestamp, forceUrl)
 {
     return new WebInspector.ConsoleMessage(
         target,
         WebInspector.ConsoleMessage.MessageSource.JS,
         WebInspector.ConsoleMessage.MessageLevel.Error,
         WebInspector.ConsoleMessage.simpleTextFromException(exceptionDetails),
         messageType,
         forceUrl || exceptionDetails.url,
         exceptionDetails.lineNumber,
         exceptionDetails.columnNumber,
         undefined,
         exceptionDetails.exception ? [WebInspector.RemoteObject.fromLocalObject(exceptionDetails.text), exceptionDetails.exception] : undefined,
         exceptionDetails.stackTrace,
         timestamp,
         exceptionDetails.executionContextId,
         exceptionDetails.scriptId);
-}
+};
 
 /**
  * @constructor
  * @implements {LogAgent.Dispatcher}
  * @param {!WebInspector.ConsoleModel} console
  */
 WebInspector.LogDispatcher = function(console)
 {
     this._console = console;
-}
+};
 
 WebInspector.LogDispatcher.prototype = {
     /**
      * @override
      * @param {!LogAgent.LogEntry} payload
      */
     entryAdded: function(payload)
     {
         var consoleMessage = new WebInspector.ConsoleMessage(
             this._console.target(),
             payload.source,
             payload.level,
             payload.text,
             undefined,
             payload.url,
             payload.lineNumber,
             undefined,
             payload.networkRequestId,
             undefined,
             payload.stackTrace,
             payload.timestamp,
             undefined,
             undefined,
             payload.workerId);
         this._console.addMessage(consoleMessage);
     }
-}
+};
 
 /**
  * @constructor
  * @extends {WebInspector.Object}
  * @implements {WebInspector.TargetManager.Observer}
  */
 WebInspector.MultitargetConsoleModel = function()
 {
     WebInspector.targetManager.observeTargets(this);
     WebInspector.targetManager.addModelListener(WebInspector.ConsoleModel, WebInspector.ConsoleModel.Events.MessageAdded, this._consoleMessageAdded, this);
     WebInspector.targetManager.addModelListener(WebInspector.ConsoleModel, WebInspector.ConsoleModel.Events.MessageUpdated, this._consoleMessageUpdated, this);
     WebInspector.targetManager.addModelListener(WebInspector.ConsoleModel, WebInspector.ConsoleModel.Events.CommandEvaluated, this._commandEvaluated, this);
-}
+};
 
 WebInspector.MultitargetConsoleModel.prototype = {
     /**
      * @override
      * @param {!WebInspector.Target} target
      */
     targetAdded: function(target)
     {
         if (!this._mainTarget) {
             this._mainTarget = target;
@@ skipping 48 matching lines @@
 
     /**
      * @param {!WebInspector.Event} event
      */
     _commandEvaluated: function(event)
     {
         this.dispatchEventToListeners(WebInspector.ConsoleModel.Events.CommandEvaluated, event.data);
     },
 
     __proto__: WebInspector.Object.prototype
-}
+};
 
 /**
  * @type {!WebInspector.MultitargetConsoleModel}
  */
 WebInspector.multitargetConsoleModel;