DevTools: use semicolons after each statement.

third_party/WebKit/Source/devtools/front_end/sdk/TracingModel.js

 /*
  * Copyright 2014 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
  * @param {!WebInspector.BackingStorage} backingStorage
  */
 WebInspector.TracingModel = function(backingStorage)
 {
     this._backingStorage = backingStorage;
     // Avoid extra reset of the storage as it's expensive.
     this._firstWritePending = true;
     this.reset();
-}
+};
 
 /**
  * @enum {string}
  */
 WebInspector.TracingModel.Phase = {
     Begin: "B",
     End: "E",
     Complete: "X",
     Instant: "I",
     AsyncBegin: "S",
@@ skipping 12 matching lines @@
     CreateObject: "N",
     SnapshotObject: "O",
     DeleteObject: "D"
 };
 
 WebInspector.TracingModel.MetadataEvent = {
     ProcessSortIndex: "process_sort_index",
     ProcessName: "process_name",
     ThreadSortIndex: "thread_sort_index",
     ThreadName: "thread_name"
-}
+};
 
 WebInspector.TracingModel.TopLevelEventCategory = "toplevel";
 WebInspector.TracingModel.DevToolsMetadataEventCategory = "disabled-by-default-devtools.timeline";
 WebInspector.TracingModel.DevToolsTimelineEventCategory = "disabled-by-default-devtools.timeline";
 
 WebInspector.TracingModel.FrameLifecycleEventCategory = "cc,devtools";
 
 /**
  * @param {string} phase
  * @return {boolean}
  */
 WebInspector.TracingModel.isNestableAsyncPhase = function(phase)
 {
     return phase === "b" || phase === "e" || phase === "n";
-}
+};
 
 /**
  * @param {string} phase
  * @return {boolean}
  */
 WebInspector.TracingModel.isAsyncBeginPhase = function(phase)
 {
     return phase === "S" || phase === "b";
-}
+};
 
 /**
  * @param {string} phase
  * @return {boolean}
  */
 WebInspector.TracingModel.isAsyncPhase = function(phase)
 {
     return WebInspector.TracingModel.isNestableAsyncPhase(phase) || phase === "S" || phase === "T" || phase === "F" || phase === "p";
-}
+};
 
 /**
  * @param {string} phase
  * @return {boolean}
  */
 WebInspector.TracingModel.isFlowPhase = function(phase)
 {
     return phase === "s" || phase === "t" || phase === "f";
-}
+};
 
 /**
  * @param {!WebInspector.TracingModel.Event} event
  * @return {boolean}
  */
 WebInspector.TracingModel.isTopLevelEvent = function(event)
 {
     return event.hasCategory(WebInspector.TracingModel.TopLevelEventCategory) ||
         event.hasCategory(WebInspector.TracingModel.DevToolsMetadataEventCategory) && event.name === "Program"; // Older timelines may have this instead of toplevel.
-}
+};
 
 /**
  * @param {!WebInspector.TracingManager.EventPayload} payload
  * @return {string|undefined}
  */
 WebInspector.TracingModel._extractId = function(payload)
 {
     var scope = payload.scope || "";
     if (typeof payload.id2 === "undefined")
         return scope && payload.id ? `${scope}@${payload.id}` : payload.id;
     var id2 = payload.id2;
     if (typeof id2 === "object" && ("global" in id2) !== ("local" in id2))
         return typeof id2["global"] !== "undefined" ? `:${scope}:${id2["global"]}` : `:${scope}:${payload.pid}:${id2["local"]}`;
     console.error(`Unexpected id2 field at ${payload.ts / 1000}, one and only one of 'local' and 'global' should be present.`);
-}
+};
 
 /**
  * @param {!WebInspector.TracingModel} tracingModel
  * @return {?WebInspector.TracingModel.Thread}
  *
  * TODO: Move this to a better place. This is here just for convenience o
  * re-use between modules. This really belongs to a higher level, since it
  * is specific to chrome's usage of tracing.
  */
 WebInspector.TracingModel.browserMainThread = function(tracingModel)
