DevTools: use semicolons after each statement.

third_party/WebKit/Source/devtools/front_end/profiler/HeapSnapshotView.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 140 matching lines @@
 
     this._popoverHelper = new WebInspector.ObjectPopoverHelper(this.element, this._getHoverAnchor.bind(this), this._resolveObjectForPopover.bind(this), undefined, true);
 
     this._currentPerspectiveIndex = 0;
     this._currentPerspective = this._perspectives[0];
     this._currentPerspective.activate(this);
     this._dataGrid = this._currentPerspective.masterGrid(this);
 
     this._populate();
     this._searchThrottler = new WebInspector.Throttler(0);
-}
+};
 
 /**
  * @constructor
  * @param {string} title
  */
 WebInspector.HeapSnapshotView.Perspective = function(title)
 {
     this._title = title;
-}
+};
 
 WebInspector.HeapSnapshotView.Perspective.prototype = {
     /**
      * @param {!WebInspector.HeapSnapshotView} heapSnapshotView
      */
     activate: function(heapSnapshotView) { },
 
     /**
      * @param {!WebInspector.HeapSnapshotView} heapSnapshotView
      */
@@ skipping 30 matching lines @@
         return this._title;
     },
 
     /**
      * @return {boolean}
      */
     supportsSearch: function()
     {
         return false;
     }
