DevTools: use semicolons after each statement.

third_party/WebKit/Source/devtools/front_end/sdk/ServiceWorkerManager.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 30 matching lines @@
     this._lastAnonymousTargetId = 0;
     this._agent = target.serviceWorkerAgent();
     /** @type {!Map.<string, !WebInspector.ServiceWorkerRegistration>} */
     this._registrations = new Map();
     this.enable();
     this._forceUpdateSetting = WebInspector.settings.createSetting("serviceWorkerUpdateOnReload", false);
     if (this._forceUpdateSetting.get())
         this._forceUpdateSettingChanged();
     this._forceUpdateSetting.addChangeListener(this._forceUpdateSettingChanged, this);
     new WebInspector.ServiceWorkerContextNamer(target, this, subTargetsManager);
-}
+};
 
 /** @enum {symbol} */
 WebInspector.ServiceWorkerManager.Events = {
     RegistrationUpdated: Symbol("RegistrationUpdated"),
     RegistrationErrorAdded: Symbol("RegistrationErrorAdded"),
     RegistrationDeleted: Symbol("RegistrationDeleted")
-}
+};
 
 WebInspector.ServiceWorkerManager.prototype = {
     enable: function()
     {
         if (this._enabled)
             return;
         this._enabled = true;
         this._agent.enable();
     },
 
@@ skipping 192 matching lines @@
     {
         return this._forceUpdateSetting;
     },
 
     _forceUpdateSettingChanged: function()
     {
         this._agent.setForceUpdateOnPageLoad(this._forceUpdateSetting.get());
     },
 
     __proto__: WebInspector.SDKObject.prototype
-}
+};
 
 /**
  * @constructor
  * @implements {ServiceWorkerAgent.Dispatcher}
  * @param {!WebInspector.ServiceWorkerManager} manager
  */
 WebInspector.ServiceWorkerDispatcher = function(manager)
 {
     this._manager = manager;
-}
+};
 
 WebInspector.ServiceWorkerDispatcher.prototype = {
     /**
      * @override
      * @param {!Array.<!ServiceWorkerAgent.ServiceWorkerRegistration>} registrations
      */
     workerRegistrationUpdated: function(registrations)
     {
         this._manager._workerRegistrationUpdated(registrations);
     },
 
     /**
      * @override
      * @param {!Array.<!ServiceWorkerAgent.ServiceWorkerVersion>} versions
      */
     workerVersionUpdated: function(versions)
     {
         this._manager._workerVersionUpdated(versions);
     },
 
     /**
      * @override
      * @param {!ServiceWorkerAgent.ServiceWorkerErrorMessage} errorMessage
      */
     workerErrorReported: function(errorMessage)
     {
         this._manager._workerErrorReported(errorMessage);
     }
-}
+};
 
 /**
  * @constructor
  * @param {!WebInspector.ServiceWorkerRegistration} registration
  * @param {!ServiceWorkerAgent.ServiceWorkerVersion} payload
  */
 WebInspector.ServiceWorkerVersion = function(registration, payload)
 {
     this.registration = registration;
     this._update(payload);
-}
+};
 
 /**
  * @enum {string}
  */
 WebInspector.ServiceWorkerVersion.Modes = {
     Installing: "installing",
     Waiting: "waiting",
     Active: "active",
     Redundant: "redundant"
-}
+};
 
 WebInspector.ServiceWorkerVersion.prototype = {
     /**
      * @param {!ServiceWorkerAgent.ServiceWorkerVersion} payload
      */
     _update: function(payload)
     {
         this.id = payload.versionId;
         this.scriptURL = payload.scriptURL;
         var parsedURL = new WebInspector.ParsedURL(payload.scriptURL);
@@ skipping 110 matching lines @@
     mode: function()
     {
         if (this.isNew() || this.isInstalling())
             return WebInspector.ServiceWorkerVersion.Modes.Installing;
         else if (this.isInstalled())
             return WebInspector.ServiceWorkerVersion.Modes.Waiting;
         else if (this.isActivating() || this.isActivated())
             return WebInspector.ServiceWorkerVersion.Modes.Active;
         return WebInspector.ServiceWorkerVersion.Modes.Redundant;
     }
-}
+};
 
 /**
 * @constructor
 * @param {!ServiceWorkerAgent.ServiceWorkerRegistration} payload
 */
 WebInspector.ServiceWorkerRegistration = function(payload)
 {
     this._update(payload);
     /** @type {!Map.<string, !WebInspector.ServiceWorkerVersion>} */
     this.versions = new Map();
     this._deleting = false;
     /** @type {!Array<!ServiceWorkerAgent.ServiceWorkerErrorMessage>} */
     this.errors = [];
-}
+};
 
 WebInspector.ServiceWorkerRegistration.prototype = {
     /**
      * @param {!ServiceWorkerAgent.ServiceWorkerRegistration} payload
      */
     _update: function(payload)
     {
         this._fingerprint = Symbol("fingerprint");
         this.id = payload.registrationId;
         this.scopeURL = payload.scopeURL;
@@ skipping 58 matching lines @@
     _shouldBeRemoved: function()
     {
         return this._isRedundant() && (!this.errors.length || this._deleting);
     },
 
     clearErrors: function()
     {
         this._fingerprint = Symbol("fingerprint");
         this.errors = [];
     }
-}
+};
 
 /**
  * @constructor
  * @param {!WebInspector.Target} target
  * @param {!WebInspector.ServiceWorkerManager} serviceWorkerManager
  * @param {!WebInspector.SubTargetsManager} subTargetsManager
  */
 WebInspector.ServiceWorkerContextNamer = function(target, serviceWorkerManager, subTargetsManager)
 {
     this._target = target;
     this._serviceWorkerManager = serviceWorkerManager;
     this._subTargetsManager = subTargetsManager;
     /** @type {!Map<string, !WebInspector.ServiceWorkerVersion>} */
     this._versionByTargetId = new Map();
     serviceWorkerManager.addEventListener(WebInspector.ServiceWorkerManager.Events.RegistrationUpdated, this._registrationsUpdated, this);
     serviceWorkerManager.addEventListener(WebInspector.ServiceWorkerManager.Events.RegistrationDeleted, this._registrationsUpdated, this);
     WebInspector.targetManager.addModelListener(WebInspector.RuntimeModel, WebInspector.RuntimeModel.Events.ExecutionContextCreated, this._executionContextCreated, this);
-}
+};
 
 WebInspector.ServiceWorkerContextNamer.prototype = {
     /**
      * @param {!WebInspector.Event} event
      */
     _registrationsUpdated: function(event)
     {
         this._versionByTargetId.clear();
         var registrations = this._serviceWorkerManager.registrations().valuesArray();
         for (var registration of registrations) {
@@ skipping 51 matching lines @@
      */
     _updateContextLabel: function(context, version)
     {
         var parsedUrl = context.origin.asParsedURL();
         var label = parsedUrl ? parsedUrl.lastPathComponentWithFragment() : context.name;
         if (version)
             context.setLabel(label + " #" + version.id + " (" + version.status + ")");
         else
             context.setLabel(label);
     },
-}
+};