DevTools: use semicolons after each statement.

third_party/WebKit/Source/devtools/front_end/main/Main.js

 /*
  * Copyright (C) 2006, 2007, 2008 Apple Inc.  All rights reserved.
  * Copyright (C) 2007 Matt Lilek (pewtermoose@gmail.com).
  * Copyright (C) 2009 Joseph Pecoraro
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
@@ skipping 18 matching lines @@
  */
 
 /**
  * @constructor
  * @suppressGlobalPropertiesCheck
  */
 WebInspector.Main = function()
 {
     WebInspector.Main._instanceForTest = this;
     runOnWindowLoad(this._loaded.bind(this));
-}
+};
 
 WebInspector.Main.prototype = {
     _loaded: function()
     {
         console.timeStamp("Main._loaded");
 
         if (InspectorFrontendHost.isUnderTest())
             self.runtime.useTestBase();
         Runtime.setPlatform(WebInspector.platform());
         InspectorFrontendHost.getPreferences(this._gotPreferences.bind(this));
@@ skipping 489 matching lines @@
     {
         var hard = /** @type {boolean} */ (event.data);
         WebInspector.Main._reloadPage(hard);
     },
 
     _onSuspendStateChanged: function()
     {
         var suspended = WebInspector.targetManager.allTargetsSuspended();
         WebInspector.inspectorView.onSuspendStateChanged(suspended);
     }
-}
+};
 
 /**
  * @constructor
  * @implements {InspectorAgent.Dispatcher}
  * @param {!WebInspector.Target} target
  */
 WebInspector.Main.InspectorDomainDispatcher = function(target)
 {
     this._target = target;
-}
+};
 
 WebInspector.Main.InspectorDomainDispatcher.prototype = {
     /**
      * @override
      * @param {string} reason
      */
     detached: function(reason)
     {
         WebInspector._disconnectedScreenWithReasonWasShown = true;
         WebInspector.RemoteDebuggingTerminatedScreen.show(reason);
     },
 
     /**
      * @override
      */
     targetCrashed: function()
     {
         var debuggerModel = WebInspector.DebuggerModel.fromTarget(this._target);
         if (debuggerModel)
             WebInspector.TargetCrashedScreen.show(debuggerModel);
     }
-}
+};
 
 
 /**
  * @constructor
  * @implements {WebInspector.ActionDelegate}
  */
 WebInspector.Main.ReloadActionDelegate = function()
 {
-}
+};
 
 WebInspector.Main.ReloadActionDelegate.prototype = {
     /**
      * @override
      * @param {!WebInspector.Context} context
      * @param {string} actionId
      * @return {boolean}
      */
     handleAction: function(context, actionId)
     {
         switch (actionId) {
         case "main.reload":
             WebInspector.Main._reloadPage(false);
             return true;
         case "main.hard-reload":
             WebInspector.Main._reloadPage(true);
             return true;
         case "main.debug-reload":
             WebInspector.reload();
             return true;
         }
         return false;
     }
-}
+};
 
 /**
  * @constructor
  * @implements {WebInspector.ActionDelegate}
  */
 WebInspector.Main.ZoomActionDelegate = function()
 {
-}
+};
 
 WebInspector.Main.ZoomActionDelegate.prototype = {
     /**
      * @override
      * @param {!WebInspector.Context} context
      * @param {string} actionId
      * @return {boolean}
      */
     handleAction: function(context, actionId)
     {
         if (InspectorFrontendHost.isHostedMode())
             return false;
 
         switch (actionId) {
         case "main.zoom-in":
             InspectorFrontendHost.zoomIn();
             return true;
         case "main.zoom-out":
             InspectorFrontendHost.zoomOut();
             return true;
         case "main.zoom-reset":
             InspectorFrontendHost.resetZoom();
             return true;
         }
         return false;
     }
-}
+};
 
 /**
  * @constructor
  * @implements {WebInspector.ActionDelegate}
  */
 WebInspector.Main.SearchActionDelegate = function()
 {
-}
+};
 
 WebInspector.Main.SearchActionDelegate.prototype = {
     /**
      * @override
      * @param {!WebInspector.Context} context
      * @param {string} actionId
      * @return {boolean}
      * @suppressGlobalPropertiesCheck
      */
     handleAction: function(context, actionId)
     {
         var searchableView = WebInspector.SearchableView.fromElement(document.deepActiveElement()) || WebInspector.inspectorView.currentPanelDeprecated().searchableView();
         if (!searchableView)
             return false;
         switch (actionId) {
         case "main.search-in-panel.find":
             return searchableView.handleFindShortcut();
         case "main.search-in-panel.cancel":
             return searchableView.handleCancelSearchShortcut();
         case "main.search-in-panel.find-next":
             return searchableView.handleFindNextShortcut();
         case "main.search-in-panel.find-previous":
             return searchableView.handleFindPreviousShortcut();
         }
         return false;
     }
-}
+};
 
 /**
  * @param {boolean} hard
  */
 WebInspector.Main._reloadPage = function(hard)
 {
     var mainTarget = WebInspector.targetManager.mainTarget();
     if (mainTarget && mainTarget.hasBrowserCapability())
         WebInspector.targetManager.reloadPage(hard);
-}
+};
 
 /**
  * @constructor
  * @implements {WebInspector.ToolbarItem.Provider}
  */
 WebInspector.Main.WarningErrorCounter = function()
 {
     WebInspector.Main.WarningErrorCounter._instanceForTest = this;
 
     this._counter = createElement("div");
     this._counter.addEventListener("click", WebInspector.console.show.bind(WebInspector.console), false);
     this._toolbarItem = new WebInspector.ToolbarItem(this._counter);
     var shadowRoot = WebInspector.createShadowRootWithCoreStyles(this._counter, "main/errorWarningCounter.css");
 
     this._errors = this._createItem(shadowRoot, "error-icon");
     this._revokedErrors = this._createItem(shadowRoot, "revokedError-icon");
     this._warnings = this._createItem(shadowRoot, "warning-icon");
     this._titles = [];
 
     WebInspector.multitargetConsoleModel.addEventListener(WebInspector.ConsoleModel.Events.ConsoleCleared, this._update, this);
     WebInspector.multitargetConsoleModel.addEventListener(WebInspector.ConsoleModel.Events.MessageAdded, this._update, this);
     WebInspector.multitargetConsoleModel.addEventListener(WebInspector.ConsoleModel.Events.MessageUpdated, this._update, this);
     this._update();
-}
+};
 
 WebInspector.Main.WarningErrorCounter.prototype = {
     /**
      * @param {!Node} shadowRoot
      * @param {string} iconType
      * @return {!{item: !Element, text: !Element}}
      */
     _createItem: function(shadowRoot, iconType)
     {
         var item = createElementWithClass("span", "counter-item");
@@ skipping 41 matching lines @@
     },
 
     /**
      * @override
      * @return {?WebInspector.ToolbarItem}
      */
     item: function()
     {
         return this._toolbarItem;
     }
-}
+};
 
 /**
  * @constructor
  * @implements {WebInspector.ToolbarItem.Provider}
  */
 WebInspector.Main.MainMenuItem = function()
 {
     this._item = new WebInspector.ToolbarButton(WebInspector.UIString("Customize and control DevTools"), "menu-toolbar-item");
     this._item.addEventListener("mousedown", this._mouseDown, this);
-}
+};
 
 WebInspector.Main.MainMenuItem.prototype = {
     /**
      * @override
      * @return {?WebInspector.ToolbarItem}
      */
     item: function()
     {
         return this._item;
     },
@@ skipping 50 matching lines @@
             var descriptor = extension.descriptor();
             if (descriptor["persistence"] !== "closeable")
                 continue;
             if (descriptor["location"] !== "drawer-view" && descriptor["location"] !== "panel")
                 continue;
             moreTools.appendItem(extension.title(), WebInspector.viewManager.showView.bind(WebInspector.viewManager, descriptor["id"]));
         }
 
         contextMenu.show();
     }
