DevTools: use semicolons after each statement.

third_party/WebKit/Source/devtools/front_end/profiler/HeapProfileView.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
  * @implements {WebInspector.Searchable}
  * @extends {WebInspector.ProfileView}
  * @param {!WebInspector.SamplingHeapProfileHeader} profileHeader
  */
 WebInspector.HeapProfileView = function(profileHeader)
 {
     this._profileHeader = profileHeader;
     this.profile = new WebInspector.SamplingHeapProfileModel(profileHeader._profile || profileHeader.protocolProfile());
     this.adjustedTotal = this.profile.total;
     var views = [
         WebInspector.ProfileView.ViewTypes.Flame,
         WebInspector.ProfileView.ViewTypes.Heavy,
         WebInspector.ProfileView.ViewTypes.Tree
     ];
     WebInspector.ProfileView.call(this, new WebInspector.HeapProfileView.NodeFormatter(this), views);
-}
+};
 
 WebInspector.HeapProfileView.prototype = {
     /**
      * @override
      * @param {string} columnId
      * @return {string}
      */
     columnHeader: function(columnId)
     {
         switch (columnId) {
         case "self": return WebInspector.UIString("Self Size (bytes)");
         case "total": return WebInspector.UIString("Total Size (bytes)");
         }
         return "";
     },
 
     /**
      * @override
      * @return {!WebInspector.FlameChartDataProvider}
      */
     createFlameChartDataProvider: function()
     {
         return new WebInspector.HeapFlameChartDataProvider(this.profile, this._profileHeader.target());
     },
 
     __proto__: WebInspector.ProfileView.prototype
-}
+};
 
 /**
  * @constructor
  * @extends {WebInspector.ProfileType}
  */
 WebInspector.SamplingHeapProfileType = function()
 {
     WebInspector.ProfileType.call(this, WebInspector.SamplingHeapProfileType.TypeId, WebInspector.UIString("Record Allocation Profile"));
     this._recording = false;
     WebInspector.SamplingHeapProfileType.instance = this;
-}
+};
 
 WebInspector.SamplingHeapProfileType.TypeId = "SamplingHeap";
 
 WebInspector.SamplingHeapProfileType.prototype = {
     /**
      * @override
      * @return {string}
      */
     typeName: function()
     {
@@ skipping 101 matching lines @@
 
     /**
      * @override
      */
     profileBeingRecordedRemoved: function()
     {
         this.stopRecordingProfile();
     },
 
     __proto__: WebInspector.ProfileType.prototype
-}
+};
 
 /**
  * @constructor
  * @extends {WebInspector.WritableProfileHeader}
  * @param {?WebInspector.Target} target
  * @param {!WebInspector.SamplingHeapProfileType} type
  * @param {string=} title
  */
 WebInspector.SamplingHeapProfileHeader = function(target, type, title)
 {
     WebInspector.WritableProfileHeader.call(this, target, type, title || WebInspector.UIString("Profile %d", type.nextProfileUid()));
-}
+};
 
 WebInspector.SamplingHeapProfileHeader.prototype = {
     /**
      * @override
      * @return {!WebInspector.ProfileView}
      */
     createView: function()
     {
         return new WebInspector.HeapProfileView(this);
     },
 
     /**
      * @return {!HeapProfilerAgent.SamplingHeapProfile}
      */
     protocolProfile: function()
     {
         return this._protocolProfile;
     },
 
     __proto__: WebInspector.WritableProfileHeader.prototype
-}
+};
 
 /**
  * @constructor
  * @extends {WebInspector.ProfileNode}
  * @param {!HeapProfilerAgent.SamplingHeapProfileNode} node
  */
 WebInspector.SamplingHeapProfileNode = function(node)
 {
     var callFrame = node.callFrame || /** @type {!RuntimeAgent.CallFrame} */ ({
         // Backward compatibility for old CpuProfileNode format.
         functionName: node["functionName"],
         scriptId: node["scriptId"],
         url: node["url"],
         lineNumber: node["lineNumber"] - 1,
         columnNumber: node["columnNumber"] - 1
     });
     WebInspector.ProfileNode.call(this, callFrame);
     this.self = node.selfSize;
-}
+};
 
 WebInspector.SamplingHeapProfileNode.prototype = {
     __proto__: WebInspector.ProfileNode.prototype
-}
+};
 
 /**
  * @constructor
  * @extends {WebInspector.ProfileTreeModel}
  * @param {!HeapProfilerAgent.SamplingHeapProfile} profile
  */
 WebInspector.SamplingHeapProfileModel = function(profile)
 {
     WebInspector.ProfileTreeModel.call(this, this._translateProfileTree(profile.head));
-}
+};
 
 WebInspector.SamplingHeapProfileModel.prototype = {
     /**
      * @param {!HeapProfilerAgent.SamplingHeapProfileNode} root
      * @return {!WebInspector.SamplingHeapProfileNode}
      */
     _translateProfileTree: function(root)
     {
         var resultRoot = new WebInspector.SamplingHeapProfileNode(root);
         var targetNodeStack = [resultRoot];
         var sourceNodeStack = [root];
         while (sourceNodeStack.length) {
             var sourceNode = sourceNodeStack.pop();
             var parentNode = targetNodeStack.pop();
             parentNode.children = sourceNode.children.map(child => new WebInspector.SamplingHeapProfileNode(child));
             sourceNodeStack.push.apply(sourceNodeStack, sourceNode.children);
             targetNodeStack.push.apply(targetNodeStack, parentNode.children);
         }
         return resultRoot;
     },
 
     __proto__: WebInspector.ProfileTreeModel.prototype
-}
+};
 
 /**
  * @constructor
  * @implements {WebInspector.ProfileDataGridNode.Formatter}
  * @param {!WebInspector.ProfileView} profileView
  */
 WebInspector.HeapProfileView.NodeFormatter = function(profileView)
 {
     this._profileView = profileView;
-}
+};
 
 WebInspector.HeapProfileView.NodeFormatter.prototype = {
     /**
      * @override
      * @param {number} value
      * @return {string}
      */
     formatValue: function(value)
     {
         return Number.withThousandsSeparator(value);
@@ skipping 12 matching lines @@
 
     /**
      * @override
      * @param  {!WebInspector.ProfileDataGridNode} node
      * @return {?Element}
      */
     linkifyNode: function(node)
     {
         return this._profileView.linkifier().maybeLinkifyConsoleCallFrame(this._profileView.target(), node.profileNode.callFrame, "profile-node-file");
     }
-}
+};
 
 /**
  * @constructor
  * @extends {WebInspector.ProfileFlameChartDataProvider}
  * @param {!WebInspector.ProfileTreeModel} profile
  * @param {?WebInspector.Target} target
  */
 WebInspector.HeapFlameChartDataProvider = function(profile, target)
 {
     WebInspector.ProfileFlameChartDataProvider.call(this, target);
     this._profile = profile;
-}
+};
 
 WebInspector.HeapFlameChartDataProvider.prototype = {
     /**
      * @override
      * @return {number}
      */
     minimumBoundary: function()
     {
         return 0;
     },
@@ skipping 93 matching lines @@
         pushEntryInfoRow(WebInspector.UIString("Total size"), Number.bytesToString(node.total));
         var linkifier = new WebInspector.Linkifier();
         var link = linkifier.maybeLinkifyConsoleCallFrame(this._target, node.callFrame);
         if (link)
             pushEntryInfoRow(WebInspector.UIString("URL"), link.textContent);
         linkifier.dispose();
         return WebInspector.ProfileView.buildPopoverTable(entryInfo);
     },
 
     __proto__: WebInspector.ProfileFlameChartDataProvider.prototype
-}
+};