-}
+};
 
 /**
  * @constructor
  * @extends {WebInspector.HeapSnapshotView.Perspective}
  */
 WebInspector.HeapSnapshotView.SummaryPerspective = function()
 {
     WebInspector.HeapSnapshotView.Perspective.call(this,  WebInspector.UIString("Summary"));
-}
+};
 
 WebInspector.HeapSnapshotView.SummaryPerspective.prototype = {
     /**
      * @override
      * @param {!WebInspector.HeapSnapshotView} heapSnapshotView
      */
     activate: function(heapSnapshotView)
     {
         heapSnapshotView._splitWidget.setMainWidget(heapSnapshotView._constructorsWidget);
         heapSnapshotView._splitWidget.setSidebarWidget(heapSnapshotView._objectDetailsView);
@@ skipping 20 matching lines @@
     /**
      * @override
      * @return {boolean}
      */
     supportsSearch: function()
     {
         return true;
     },
 
     __proto__: WebInspector.HeapSnapshotView.Perspective.prototype
-}
+};
 
 /**
  * @constructor
  * @extends {WebInspector.HeapSnapshotView.Perspective}
  */
 WebInspector.HeapSnapshotView.ComparisonPerspective = function()
 {
     WebInspector.HeapSnapshotView.Perspective.call(this,  WebInspector.UIString("Comparison"));
-}
+};
 
 WebInspector.HeapSnapshotView.ComparisonPerspective.prototype = {
     /**
      * @override
      * @param {!WebInspector.HeapSnapshotView} heapSnapshotView
      */
     activate: function(heapSnapshotView)
     {
         heapSnapshotView._splitWidget.setMainWidget(heapSnapshotView._diffWidget);
         heapSnapshotView._splitWidget.setSidebarWidget(heapSnapshotView._objectDetailsView);
@@ skipping 15 matching lines @@
     /**
      * @override
      * @return {boolean}
      */
     supportsSearch: function()
     {
         return true;
     },
 
     __proto__: WebInspector.HeapSnapshotView.Perspective.prototype
-}
+};
 
 /**
  * @constructor
  * @extends {WebInspector.HeapSnapshotView.Perspective}
  */
 WebInspector.HeapSnapshotView.ContainmentPerspective = function()
 {
     WebInspector.HeapSnapshotView.Perspective.call(this,  WebInspector.UIString("Containment"));
-}
+};
 
 WebInspector.HeapSnapshotView.ContainmentPerspective.prototype = {
     /**
      * @override
      * @param {!WebInspector.HeapSnapshotView} heapSnapshotView
      */
     activate: function(heapSnapshotView)
     {
         heapSnapshotView._splitWidget.setMainWidget(heapSnapshotView._containmentWidget);
         heapSnapshotView._splitWidget.setSidebarWidget(heapSnapshotView._objectDetailsView);
         heapSnapshotView._splitWidget.show(heapSnapshotView._searchableView.element);
     },
 
     /**
      * @override
      * @param {!WebInspector.HeapSnapshotView} heapSnapshotView
      * @return {?WebInspector.DataGrid}
      */
     masterGrid: function(heapSnapshotView)
     {
         return heapSnapshotView._containmentDataGrid;
     },
 
     __proto__: WebInspector.HeapSnapshotView.Perspective.prototype
-}
+};
 
 /**
  * @constructor
  * @extends {WebInspector.HeapSnapshotView.Perspective}
  */
 WebInspector.HeapSnapshotView.AllocationPerspective = function()
 {
     WebInspector.HeapSnapshotView.Perspective.call(this,  WebInspector.UIString("Allocation"));
     this._allocationSplitWidget = new WebInspector.SplitWidget(false, true, "heapSnapshotAllocationSplitViewState", 200, 200);
     this._allocationSplitWidget.setSidebarWidget(new WebInspector.VBox());
 
-}
+};
 
 WebInspector.HeapSnapshotView.AllocationPerspective.prototype = {
     /**
      * @override
      * @param {!WebInspector.HeapSnapshotView} heapSnapshotView
      */
     activate: function(heapSnapshotView)
     {
         this._allocationSplitWidget.setMainWidget(heapSnapshotView._allocationWidget);
         heapSnapshotView._splitWidget.setMainWidget(heapSnapshotView._constructorsWidget);
@@ skipping 31 matching lines @@
      * @override
      * @param {!WebInspector.HeapSnapshotView} heapSnapshotView
      * @return {?WebInspector.DataGrid}
      */
     masterGrid: function(heapSnapshotView)
     {
         return heapSnapshotView._allocationDataGrid;
     },
 
     __proto__: WebInspector.HeapSnapshotView.Perspective.prototype
-}
+};
 
 /**
  * @constructor
  * @extends {WebInspector.HeapSnapshotView.Perspective}
  */
 WebInspector.HeapSnapshotView.StatisticsPerspective = function()
 {
     WebInspector.HeapSnapshotView.Perspective.call(this,  WebInspector.UIString("Statistics"));
-}
+};
 
 WebInspector.HeapSnapshotView.StatisticsPerspective.prototype = {
     /**
      * @override
      * @param {!WebInspector.HeapSnapshotView} heapSnapshotView
      */
     activate: function(heapSnapshotView)
     {
         heapSnapshotView._statisticsView.show(heapSnapshotView._searchableView.element);
     },
 
     /**
      * @override
      * @param {!WebInspector.HeapSnapshotView} heapSnapshotView
      * @return {?WebInspector.DataGrid}
      */
     masterGrid: function(heapSnapshotView)
     {
         return null;
     },
 
     __proto__: WebInspector.HeapSnapshotView.Perspective.prototype
-}
+};
 
 
 WebInspector.HeapSnapshotView.prototype = {
     /**
      * @return {!WebInspector.SearchableView}
      */
     searchableView: function()
     {
         return this._searchableView;
     },
@@ skipping 546 matching lines @@
     {
         if (this._allocationStackView) {
             this._allocationStackView.clear();
             this._allocationDataGrid.dispose();
         }
         if (this._trackingOverviewGrid)
             this._trackingOverviewGrid.dispose();
     },
 
     __proto__: WebInspector.SimpleView.prototype
-}
+};
 
 /**
  * @constructor
  * @extends {WebInspector.ProfileType}
  * @implements {WebInspector.TargetManager.Observer}
  * @param {string=} id
  * @param {string=} title
  */
 WebInspector.HeapSnapshotProfileType = function(id, title)
 {
     WebInspector.ProfileType.call(this, id || WebInspector.HeapSnapshotProfileType.TypeId, title || WebInspector.UIString("Take Heap Snapshot"));
     WebInspector.targetManager.observeTargets(this);
     WebInspector.targetManager.addModelListener(WebInspector.HeapProfilerModel, WebInspector.HeapProfilerModel.Events.ResetProfiles, this._resetProfiles, this);
     WebInspector.targetManager.addModelListener(WebInspector.HeapProfilerModel, WebInspector.HeapProfilerModel.Events.AddHeapSnapshotChunk, this._addHeapSnapshotChunk, this);
     WebInspector.targetManager.addModelListener(WebInspector.HeapProfilerModel, WebInspector.HeapProfilerModel.Events.ReportHeapSnapshotProgress, this._reportHeapSnapshotProgress, this);
-}
+};
 
 WebInspector.HeapSnapshotProfileType.TypeId = "HEAP";
 WebInspector.HeapSnapshotProfileType.SnapshotReceived = "SnapshotReceived";
 
 WebInspector.HeapSnapshotProfileType.prototype = {
     /**
      * @override
      * @param {!WebInspector.Target} target
      */
     targetAdded: function(target)
@@ skipping 120 matching lines @@
     },
 
     _snapshotReceived: function(profile)
     {
         if (this._profileBeingRecorded === profile)
             this.setProfileBeingRecorded(null);
         this.dispatchEventToListeners(WebInspector.HeapSnapshotProfileType.SnapshotReceived, profile);
     },
 
     __proto__: WebInspector.ProfileType.prototype
