DevTools: use semicolons after each statement.

third_party/WebKit/Source/devtools/front_end/timeline/TimelinePanel.js

 /*
  * Copyright (C) 2012 Google Inc. All rights reserved.
  * Copyright (C) 2012 Intel 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.
@@ skipping 105 matching lines @@
 
     this._detailsSplitWidget.show(timelinePane.element);
     this._detailsSplitWidget.hideSidebar();
     WebInspector.targetManager.addEventListener(WebInspector.TargetManager.Events.SuspendStateChanged, this._onSuspendStateChanged, this);
     this._showRecordingHelpMessage();
 
     /** @type {!WebInspector.TracingModel.Event}|undefined */
     this._selectedSearchResult;
     /** @type {!Array<!WebInspector.TracingModel.Event>}|undefined */
     this._searchResults;
-}
+};
 
 /**
  * @enum {string}
  */
 WebInspector.TimelinePanel.Perspectives = {
     Load: "Load",
     Responsiveness: "Responsiveness",
     Custom: "Custom"
-}
+};
 
 /**
  * @enum {string}
  */
 WebInspector.TimelinePanel.DetailsTab = {
     Details: "Details",
     Events: "Events",
     CallTree: "CallTree",
     BottomUp: "BottomUp",
     PaintProfiler: "PaintProfiler",
     LayerViewer: "LayerViewer"
-}
+};
 
 /**
  * @enum {symbol}
  */
 WebInspector.TimelinePanel.State = {
     Idle: Symbol("Idle"),
     StartPending: Symbol("StartPending"),
     Recording: Symbol("Recording"),
     StopPending: Symbol("StopPending"),
     Loading: Symbol("Loading")
-}
+};
 
 // Define row and header height, should be in sync with styles for timeline graphs.
 WebInspector.TimelinePanel.rowHeight = 18;
 WebInspector.TimelinePanel.headerHeight = 20;
 
 WebInspector.TimelinePanel.prototype = {
     /**
      * @override
      * @return {?WebInspector.SearchableView}
      */
@@ skipping 527 matching lines @@
 
     /**
      * @override
      */
     recordingStarted: function()
     {
         this._clear();
         this._setState(WebInspector.TimelinePanel.State.Recording);
         this._showRecordingStarted();
         this._statusPane.updateStatus(WebInspector.UIString("Recording\u2026"));
-        this._statusPane.updateProgressBar(WebInspector.UIString("Buffer usage"), 0)
+        this._statusPane.updateProgressBar(WebInspector.UIString("Buffer usage"), 0);
         this._statusPane.startTimer();
         this._hideRecordingHelpMessage();
     },
 
     /**
      * @override
      * @param {number} usage
      */
     recordingProgress: function(usage)
     {
@@ skipping 555 matching lines @@
             leftTime = this._tracingModel.minimumRecordTime();
             rightTime = this._tracingModel.maximumRecordTime();
         } else {
             leftTime = Math.max(leftTime - 0.05 * span, this._tracingModel.minimumRecordTime());
             rightTime = Math.min(rightTime + 0.05 * span, this._tracingModel.maximumRecordTime());
         }
         this.requestWindowTimes(leftTime, rightTime);
     },
 
     __proto__: WebInspector.Panel.prototype