@@ skipping 11 matching lines @@
     }
     if (crRendererMainThreads.length === 1)
         return crRendererMainThreads[0];
     if (browserProcesses.length === 1)
         return browserProcesses[0].threadByName("CrBrowserMain");
     var tracingStartedInBrowser = tracingModel.devToolsMetadataEvents().filter(e => e.name === "TracingStartedInBrowser");
     if (tracingStartedInBrowser.length === 1)
         return tracingStartedInBrowser[0].thread;
     WebInspector.console.error("Failed to find browser main thread in trace, some timeline features may be unavailable");
     return null;
-}
+};
 
 /**
  * @interface
  */
 WebInspector.BackingStorage = function()
 {
-}
+};
 
 WebInspector.BackingStorage.prototype = {
     /**
      * @param {string} string
      */
     appendString: function(string) { },
 
     /**
      * @param {string} string
      * @return {function():!Promise.<?string>}
      */
     appendAccessibleString: function(string) { },
 
     finishWriting: function() { },
 
     reset: function() { },
-}
+};
 
 
 WebInspector.TracingModel.prototype = {
     /**
      * @return {!Array.<!WebInspector.TracingModel.Event>}
      */
     devToolsMetadataEvents: function()
     {
         return this._devToolsMetadataEvents;
     },
@@ skipping 299 matching lines @@
      */
     _parsedCategoriesForString: function(str)
     {
         var parsedCategories = this._parsedCategories.get(str);
         if (!parsedCategories) {
             parsedCategories = new Set(str.split(","));
             this._parsedCategories.set(str, parsedCategories);
         }
         return parsedCategories;
     }
-}
+};
 
 /**
  * @constructor
  * @param {string} categories
  * @param {string} name
  * @param {!WebInspector.TracingModel.Phase} phase
  * @param {number} startTime
  * @param {!WebInspector.TracingModel.Thread} thread
  */
 WebInspector.TracingModel.Event = function(categories, name, phase, startTime, thread)
@@ skipping 21 matching lines @@
     this.stackTrace = null;
     /** @type {?Element} */
     this.previewElement = null;
     /** @type {?string} */
     this.url = null;
     /** @type {number} */
     this.backendNodeId = 0;
 
     /** @type {number} */
     this.selfTime = 0;
-}
+};
 
 /**
  * @param {!WebInspector.TracingManager.EventPayload} payload
  * @param {!WebInspector.TracingModel.Thread} thread
  * @return {!WebInspector.TracingModel.Event}
  */
 WebInspector.TracingModel.Event.fromPayload = function(payload, thread)
 {
     var event = new WebInspector.TracingModel.Event(payload.cat, payload.name, /** @type {!WebInspector.TracingModel.Phase} */ (payload.ph), payload.ts / 1000, thread);
     if (payload.args)
         event.addArgs(payload.args);
     else
         console.error("Missing mandatory event argument 'args' at " + payload.ts / 1000);
     if (typeof payload.dur === "number")
         event.setEndTime((payload.ts + payload.dur) / 1000);
     var id = WebInspector.TracingModel._extractId(payload);
     if (typeof id !== "undefined")
         event.id = id;
     if (payload.bind_id)
         event.bind_id = payload.bind_id;
 
     return event;
-}
+};
 
 WebInspector.TracingModel.Event.prototype = {
     /**
      * @param {string} categoryName
      * @return {boolean}
      */
     hasCategory: function(categoryName)
     {
         return this._parsedCategories.has(categoryName);
     },
@@ skipping 35 matching lines @@
             console.error("Missing mandatory event argument 'args' at " + endEvent.startTime);
         this.setEndTime(endEvent.startTime);
     },
 
     /**
      * @param {?function():!Promise.<?string>} backingStorage
      */
     _setBackingStorage: function(backingStorage)
     {
     }