-}
+};
 
 
 /**
  * @constructor
  * @extends {WebInspector.HeapSnapshotProfileType}
  */
 WebInspector.TrackingHeapSnapshotProfileType = function()
 {
     WebInspector.HeapSnapshotProfileType.call(this, WebInspector.TrackingHeapSnapshotProfileType.TypeId, WebInspector.UIString("Record Allocation Timeline"));
-}
+};
 
 WebInspector.TrackingHeapSnapshotProfileType.TypeId = "HEAP-RECORD";
 
 WebInspector.TrackingHeapSnapshotProfileType.HeapStatsUpdate = "HeapStatsUpdate";
 WebInspector.TrackingHeapSnapshotProfileType.TrackingStarted = "TrackingStarted";
 WebInspector.TrackingHeapSnapshotProfileType.TrackingStopped = "TrackingStopped";
 
 
 /**
  * @constructor
  */
 WebInspector.TrackingHeapSnapshotProfileType.Samples = function()
 {
     /** @type {!Array.<number>} */
     this.sizes = [];
     /** @type {!Array.<number>} */
     this.ids = [];
     /** @type {!Array.<number>} */
     this.timestamps = [];
     /** @type {!Array.<number>} */
     this.max = [];
     /** @type {number} */
     this.totalTime = 30000;
-}
+};
 
 WebInspector.TrackingHeapSnapshotProfileType.prototype = {
 
     /**
      * @override
      * @param {!WebInspector.Target} target
      */
     targetAdded: function(target)
     {
         WebInspector.HeapSnapshotProfileType.prototype.targetAdded.call(this, target);
@@ skipping 173 matching lines @@
     /**
      * @override
      */
     profileBeingRecordedRemoved: function()
     {
         this._stopRecordingProfile();
         this._profileSamples = null;
     },
 
     __proto__: WebInspector.HeapSnapshotProfileType.prototype
-}
+};
 
 /**
  * @constructor
  * @extends {WebInspector.ProfileHeader}
  * @param {?WebInspector.Target} target
  * @param {!WebInspector.HeapSnapshotProfileType} type
  * @param {string=} title
  */
 WebInspector.HeapProfileHeader = function(target, type, title)
 {
@@ skipping 19 matching lines @@
     this._bufferedWriter = null;
 
     /**
      * @param {function(!WebInspector.HeapSnapshotProxy)} fulfill
      * @this {WebInspector.HeapProfileHeader}
      */
     function loadResolver(fulfill)
     {
         this._fulfillLoad = fulfill;
     }
-}
+};
 
 WebInspector.HeapProfileHeader.prototype = {
     /**
      * @override
      * @param {!WebInspector.ProfileType.DataDisplayDelegate} dataDisplayDelegate
      * @return {!WebInspector.ProfileSidebarTreeElement}
      */
     createSidebarTreeElement: function(dataDisplayDelegate)
     {
         return new WebInspector.ProfileSidebarTreeElement(dataDisplayDelegate, this, "heap-snapshot-sidebar-tree-item");
@@ skipping 188 matching lines @@
         var fileReader = this._createFileReader(file, delegate);
         fileReader.start(this._receiver);
     },
 
     _createFileReader: function(file, delegate)
     {
         return new WebInspector.ChunkedFileReader(file, 10000000, delegate);
     },
 
     __proto__: WebInspector.ProfileHeader.prototype
-}
+};
 
 /**
  * @constructor
  * @implements {WebInspector.OutputStreamDelegate}
  */
 WebInspector.HeapSnapshotLoadFromFileDelegate = function(snapshotHeader)
 {
     this._snapshotHeader = snapshotHeader;
-}
+};
 
 WebInspector.HeapSnapshotLoadFromFileDelegate.prototype = {
     /**
      * @override
      */
     onTransferStarted: function()
     {
     },
 
     /**
@@ skipping 26 matching lines @@
         case e.target.error.NOT_READABLE_ERR:
             subtitle = WebInspector.UIString("'%s' is not readable", reader.fileName());
             break;
         case e.target.error.ABORT_ERR:
             return;
         default:
             subtitle = WebInspector.UIString("'%s' error %d", reader.fileName(), e.target.error.code);
         }
         this._snapshotHeader.updateStatus(subtitle);
     }
-}
+};
 
 /**
  * @constructor
  * @implements {WebInspector.OutputStreamDelegate}
  * @param {!WebInspector.HeapProfileHeader} profileHeader
  */
 WebInspector.SaveSnapshotOutputStreamDelegate = function(profileHeader)
 {
     this._profileHeader = profileHeader;
-}
+};
 
 WebInspector.SaveSnapshotOutputStreamDelegate.prototype = {
     /**
      * @override
      */
     onTransferStarted: function()
     {
         this._profileHeader._updateSaveProgress(0, 1);
     },
 
@@ skipping 17 matching lines @@
     /**
      * @override
      * @param {!WebInspector.ChunkedReader} reader
      * @param {!Event} event
      */
     onError: function(reader, event)
     {
         WebInspector.console.error("Failed to read heap snapshot from temp file: " + /** @type {!ErrorEvent} */ (event).message);
         this.onTransferFinished();
     }
-}
+};
 
 /**
  * @constructor
  * @extends {WebInspector.VBox}
  * @param {!WebInspector.HeapProfileHeader} heapProfileHeader
  */
 WebInspector.HeapTrackingOverviewGrid = function(heapProfileHeader)
 {
     WebInspector.VBox.call(this);
     this.element.id = "heap-recording-view";
@@ skipping 12 matching lines @@
     this._profileType = heapProfileHeader.profileType();
     if (!heapProfileHeader.fromFile() && heapProfileHeader.profileType().profileBeingRecorded() === heapProfileHeader) {
         this._profileType.addEventListener(WebInspector.TrackingHeapSnapshotProfileType.HeapStatsUpdate, this._onHeapStatsUpdate, this);
         this._profileType.addEventListener(WebInspector.TrackingHeapSnapshotProfileType.TrackingStopped, this._onStopTracking, this);
     }
     this._windowLeft = 0.0;
     this._windowRight = 1.0;
     this._overviewGrid.setWindow(this._windowLeft, this._windowRight);
     this._yScale = new WebInspector.HeapTrackingOverviewGrid.SmoothScale();
     this._xScale = new WebInspector.HeapTrackingOverviewGrid.SmoothScale();
-}
+};
 
 WebInspector.HeapTrackingOverviewGrid.IdsRangeChanged = "IdsRangeChanged";
 
 WebInspector.HeapTrackingOverviewGrid.prototype = {
     dispose: function()
     {
         this._onStopTracking();
     },
 
     _onStopTracking: function()
@@ skipping 219 matching lines @@
                 minId = ids[i];
                 continue;
             }
             size += sizes[i];
         }
 
         this.dispatchEventToListeners(WebInspector.HeapTrackingOverviewGrid.IdsRangeChanged, {minId: minId, maxId: maxId, size: size});
     },
 
     __proto__: WebInspector.VBox.prototype