-}
+};
 
 /**
  * @interface
  */
 WebInspector.TimelineLifecycleDelegate = function()
 {
-}
+};
 
 WebInspector.TimelineLifecycleDelegate.prototype = {
     recordingStarted: function() {},
 
     /**
      * @param {number} usage
      */
     recordingProgress: function(usage) {},
 
     loadingStarted: function() {},
@@ skipping 38 matching lines @@
 
     var callTreeView = new WebInspector.CallTreeTimelineTreeView(timelineModel, filters);
     this.appendTab(tabIds.CallTree, WebInspector.UIString("Call Tree"), callTreeView);
     this._rangeDetailViews.set(tabIds.CallTree, callTreeView);
 
     var eventsView = new WebInspector.EventsTimelineTreeView(timelineModel, filters, delegate);
     this.appendTab(tabIds.Events, WebInspector.UIString("Event Log"), eventsView);
     this._rangeDetailViews.set(tabIds.Events, eventsView);
 
     this.addEventListener(WebInspector.TabbedPane.Events.TabSelected, this._tabSelected, this);
-}
+};
 
 WebInspector.TimelineDetailsView.prototype = {
     /**
      * @param {!Node} node
      */
     setContent: function(node)
     {
         var allTabs = this.otherTabs(WebInspector.TimelinePanel.DetailsTab.Details);
         for (var i = 0; i < allTabs.length; ++i) {
             if (!this._rangeDetailViews.has(allTabs[i]))
@@ skipping 43 matching lines @@
      */
     _tabSelected: function(event)
     {
         if (!event.data.isUserGesture)
             return;
         this.setPreferredTab(event.data.tabId);
         this.updateContents(this._selection);
     },
 
     __proto__: WebInspector.TabbedPane.prototype
-}
+};
 
 /**
  * @constructor
  * @param {!WebInspector.TimelineSelection.Type} type
  * @param {number} startTime
  * @param {number} endTime
  * @param {!Object=} object
  */
 WebInspector.TimelineSelection = function(type, startTime, endTime, object)
 {
     this._type = type;
     this._startTime = startTime;
     this._endTime = endTime;
     this._object = object || null;
-}
+};
 
 /**
  * @enum {string}
  */
 WebInspector.TimelineSelection.Type = {
     Frame: "Frame",
     NetworkRequest: "NetworkRequest",
     TraceEvent: "TraceEvent",
     Range: "Range"
 };
 
 /**
  * @param {!WebInspector.TimelineFrame} frame
  * @return {!WebInspector.TimelineSelection}
  */
 WebInspector.TimelineSelection.fromFrame = function(frame)
 {
     return new WebInspector.TimelineSelection(
         WebInspector.TimelineSelection.Type.Frame,
         frame.startTime, frame.endTime,
         frame);
-}
+};
 
 /**
  * @param {!WebInspector.TimelineModel.NetworkRequest} request
  * @return {!WebInspector.TimelineSelection}
  */
 WebInspector.TimelineSelection.fromNetworkRequest = function(request)
 {
     return new WebInspector.TimelineSelection(
         WebInspector.TimelineSelection.Type.NetworkRequest,
         request.startTime, request.endTime || request.startTime,
         request);
-}
+};
 
 /**
  * @param {!WebInspector.TracingModel.Event} event
  * @return {!WebInspector.TimelineSelection}
  */
 WebInspector.TimelineSelection.fromTraceEvent = function(event)
 {
     return new WebInspector.TimelineSelection(
         WebInspector.TimelineSelection.Type.TraceEvent,
         event.startTime, event.endTime || (event.startTime + 1),
         event);
-}
+};
 
 /**
  * @param {number} startTime
  * @param {number} endTime
  * @return {!WebInspector.TimelineSelection}
  */
 WebInspector.TimelineSelection.fromRange = function(startTime, endTime)
 {
     return new WebInspector.TimelineSelection(
         WebInspector.TimelineSelection.Type.Range,
         startTime, endTime);
-}
+};
 
 WebInspector.TimelineSelection.prototype = {
     /**
      * @return {!WebInspector.TimelineSelection.Type}
      */
     type: function()
     {
         return this._type;
     },
 
@@ skipping 21 matching lines @@
         return this._endTime;
     }
 };
 
 /**
  * @interface
  * @extends {WebInspector.EventTarget}
  */
 WebInspector.TimelineModeView = function()
 {
-}
+};
 
 WebInspector.TimelineModeView.prototype = {
     /**
      * @return {!WebInspector.Widget}
      */
     view: function() {},
 
     dispose: function() {},
 
     /**
@@ skipping 20 matching lines @@
 
     /**
      * @param {?WebInspector.TimelineSelection} selection
      */
     setSelection: function(selection) {},
 
     /**
      * @param {?WebInspector.TracingModel.Event} event
      */
     highlightEvent: function(event) { }
-}
+};
 
 /**
  * @interface
  */