-}
+};
 
 /**
  * @constructor
  */
 WebInspector.NetworkPanelIndicator = function()
 {
     // TODO: we should not access network from other modules.
     if (!WebInspector.inspectorView.hasPanel("network"))
         return;
     var manager = WebInspector.multitargetNetworkManager;
     manager.addEventListener(WebInspector.MultitargetNetworkManager.Events.ConditionsChanged, updateVisibility);
     var blockedURLsSetting = WebInspector.moduleSetting("blockedURLs");
     blockedURLsSetting.addChangeListener(updateVisibility);
     updateVisibility();
 
     function updateVisibility()
     {
         if (manager.isThrottling()) {
             WebInspector.inspectorView.setPanelIcon("network", "warning-icon", WebInspector.UIString("Network throttling is enabled"));
         } else if (blockedURLsSetting.get().length) {
             WebInspector.inspectorView.setPanelIcon("network", "warning-icon", WebInspector.UIString("Requests may be blocked"));
         } else {
             WebInspector.inspectorView.setPanelIcon("network", "", "");
         }
     }
-}
+};
 
 /**
  * @constructor
  */
 WebInspector.SourcesPanelIndicator = function()
 {
     WebInspector.moduleSetting("javaScriptDisabled").addChangeListener(javaScriptDisabledChanged);
     javaScriptDisabledChanged();
 
     function javaScriptDisabledChanged()
     {
         var javaScriptDisabled = WebInspector.moduleSetting("javaScriptDisabled").get();
         if (javaScriptDisabled) {
             WebInspector.inspectorView.setPanelIcon("sources", "warning-icon", WebInspector.UIString("JavaScript is disabled"));
         } else {
             WebInspector.inspectorView.setPanelIcon("sources", "", "");
         }
     }
-}
+};
 
 /**
  * @constructor
  */
 WebInspector.Main.PauseListener = function()
 {
     WebInspector.targetManager.addModelListener(WebInspector.DebuggerModel, WebInspector.DebuggerModel.Events.DebuggerPaused, this._debuggerPaused, this);
-}
+};
 
 WebInspector.Main.PauseListener.prototype = {
     /**
      * @param {!WebInspector.Event} event
      */
     _debuggerPaused: function(event)
     {
         WebInspector.targetManager.removeModelListener(WebInspector.DebuggerModel, WebInspector.DebuggerModel.Events.DebuggerPaused, this._debuggerPaused, this);
         var debuggerPausedDetails = /** @type {!WebInspector.DebuggerPausedDetails} */ (event.data);
         var debuggerModel = /** @type {!WebInspector.DebuggerModel} */ (event.target);
         WebInspector.context.setFlavor(WebInspector.Target, debuggerModel.target());
         WebInspector.Revealer.reveal(debuggerPausedDetails);
     }
-}
+};
 
 /**
  * @constructor
  */
 WebInspector.Main.InspectedNodeRevealer = function()
 {
     WebInspector.targetManager.addModelListener(WebInspector.DOMModel, WebInspector.DOMModel.Events.NodeInspected, this._inspectNode, this);
-}
+};
 
 WebInspector.Main.InspectedNodeRevealer.prototype = {
     /**
      * @param {!WebInspector.Event} event
      */
     _inspectNode: function(event)
     {
         var deferredNode = /** @type {!WebInspector.DeferredDOMNode} */ (event.data);
         WebInspector.Revealer.reveal(deferredNode);
     }
-}
+};
 
 /**
  * @param {string} method
  * @param {?Object} params
  * @return {!Promise}
  */
 WebInspector.sendOverProtocol = function(method, params)
 {
     var connection = WebInspector.targetManager.mainTarget().connection();
     return new Promise((resolve, reject) => {
         connection.sendRawMessageForTesting(method, params, (err, result) => {
             if (err)
                 return reject(err);
             return resolve(result);
         });
     });
-}
+};
 
 /**
  * @constructor
  * @extends {WebInspector.VBox}
  * @param {string} reason
  */
 WebInspector.RemoteDebuggingTerminatedScreen = function(reason)
 {
     WebInspector.VBox.call(this, true);
     this.registerRequiredCSS("main/remoteDebuggingTerminatedScreen.css");
     var message = this.contentElement.createChild("div", "message");
     message.createChild("span").textContent = WebInspector.UIString("Debugging connection was closed. Reason: ");
     message.createChild("span", "reason").textContent = reason;
     this.contentElement.createChild("div", "message").textContent = WebInspector.UIString("Reconnect when ready by reopening DevTools.");
     var button = createTextButton(WebInspector.UIString("Reconnect DevTools"), () => window.location.reload());
     this.contentElement.createChild("div", "button").appendChild(button);
-}
+};
 
 /**
  * @param {string} reason
  */
 WebInspector.RemoteDebuggingTerminatedScreen.show = function(reason)
 {
     var dialog = new WebInspector.Dialog();
     dialog.setWrapsContent(true);
     dialog.addCloseButton();
     dialog.setDimmed(true);
     new WebInspector.RemoteDebuggingTerminatedScreen(reason).show(dialog.element);
     dialog.show();
-}
+};
 
 WebInspector.RemoteDebuggingTerminatedScreen.prototype = {
     __proto__: WebInspector.VBox.prototype
-}
+};
 
 /**
  * @constructor
  * @param {function()} hideCallback
  * @extends {WebInspector.VBox}
  */
 WebInspector.TargetCrashedScreen = function(hideCallback)
 {
     WebInspector.VBox.call(this, true);
     this.registerRequiredCSS("main/targetCrashedScreen.css");
     this.contentElement.createChild("div", "message").textContent = WebInspector.UIString("DevTools was disconnected from the page.");
     this.contentElement.createChild("div", "message").textContent = WebInspector.UIString("Once page is reloaded, DevTools will automatically reconnect.");
     this._hideCallback = hideCallback;
-}
+};
 
 /**
  * @param {!WebInspector.DebuggerModel} debuggerModel
  */
 WebInspector.TargetCrashedScreen.show = function(debuggerModel)
 {
     var dialog = new WebInspector.Dialog();
     dialog.setWrapsContent(true);
     dialog.addCloseButton();
     dialog.setDimmed(true);
     var hideBound = dialog.detach.bind(dialog);
     debuggerModel.addEventListener(WebInspector.DebuggerModel.Events.GlobalObjectCleared, hideBound);
 
     new WebInspector.TargetCrashedScreen(onHide).show(dialog.element);
     dialog.show();
 
     function onHide()
     {
         debuggerModel.removeEventListener(WebInspector.DebuggerModel.Events.GlobalObjectCleared, hideBound);
     }
-}
+};
 
 WebInspector.TargetCrashedScreen.prototype = {
     /**
      * @override
      */
     willHide: function()
     {
         this._hideCallback.call(null);
     },
 
     __proto__: WebInspector.VBox.prototype
-}
+};
 
 /**
  * @constructor
  * @implements {WebInspector.TargetManager.Observer}
  */
 WebInspector.BackendSettingsSync = function()
 {
     this._autoAttachSetting = WebInspector.settings.moduleSetting("autoAttachToCreatedPages");
     this._autoAttachSetting.addChangeListener(this._update, this);
     this._disableJavascriptSetting = WebInspector.settings.moduleSetting("javaScriptDisabled");
     this._disableJavascriptSetting.addChangeListener(this._update, this);
     this._blockedEventsWarningSetting = WebInspector.settings.moduleSetting("blockedEventsWarningEnabled");
     this._blockedEventsWarningSetting.addChangeListener(this._update, this);
     WebInspector.targetManager.observeTargets(this, WebInspector.Target.Capability.Browser);
-}
+};
 
 WebInspector.BackendSettingsSync.prototype = {
     /**
      * @param {!WebInspector.Target} target
      */
     _updateTarget: function(target)
     {
         var blockedEventsWarningThresholdSeconds = 0.1;
         target.pageAgent().setBlockedEventsWarningThreshold(this._blockedEventsWarningSetting.get() ? blockedEventsWarningThresholdSeconds : 0);
         target.pageAgent().setAutoAttachToCreatedPages(this._autoAttachSetting.get());
@@ skipping 15 matching lines @@
         target.renderingAgent().setShowViewportSizeOnResize(true);
     },
 
     /**
      * @param {!WebInspector.Target} target
      * @override
      */
     targetRemoved: function(target)
     {
     }
-}
+};
 
 /**
  * @constructor
  * @implements {WebInspector.SettingUI}
  */
 WebInspector.ShowMetricsRulersSettingUI = function()
 {
-}
+};
 
 WebInspector.ShowMetricsRulersSettingUI.prototype = {
     /**
      * @override
      * @return {?Element}
      */
     settingElement: function()
     {
         return WebInspector.SettingsUI.createSettingCheckbox(WebInspector.UIString("Show rulers"), WebInspector.moduleSetting("showMetricsRulers"));
     }
-}
+};
 
 new WebInspector.Main();