-}
+};
 
 
 /**
  * @constructor
  */
 WebInspector.HeapTrackingOverviewGrid.SmoothScale = function()
 {
     this._lastUpdate = 0;
     this._currentScale = 0.0;
-}
+};
 
 WebInspector.HeapTrackingOverviewGrid.SmoothScale.prototype = {
     /**
      * @param {number} target
      * @return {number}
      */
     nextScale: function(target) {
         target = target || this._currentScale;
         if (this._currentScale) {
             var now = Date.now();
             var timeDeltaMs = now - this._lastUpdate;
             this._lastUpdate = now;
             var maxChangePerSec = 20;
             var maxChangePerDelta = Math.pow(maxChangePerSec, timeDeltaMs / 1000);
             var scaleChange = target / this._currentScale;
             this._currentScale *= Number.constrain(scaleChange, 1 / maxChangePerDelta, maxChangePerDelta);
         } else {
             this._currentScale = target;
         }
         return this._currentScale;
     }
-}
+};
 
 
 /**
  * @constructor
  * @implements {WebInspector.TimelineGrid.Calculator}
  */
 WebInspector.HeapTrackingOverviewGrid.OverviewCalculator = function()
 {
-}
+};
 
 WebInspector.HeapTrackingOverviewGrid.OverviewCalculator.prototype = {
     /**
      * @override
      * @return {number}
      */
     paddingLeft: function()
     {
         return 0;
     },
@@ skipping 57 matching lines @@
     },
 
     /**
      * @override
      * @return {number}
      */
     boundarySpan: function()
     {
         return this._maximumBoundaries - this._minimumBoundaries;
     }