-WebInspector.TimelineModeViewDelegate = function() {}
+WebInspector.TimelineModeViewDelegate = function() {};
 
 WebInspector.TimelineModeViewDelegate.prototype = {
     /**
      * @param {number} startTime
      * @param {number} endTime
      */
     requestWindowTimes: function(startTime, endTime) {},
 
     /**
      * @param {?WebInspector.TimelineSelection} selection
      * @param {!WebInspector.TimelinePanel.DetailsTab=} preferredTab
      */
     select: function(selection, preferredTab) {},
 
     /**
      * @param {number} time
      */
     selectEntryAtTime: function(time) {},
 
     /**
      * @param {!Node} node
      */
     showInDetails: function(node) {},
 
     /**
      * @param {?WebInspector.TracingModel.Event} event
      */
     highlightEvent: function(event) {}
-}
+};
 
 /**
  * @constructor
  * @extends {WebInspector.TimelineModel.Filter}
  */
 WebInspector.TimelineCategoryFilter = function()
 {
     WebInspector.TimelineModel.Filter.call(this);
-}
+};
 
 WebInspector.TimelineCategoryFilter.prototype = {
     /**
      * @override
      * @param {!WebInspector.TracingModel.Event} event
      * @return {boolean}
      */
     accept: function(event)
     {
         return !WebInspector.TimelineUIUtils.eventStyle(event).category.hidden;
     },
 
     __proto__: WebInspector.TimelineModel.Filter.prototype
-}
+};
 
 /**
  * @constructor
  * @extends {WebInspector.TimelineModel.Filter}
  */
 WebInspector.TimelineIsLongFilter = function()
 {
     WebInspector.TimelineModel.Filter.call(this);
     this._minimumRecordDuration = 0;
-}
+};
 
 WebInspector.TimelineIsLongFilter.prototype = {
     /**
      * @param {number} value
      */
     setMinimumRecordDuration: function(value)
     {
         this._minimumRecordDuration = value;
     },
 
     /**
      * @override
      * @param {!WebInspector.TracingModel.Event} event
      * @return {boolean}
      */
     accept: function(event)
     {
         var duration = event.endTime ? event.endTime - event.startTime : 0;
         return duration >= this._minimumRecordDuration;
     },
 
     __proto__: WebInspector.TimelineModel.Filter.prototype
 
-}
+};
 
 /**
  * @constructor
  * @extends {WebInspector.TimelineModel.Filter}
  * @param {!RegExp=} regExp
  */
 WebInspector.TimelineTextFilter = function(regExp)
 {
     WebInspector.TimelineModel.Filter.call(this);
     this._setRegExp(regExp || null);
-}
+};
 
 WebInspector.TimelineTextFilter.prototype = {
     /**
      * @param {?RegExp} regExp
      */
     _setRegExp: function(regExp)
     {
         this._regExp = regExp;
     },
 
     /**
      * @override
      * @param {!WebInspector.TracingModel.Event} event
      * @return {boolean}
      */
     accept: function(event)
     {
         return !this._regExp || WebInspector.TimelineUIUtils.testContentMatching(event, this._regExp);
     },
 
     __proto__: WebInspector.TimelineModel.Filter.prototype
-}
+};
 
 /**
  * @constructor
  * @extends {WebInspector.VBox}
  * @param {boolean} showTimer
  * @param {function()} stopCallback
  */
 WebInspector.TimelinePanel.StatusPane = function(showTimer, stopCallback)
 {
     WebInspector.VBox.call(this, true);
     this.registerRequiredCSS("timeline/timelineStatusDialog.css");
     this.contentElement.classList.add("timeline-status-dialog");
 
     var statusLine = this.contentElement.createChild("div", "status-dialog-line status");
     statusLine.createChild("div", "label").textContent = WebInspector.UIString("Status");
     this._status = statusLine.createChild("div", "content");
 
     if (showTimer) {
         var timeLine = this.contentElement.createChild("div", "status-dialog-line time");
         timeLine.createChild("div", "label").textContent = WebInspector.UIString("Time");
         this._time = timeLine.createChild("div", "content");
     }
     var progressLine = this.contentElement.createChild("div", "status-dialog-line progress");
     this._progressLabel = progressLine.createChild("div", "label");
     this._progressBar = progressLine.createChild("div", "indicator-container").createChild("div", "indicator");
 
     this._stopButton = createTextButton(WebInspector.UIString("Stop"), stopCallback);
     this.contentElement.createChild("div", "stop-button").appendChild(this._stopButton);
-}
+};
 
 WebInspector.TimelinePanel.StatusPane.prototype = {
     finish: function()
     {
         this._stopTimer();
         this._stopButton.disabled = true;
     },
 
     hide: function()
     {
@@ skipping 50 matching lines @@
      */
     _updateTimer: function(precise)
     {
         if (!this._timeUpdateTimer)
             return;
         var elapsed = (Date.now() - this._startTime) / 1000;
         this._time.textContent = WebInspector.UIString("%s\u2009sec", elapsed.toFixed(precise ? 1 : 0));
     },
 
     __proto__: WebInspector.VBox.prototype
-}
+};
 
 /**
  * @return {!WebInspector.TimelinePanel}
  */
 WebInspector.TimelinePanel.instance = function()
 {
     return /** @type {!WebInspector.TimelinePanel} */ (self.runtime.sharedInstance(WebInspector.TimelinePanel));
-}
+};
 
 /**
  * @constructor
  * @implements {WebInspector.QueryParamHandler}
  */
 WebInspector.LoadTimelineHandler = function()
 {
-}
+};
 
 WebInspector.LoadTimelineHandler.prototype = {
     /**
      * @override
      * @param {string} value
      */
     handleQueryParam: function(value)
     {
         WebInspector.viewManager.showView("timeline").then(() => {
             WebInspector.TimelinePanel.instance()._loadFromURL(window.decodeURIComponent(value));
         });
     }
-}
+};
 
 /**
  * @constructor
  * @implements {WebInspector.ActionDelegate}
  */
 WebInspector.TimelinePanel.ActionDelegate = function()
 {
-}
+};
 
 WebInspector.TimelinePanel.ActionDelegate.prototype = {
     /**
      * @override
      * @param {!WebInspector.Context} context
      * @param {string} actionId
      * @return {boolean}
      */
     handleAction: function(context, actionId)
     {
@@ skipping 11 matching lines @@
             return true;
         case "timeline.jump-to-previous-frame":
             panel._jumpToFrame(-1);
             return true;
         case "timeline.jump-to-next-frame":
             panel._jumpToFrame(1);
             return true;
         }
         return false;
     }
