DevTools: use semicolons after each statement.

third_party/WebKit/Source/devtools/front_end/services/ServiceManager.js

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 /**
  * @constructor
  */
 WebInspector.ServiceManager = function()
 {
-}
+};
 
 WebInspector.ServiceManager.prototype = {
     /**
      * @param {string} serviceName
      * @return {!Promise<?WebInspector.ServiceManager.Service>}
      */
     createRemoteService: function(serviceName)
     {
         if (!this._remoteConnection) {
             var url = Runtime.queryParam("service-backend");
@@ skipping 16 matching lines @@
     {
         var url = appName + ".js";
         var remoteBase = Runtime.queryParam("remoteBase");
         if (remoteBase)
             url += "?remoteBase=" + remoteBase;
 
         var worker = isSharedWorker ? new SharedWorker(url, appName) : new Worker(url);
         var connection = new WebInspector.ServiceManager.Connection(new WebInspector.ServiceManager.WorkerServicePort(worker));
         return connection._createService(serviceName);
     }
-}
+};
 
 /**
  * @constructor
  * @param {!ServicePort} port
  */
 WebInspector.ServiceManager.Connection = function(port)
 {
     this._port = port;
     this._port.setHandlers(this._onMessage.bind(this), this._connectionClosed.bind(this));
 
     this._lastId = 1;
     /** @type {!Map<number, function(?Object)>}*/
     this._callbacks = new Map();
     /** @type {!Map<string, !WebInspector.ServiceManager.Service>}*/
     this._services = new Map();
-}
+};
 
 WebInspector.ServiceManager.Connection.prototype = {
     /**
      * @param {string} serviceName
      * @return {!Promise<?WebInspector.ServiceManager.Service>}
      */
     _createService: function(serviceName)
     {
         return this._sendCommand(serviceName + ".create").then(result => {
             if (!result) {
@@ skipping 67 matching lines @@
 
     _connectionClosed: function()
     {
         for (var callback of this._callbacks.values())
             callback(null);
         this._callbacks.clear();
         for (var service of this._services.values())
             service._dispatchNotification("disposed");
         this._services.clear();
     }
-}
+};
 
 /**
  * @constructor
  * @param {!WebInspector.ServiceManager.Connection} connection
  * @param {string} serviceName
  * @param {string} objectId
  */
 WebInspector.ServiceManager.Service = function(connection, serviceName, objectId)
 {
     this._connection = connection;
     this._serviceName = serviceName;
     this._objectId = objectId;
     /** @type {!Map<string, function(!Object=)>}*/
     this._notificationHandlers = new Map();
-}
+};
 
 WebInspector.ServiceManager.Service.prototype = {
     /**
      * @return {!Promise}
      */
     dispose: function()
     {
         var params = { id: this._objectId };
         return this._connection._sendCommand(this._serviceName + ".dispose", params).then(() => {
             this._connection._serviceDisposed(this);
@@ skipping 27 matching lines @@
      */
     _dispatchNotification: function(methodName, params)
     {
         var handler = this._notificationHandlers.get(methodName);
         if (!handler) {
             console.error("Could not report notification '" + methodName + "' on '" + this._objectId + "'");
             return;
         }
         handler(params);
     }
-}
+};
 
 /**
  * @constructor
  * @implements {ServicePort}
  * @param {string} url
  */
 WebInspector.ServiceManager.RemoteServicePort = function(url)
 {
     this._url = url;
-}
+};
 
 WebInspector.ServiceManager.RemoteServicePort.prototype = {
     /**
      * @override
      * @param {function(string)} messageHandler
      * @param {function(string)} closeHandler
      */
     setHandlers: function(messageHandler, closeHandler)
     {
         this._messageHandler = messageHandler;
@@ skipping 69 matching lines @@
     {
         return this._open().then(() => {
             if (this._socket) {
                 this._socket.close();
                 this._socket = null;
                 delete this._connectionPromise;
             }
             return true;
         });
     },
-}
+};
 
 /**
  * @constructor
  * @implements {ServicePort}
  * @param {!Worker|!SharedWorker} worker
  */
 WebInspector.ServiceManager.WorkerServicePort = function(worker)
 {
     this._worker = worker;
 
@@ skipping 14 matching lines @@
      * @this {WebInspector.ServiceManager.WorkerServicePort}
      */
     function onMessage(event)
     {
         if (event.data === "workerReady") {
             fulfill(true);
             return;
         }
         this._messageHandler(event.data);
     }
-}
+};
 
 WebInspector.ServiceManager.WorkerServicePort.prototype = {
     /**
      * @override
      * @param {function(string)} messageHandler
      * @param {function(string)} closeHandler
      */
     setHandlers: function(messageHandler, closeHandler)
     {
         this._messageHandler = messageHandler;
@@ skipping 25 matching lines @@
      * @return {!Promise}
      */
     close: function()
     {
         return this._workerPromise.then(() => {
             if (this._worker)
                 this._worker.terminate();
             return false;
         });
     }
-}
+};
 
 WebInspector.serviceManager = new WebInspector.ServiceManager();