DevTools: use semicolons after each statement.

third_party/WebKit/Source/devtools/front_end/sdk/InspectorBackend.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 31 matching lines @@
 InspectorBackendClass._DevToolsErrorCode = -32000;
 InspectorBackendClass.DevToolsStubErrorCode = -32015;
 
 /**
  * @param {string} error
  * @param {!Object} messageObject
  */
 InspectorBackendClass.reportProtocolError = function(error, messageObject)
 {
     console.error(error + ": " + JSON.stringify(messageObject));
-}
+};
 
 InspectorBackendClass.prototype = {
     /**
      * @return {boolean}
      */
     isInitialized: function()
     {
         return this._initialized;
     },
 
@@ skipping 29 matching lines @@
             return this._agentsMap[domain];
         }
 
         window.Protocol.Agents.prototype[methodName] = agentGetter;
 
         /**
          * @this {Protocol.Agents}
          */
         function registerDispatcher(dispatcher)
         {
-            this.registerDispatcher(domain, dispatcher)
+            this.registerDispatcher(domain, dispatcher);
         }
 
         window.Protocol.Agents.prototype["register" + domain + "Dispatcher"] = registerDispatcher;
     },
 
     /**
      * @param {string} domain
      * @return {!InspectorBackendClass.AgentPrototype}
      */
     _agentPrototype: function(domain)
@@ skipping 78 matching lines @@
                 clientCallback(defaultValue);
                 return;
             }
             if (constructor)
                 clientCallback(new constructor(value));
             else
                 clientCallback(value);
         }
         return callbackWrapper;
     }
-}
+};
 
 /**
  *  @constructor
  *  @extends {WebInspector.Object}
  */
 InspectorBackendClass.Connection = function()
 {
     this._lastMessageId = 1;
     this._pendingResponsesCount = 0;
     this._agents = {};
     this._dispatchers = {};
     this._callbacks = {};
     this._initialize(InspectorBackend._agentPrototypes, InspectorBackend._dispatcherPrototypes);
     this._isConnected = true;
-}
+};
 
 /** @enum {symbol} */
 InspectorBackendClass.Connection.Events = {
     Disconnected: Symbol("Disconnected")
-}
+};
 
 InspectorBackendClass.Connection.prototype = {
     /**
      * @param {!Object.<string, !InspectorBackendClass.AgentPrototype>} agentPrototypes
      * @param {!Object.<string, !InspectorBackendClass.DispatcherPrototype>} dispatcherPrototypes
      */
     _initialize: function(agentPrototypes, dispatcherPrototypes)
     {
         for (var domain in agentPrototypes) {
             this._agents[domain] = Object.create(agentPrototypes[domain]);
@@ skipping 245 matching lines @@
     /**
      * @param {!Array.<string>} domains
      */
     suppressErrorsForDomains: function(domains)
     {
         domains.forEach(function(domain) { this._agents[domain].suppressErrorLogging(); }, this);
     },
 
     __proto__: WebInspector.Object.prototype
 
-}
+};
 
 /**
  * @constructor
  * @param {string} domain
  */
 InspectorBackendClass.AgentPrototype = function(domain)
 {
     this._replyArgs = {};
     this._hasErrorData = {};
     this._domain = domain;
     this._suppressErrorLogging = false;
-}
+};
 
 InspectorBackendClass.AgentPrototype.prototype = {
     /**
      * @param {!InspectorBackendClass.Connection} connection
      */
     setConnection: function(connection)
     {
         this._connection = connection;
     },
 
@@ skipping 76 matching lines @@
         if (args.length === 1 && (!allowExtraUndefinedArg || (typeof args[0] !== "undefined"))) {
             errorCallback("Protocol Error: Optional callback argument for method '" + method + "' call must be a function but its type is '" + typeof args[0] + "'.");
             return null;
         }
 
         if (args.length > 1) {
             errorCallback("Protocol Error: Extra " + args.length + " arguments in a call to method '" + method + "'.");
             return null;
         }
 
-        return hasParams ? params : null
+        return hasParams ? params : null;
     },
 
     /**
      * @param {string} method
      * @param {!Array.<!Object>} signature
      * @param {!Array.<*>} args
      * @return {!Promise.<*>}
      */
     _sendMessageToBackendPromise: function(method, signature, args)
     {
@@ skipping 66 matching lines @@
                 argumentsArray.push(messageObject.result[paramNames[i]]);
         }
 
         callback.apply(null, argumentsArray);
     },
 
     suppressErrorLogging: function()
     {
         this._suppressErrorLogging = true;
     }
-}
+};
 
 /**
  * @constructor
  */
 InspectorBackendClass.DispatcherPrototype = function()
 {
     this._eventArgs = {};
     this._dispatcher = null;
-}
+};
 
 InspectorBackendClass.DispatcherPrototype.prototype = {
 
     /**
      * @param {string} eventName
      * @param {!Object} params
      */
     registerEvent: function(eventName, params)
     {
         this._eventArgs[eventName] = params;
@@ skipping 35 matching lines @@
 
         var processingStartTime;
         if (InspectorBackendClass.Options.dumpInspectorTimeStats)
             processingStartTime = Date.now();
 
         this._dispatcher[functionName].apply(this._dispatcher, params);
 
         if (InspectorBackendClass.Options.dumpInspectorTimeStats)
             console.log("time-stats: " + messageObject.method + " = " + (Date.now() - processingStartTime));
     }
-}
+};
 
 InspectorBackendClass.Options = {
     dumpInspectorTimeStats: false,
     dumpInspectorProtocolMessages: false,
     suppressRequestErrors: false
-}
+};
 
 InspectorBackend = new InspectorBackendClass();