-}
+};
 
 /**
  * @param {!WebInspector.TracingModel.Event} a
  * @param {!WebInspector.TracingModel.Event} b
  * @return {number}
  */
 WebInspector.TracingModel.Event.compareStartTime = function(a, b)
 {
     return a.startTime - b.startTime;
-}
+};
 
 /**
  * @param {!WebInspector.TracingModel.Event} a
  * @param {!WebInspector.TracingModel.Event} b
  * @return {number}
  */
 WebInspector.TracingModel.Event.compareStartAndEndTime = function(a, b)
 {
     return a.startTime - b.startTime || (b.endTime !== undefined && a.endTime !== undefined && b.endTime - a.endTime) || 0;
-}
+};
 
 /**
  * @param {!WebInspector.TracingModel.Event} a
  * @param {!WebInspector.TracingModel.Event} b
  * @return {number}
  */
 WebInspector.TracingModel.Event.orderedCompareStartTime = function(a, b)
 {
     // Array.mergeOrdered coalesces objects if comparator returns 0.
     // To change this behavior this comparator return -1 in the case events
     // startTime's are equal, so both events got placed into the result array.
     return a.startTime - b.startTime || a.ordinal - b.ordinal || -1;
-}
+};
 
 /**
  * @constructor
  * @extends {WebInspector.TracingModel.Event}
  * @param {string} category
  * @param {string} name
  * @param {number} startTime
  * @param {!WebInspector.TracingModel.Thread} thread
  */
 WebInspector.TracingModel.ObjectSnapshot = function(category, name, startTime, thread)
 {
     WebInspector.TracingModel.Event.call(this, category, name, WebInspector.TracingModel.Phase.SnapshotObject, startTime, thread);
-}
+};
 
 /**
  * @param {!WebInspector.TracingManager.EventPayload} payload
  * @param {!WebInspector.TracingModel.Thread} thread
  * @return {!WebInspector.TracingModel.ObjectSnapshot}
  */
 WebInspector.TracingModel.ObjectSnapshot.fromPayload = function(payload, thread)
 {
     var snapshot = new WebInspector.TracingModel.ObjectSnapshot(payload.cat, payload.name, payload.ts / 1000, thread);
     var id = WebInspector.TracingModel._extractId(payload);
     if (typeof id !== "undefined")
         snapshot.id = id;
     if (!payload.args || !payload.args["snapshot"]) {
         console.error("Missing mandatory 'snapshot' argument at " + payload.ts / 1000);
         return snapshot;
     }
     if (payload.args)
         snapshot.addArgs(payload.args);
     return snapshot;
-}
+};
 
 WebInspector.TracingModel.ObjectSnapshot.prototype = {
     /**
      * @param {function(?)} callback
      */
     requestObject: function(callback)
     {
         var snapshot = this.args["snapshot"];
         if (snapshot) {
             callback(snapshot);
@@ skipping 35 matching lines @@
      */
     _setBackingStorage: function(backingStorage)
     {
         if (!backingStorage)
             return;
         this._backingStorage = backingStorage;
         this.args = {};
     },
 
     __proto__: WebInspector.TracingModel.Event.prototype
-}
+};
 
 /**
  * @constructor
  * @param {!WebInspector.TracingModel.Event} startEvent
  * @extends {WebInspector.TracingModel.Event}
  */
 WebInspector.TracingModel.AsyncEvent = function(startEvent)
 {
-    WebInspector.TracingModel.Event.call(this, startEvent.categoriesString, startEvent.name, startEvent.phase, startEvent.startTime, startEvent.thread)
+    WebInspector.TracingModel.Event.call(this, startEvent.categoriesString, startEvent.name, startEvent.phase, startEvent.startTime, startEvent.thread);
     this.addArgs(startEvent.args);
     this.steps = [startEvent];
-}
+};
 
 WebInspector.TracingModel.AsyncEvent.prototype = {
     /**
      * @param {!WebInspector.TracingModel.Event} event
      */
     _addStep: function(event)
     {
         this.steps.push(event);
         if (event.phase === WebInspector.TracingModel.Phase.AsyncEnd || event.phase === WebInspector.TracingModel.Phase.NestableAsyncEnd) {
             this.setEndTime(event.startTime);
             // FIXME: ideally, we shouldn't do this, but this makes the logic of converting
             // async console events to sync ones much simpler.
             this.steps[0].setEndTime(event.startTime);
         }
     },
 
     __proto__: WebInspector.TracingModel.Event.prototype
-}
+};
 
 /**
  * @constructor
  * @param {!WebInspector.TracingModel.Event} event
  */
 WebInspector.TracingModel.ProfileEventsGroup = function(event)
 {
     /** @type {!Array<!WebInspector.TracingModel.Event>} */
     this.children = [event];
-}
+};
 
 WebInspector.TracingModel.ProfileEventsGroup.prototype = {
     /**
      * @param {!WebInspector.TracingModel.Event} event
      */
     _addChild: function(event)
     {
         this.children.push(event);
     }
-}
+};
 
 /**
  * @constructor
  */
 WebInspector.TracingModel.NamedObject = function()
 {
-}
+};
 
 WebInspector.TracingModel.NamedObject.prototype =
 {
     /**
      * @param {string} name
      */
     _setName: function(name)
     {
         this._name = name;
     },
 
     /**
      * @return {string}
      */
     name: function()
     {
         return this._name;
     },
 
     /**
      * @param {number} sortIndex
      */
     _setSortIndex: function(sortIndex)
     {
         this._sortIndex = sortIndex;
     },
-}
+};
 
 /**
  * @param {!Array.<!WebInspector.TracingModel.NamedObject>} array
  */
 WebInspector.TracingModel.NamedObject._sort = function(array)
 {
     /**
      * @param {!WebInspector.TracingModel.NamedObject} a
      * @param {!WebInspector.TracingModel.NamedObject} b
      */
     function comparator(a, b)
     {
         return a._sortIndex !== b._sortIndex ? a._sortIndex - b._sortIndex : a.name().localeCompare(b.name());
     }
     return array.sort(comparator);
-}
+};
 
 /**
  * @constructor
  * @extends {WebInspector.TracingModel.NamedObject}
  * @param {!WebInspector.TracingModel} model
  * @param {number} id
  */
 WebInspector.TracingModel.Process = function(model, id)
 {
     WebInspector.TracingModel.NamedObject.call(this);
     this._setName("Process " + id);
     this._id = id;
     /** @type {!Map<number, !WebInspector.TracingModel.Thread>} */
     this._threads = new Map();
     this._threadByName = new Map();
     this._model = model;
-}
+};
 
 WebInspector.TracingModel.Process.prototype = {
     /**
      * @return {number}
      */
     id: function()
     {
         return this._id;
     },
 
@@ skipping 40 matching lines @@
 
     /**
      * @return {!Array.<!WebInspector.TracingModel.Thread>}
      */
     sortedThreads: function()
     {
         return WebInspector.TracingModel.NamedObject._sort(this._threads.valuesArray());
     },
 
     __proto__: WebInspector.TracingModel.NamedObject.prototype
-}
+};
 
 /**
  * @constructor
  * @extends {WebInspector.TracingModel.NamedObject}
  * @param {!WebInspector.TracingModel.Process} process
  * @param {number} id
  */
 WebInspector.TracingModel.Thread = function(process, id)
 {
     WebInspector.TracingModel.NamedObject.call(this);
     this._process = process;
     this._setName("Thread " + id);
     this._events = [];
     this._asyncEvents = [];
     this._id = id;
     this._model = process._model;
-}
+};
 
 WebInspector.TracingModel.Thread.prototype = {
     tracingComplete: function()
     {
         this._asyncEvents.stableSort(WebInspector.TracingModel.Event.compareStartAndEndTime);
         this._events.stableSort(WebInspector.TracingModel.Event.compareStartTime);
         var phases = WebInspector.TracingModel.Phase;
         var stack = [];
         for (var i = 0; i < this._events.length; ++i) {
             var e = this._events[i];
@@ skipping 83 matching lines @@
 
     /**
      * @return {!Array.<!WebInspector.TracingModel.AsyncEvent>}
      */
     asyncEvents: function()
     {
         return this._asyncEvents;
     },
 
     __proto__: WebInspector.TracingModel.NamedObject.prototype
-}
+};