-}
+};
 
 
 /**
  * @constructor
  * @extends {WebInspector.VBox}
  */
 WebInspector.HeapSnapshotStatisticsView = function()
 {
     WebInspector.VBox.call(this);
     this.setMinimumSize(50, 25);
     this._pieChart = new WebInspector.PieChart(150, WebInspector.HeapSnapshotStatisticsView._valueFormatter, true);
     this._pieChart.element.classList.add("heap-snapshot-stats-pie-chart");
     this.element.appendChild(this._pieChart.element);
     this._labels = this.element.createChild("div", "heap-snapshot-stats-legend");
-}
+};
 
 /**
  * @param {number} value
  * @return {string}
  */
 WebInspector.HeapSnapshotStatisticsView._valueFormatter = function(value)
 {
     return WebInspector.UIString("%s KB", Number.withThousandsSeparator(Math.round(value / 1024)));
-}
+};
 
 WebInspector.HeapSnapshotStatisticsView.prototype = {
     /**
      * @param {number} value
      */
     setTotal: function(value)
     {
         this._pieChart.setTotal(value);
     },
 
@@ skipping 13 matching lines @@
         var sizeDiv = node.createChild("div", "heap-snapshot-stats-size");
         if (color)
             swatchDiv.style.backgroundColor = color;
         else
             swatchDiv.classList.add("heap-snapshot-stats-empty-swatch");
         nameDiv.textContent = name;
         sizeDiv.textContent = WebInspector.HeapSnapshotStatisticsView._valueFormatter(value);
     },
 
     __proto__: WebInspector.VBox.prototype
-}
+};
 
 /**
  * @constructor
  * @extends {WebInspector.Widget}
  * @param {?WebInspector.Target} target
  */
 WebInspector.HeapAllocationStackView = function(target)
 {
     WebInspector.Widget.call(this);
     this._target = target;
     this._linkifier = new WebInspector.Linkifier();
-}
+};
 
 WebInspector.HeapAllocationStackView.prototype = {
     /**
      * @param {!WebInspector.HeapSnapshotProxy} snapshot
      * @param {number} snapshotNodeIndex
      */
     setAllocatedObject: function(snapshot, snapshotNodeIndex)
     {
         this.clear();
         snapshot.allocationStack(snapshotNodeIndex, this._didReceiveAllocationStack.bind(this));
@@ skipping 23 matching lines @@
             var name = frameDiv.createChild("div");
             name.textContent = WebInspector.beautifyFunctionName(frame.functionName);
             if (frame.scriptId) {
                 var urlElement = this._linkifier.linkifyScriptLocation(this._target, String(frame.scriptId), frame.scriptName, frame.line - 1, frame.column - 1);
                 frameDiv.appendChild(urlElement);
             }
         }
     },
 
     __proto__: WebInspector.Widget.prototype
-}
+};