-}
+};
 
 /**
  * @constructor
  * @extends {WebInspector.Object}
  */
 WebInspector.TimelineFilters = function()
 {
     WebInspector.Object.call(this);
 
     this._categoryFilter = new WebInspector.TimelineCategoryFilter();
     this._durationFilter = new WebInspector.TimelineIsLongFilter();
     this._textFilter = new WebInspector.TimelineTextFilter();
     this._filters = [this._categoryFilter, this._durationFilter, this._textFilter];
 
     this._createFilterBar();
-}
+};
 
 /** @enum {symbol} */
 WebInspector.TimelineFilters.Events = {
     FilterChanged: Symbol("FilterChanged")
 };
 
 WebInspector.TimelineFilters._durationFilterPresetsMs = [0, 1, 15];
 
 WebInspector.TimelineFilters.prototype = {
     /**
@@ skipping 111 matching lines @@
 /**
  * @constructor
  * @extends {WebInspector.Object}
  * @implements {WebInspector.TargetManager.Observer}
  */
 WebInspector.CPUThrottlingManager = function()
 {
     this._targets = [];
     this._throttlingRate = 1.; // No throttling
     WebInspector.targetManager.observeTargets(this, WebInspector.Target.Capability.Browser);
-}
+};
 
 WebInspector.CPUThrottlingManager.prototype = {
     /**
      * @param {number} value
      */
     setRate: function(value)
     {
         this._throttlingRate = value;
         this._targets.forEach(target => target.emulationAgent().setCPUThrottlingRate(value));
         if (value !== 1)
@@ skipping 23 matching lines @@
     /**
      * @override
      * @param {!WebInspector.Target} target
      */
     targetRemoved: function(target)
     {
         this._targets.remove(target, true);
     },
 
     __proto__: WebInspector.Object.prototype
-}
+};
 
 /**
  * @constructor
  * @extends {WebInspector.HBox}
  */
 WebInspector.TimelinePanel.CustomCPUThrottlingRateDialog = function()
 {
     WebInspector.HBox.call(this, true);
     this.registerRequiredCSS("ui_lazy/dialog.css");
     this.contentElement.createChild("label").textContent = WebInspector.UIString("CPU Slowdown Rate: ");
 
     this._input = this.contentElement.createChild("input");
     this._input.setAttribute("type", "text");
     this._input.style.width = "64px";
     this._input.addEventListener("keydown", this._onKeyDown.bind(this), false);
 
     var addButton = this.contentElement.createChild("button");
     addButton.textContent = WebInspector.UIString("Set");
     addButton.addEventListener("click", this._apply.bind(this), false);
 
     this.setDefaultFocusedElement(this._input);
     this.contentElement.tabIndex = 0;
     this._resultPromise = new Promise(fulfill => this._callback = fulfill);
-}
+};
 
 /**
  * @param {!Element=} anchor
  * @return {!Promise<string>}
  */
 WebInspector.TimelinePanel.CustomCPUThrottlingRateDialog.show = function(anchor)
 {
     var dialog = new WebInspector.Dialog();
     var dialogContent = new WebInspector.TimelinePanel.CustomCPUThrottlingRateDialog();
     dialogContent.show(dialog.element);
     dialog.setWrapsContent(true);
     if (anchor)
         dialog.setPosition(anchor.totalOffsetLeft() - 32, anchor.totalOffsetTop() + anchor.offsetHeight);
     dialog.show();
     return dialogContent.result().then(value => (dialog.detach(), value));
-}
+};
 
 WebInspector.TimelinePanel.CustomCPUThrottlingRateDialog.prototype = {
     /**
      * @return {!Promise<string>}
      */
     result: function()
     {
         return this._resultPromise;
     },
 
     _apply: function()
     {
         this._callback(this._input.value);
     },
 
     /**
      * @param {!Event} event
      */
     _onKeyDown: function(event)
     {
         if (event.keyCode === WebInspector.KeyboardShortcut.Keys.Enter.code) {
             event.preventDefault();
             this._apply();
         }
     },
 
     __proto__: WebInspector.HBox.prototype
-}
+};