DevTools: use semicolons after each statement.

third_party/WebKit/Source/devtools/front_end/timeline_model/TimelineModel.js

 /*
  * Copyright (C) 2012 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 18 matching lines @@
  */
 
 /**
  * @constructor
  * @param {!WebInspector.TimelineModel.Filter} eventFilter
  */
 WebInspector.TimelineModel = function(eventFilter)
 {
     this._eventFilter = eventFilter;
     this.reset();
-}
+};
 
 /**
  * @enum {string}
  */
 WebInspector.TimelineModel.RecordType = {
     Task: "Task",
     Program: "Program",
     EventDispatch: "EventDispatch",
 
     GPUTask: "GPUTask",
@@ skipping 106 matching lines @@
     InputLatencyMouseWheel: "InputLatency::MouseWheel",
     ImplSideFling: "InputHandlerProxy::HandleGestureFling::started",
     GCIdleLazySweep: "ThreadState::performIdleLazySweep",
     GCCompleteSweep: "ThreadState::completeSweep",
     GCCollectGarbage: "BlinkGCMarking",
 
     // CpuProfile is a virtual event created on frontend to support
     // serialization of CPU Profiles within tracing timeline data.
     CpuProfile: "CpuProfile",
     Profile: "Profile"
-}
+};
 
 WebInspector.TimelineModel.Category = {
     Console: "blink.console",
     UserTiming: "blink.user_timing",
     LatencyInfo: "latencyInfo"
 };
 
 /**
  * @enum {string}
  */
 WebInspector.TimelineModel.WarningType = {
     ForcedStyle: "ForcedStyle",
     ForcedLayout: "ForcedLayout",
     IdleDeadlineExceeded: "IdleDeadlineExceeded",
     V8Deopt: "V8Deopt"
-}
+};
 
 WebInspector.TimelineModel.MainThreadName = "main";
 WebInspector.TimelineModel.WorkerThreadName = "DedicatedWorker Thread";
 WebInspector.TimelineModel.RendererMainThreadName = "CrRendererMain";
 
 /**
  * @enum {symbol}
  */
 WebInspector.TimelineModel.AsyncEventGroup = {
     animation: Symbol("animation"),
@@ skipping 27 matching lines @@
             onEndEvent(stack.pop());
         if (e.duration) {
             onStartEvent(e);
             stack.push(e);
         } else {
             onInstantEvent && onInstantEvent(e, stack.peekLast() || null);
         }
     }
     while (stack.length)
         onEndEvent(stack.pop());
-}
+};
 
 WebInspector.TimelineModel.DevToolsMetadataEvent = {
     TracingStartedInBrowser: "TracingStartedInBrowser",
     TracingStartedInPage: "TracingStartedInPage",
     TracingSessionIdForWorker: "TracingSessionIdForWorker",
 };
 
 /**
  * @constructor
  * @param {string} name
  */
 WebInspector.TimelineModel.VirtualThread = function(name)
 {
     this.name = name;
     /** @type {!Array<!WebInspector.TracingModel.Event>} */
     this.events = [];
     /** @type {!Map<!WebInspector.TimelineModel.AsyncEventGroup, !Array<!WebInspector.TracingModel.AsyncEvent>>} */
     this.asyncEventsByGroup = new Map();
-}
+};
 
 WebInspector.TimelineModel.VirtualThread.prototype = {
     /**
      * @return {boolean}
      */
     isWorker: function()
     {
         return this.name === WebInspector.TimelineModel.WorkerThreadName;
     }
-}
+};
 
 /**
  * @constructor
  * @param {!WebInspector.TracingModel.Event} traceEvent
  */
 WebInspector.TimelineModel.Record = function(traceEvent)
 {
     this._event = traceEvent;
     this._children = [];
-}
+};
 
 /**
  * @param {!WebInspector.TimelineModel.Record} a
  * @param {!WebInspector.TimelineModel.Record} b
  * @return {number}
  */
 WebInspector.TimelineModel.Record._compareStartTime = function(a, b)
 {
     // Never return 0 as otherwise equal records would be merged.
     return a.startTime() <= b.startTime() ? -1 : 1;
-}
+};
 
 WebInspector.TimelineModel.Record.prototype = {
     /**
      * @return {?WebInspector.Target}
      */
     target: function()
     {
         var threadName = this._event.thread.name();
         // FIXME: correctly specify target
         return threadName === WebInspector.TimelineModel.RendererMainThreadName ? WebInspector.targetManager.targets()[0] || null : null;
@@ skipping 72 matching lines @@
     },
 
     /**
      * @param {!WebInspector.TimelineModel.Record} child
      */
     _addChild: function(child)
     {
         this._children.push(child);
         child.parent = this;
     }
-}
+};
 
 /** @typedef {!{page: !Array<!WebInspector.TracingModel.Event>, workers: !Array<!WebInspector.TracingModel.Event>}} */
 WebInspector.TimelineModel.MetadataEvents;
 
 /**
  * @return {!WebInspector.TimelineModel.RecordType}
  */
 WebInspector.TimelineModel._eventType = function(event)
 {
     if (event.hasCategory(WebInspector.TimelineModel.Category.Console))
         return WebInspector.TimelineModel.RecordType.ConsoleTime;
     if (event.hasCategory(WebInspector.TimelineModel.Category.UserTiming))
         return WebInspector.TimelineModel.RecordType.UserTiming;
     if (event.hasCategory(WebInspector.TimelineModel.Category.LatencyInfo))
         return WebInspector.TimelineModel.RecordType.LatencyInfo;
     return /** @type !WebInspector.TimelineModel.RecordType */ (event.name);
-}
+};
 
 WebInspector.TimelineModel.prototype = {
     /**
      * @deprecated Test use only!
      * @param {?function(!WebInspector.TimelineModel.Record)|?function(!WebInspector.TimelineModel.Record,number)} preOrderCallback
      * @param {function(!WebInspector.TimelineModel.Record)|function(!WebInspector.TimelineModel.Record,number)=} postOrderCallback
      * @return {boolean}
      */
     forAllRecords: function(preOrderCallback, postOrderCallback)
     {
@@ skipping 461 matching lines @@
     },
 
     /**
      * @param {!Map<!WebInspector.TimelineModel.AsyncEventGroup, !Array<!WebInspector.TracingModel.AsyncEvent>>} asyncEventsByGroup
      * @param {!Array<!WebInspector.TracingModel.AsyncEvent>} asyncEvents
      * @param {number=} startTime
      * @param {number=} endTime
      */
     _processAsyncEvents: function(asyncEventsByGroup, asyncEvents, startTime, endTime)
     {
-        var i = startTime ? asyncEvents.lowerBound(startTime, function(time, asyncEvent) { return time - asyncEvent.startTime }) : 0;
+        var i = startTime ? asyncEvents.lowerBound(startTime, function(time, asyncEvent) { return time - asyncEvent.startTime; }) : 0;
         for (; i < asyncEvents.length; ++i) {
             var asyncEvent = asyncEvents[i];
             if (endTime && asyncEvent.startTime >= endTime)
                 break;
             var asyncGroup = this._processAsyncEvent(asyncEvent);
             if (!asyncGroup)
                 continue;
             var groupAsyncEvents = asyncEventsByGroup.get(asyncGroup);
             if (!groupAsyncEvents) {
                 groupAsyncEvents = [];
@@ skipping 438 matching lines @@
                 request = new WebInspector.TimelineModel.NetworkRequest(e);
                 requests.set(id, request);
                 if (request.startTime)
                     requestsList.push(request);
                 else
                     zeroStartRequestsList.push(request);
             }
         }
         return zeroStartRequestsList.concat(requestsList);
     },
-}
+};
 
 /**
  * @param {!Array<!WebInspector.TimelineModel.Filter>} filters
  * @param {!WebInspector.TracingModel.Event} event
  * @return {boolean}
  */
 WebInspector.TimelineModel.isVisible = function(filters, event)
 {
     for (var i = 0; i < filters.length; ++i) {
         if (!filters[i].accept(event))
             return false;
     }
     return true;
-}
+};
 
 /**
  * @param {!WebInspector.TracingModel.Event} event
  * @return {boolean}
  */
 WebInspector.TimelineModel.isMarkerEvent = function(event)
 {
     var recordTypes = WebInspector.TimelineModel.RecordType;
     switch (event.name) {
     case recordTypes.TimeStamp:
     case recordTypes.MarkFirstPaint:
         return true;
     case recordTypes.MarkDOMContent:
     case recordTypes.MarkLoad:
         return event.args["data"]["isMainFrame"];
     default:
         return false;
     }
-}
+};
 
 /**
  * @constructor
  * @param {!WebInspector.TracingModel.Event} event
  */
 WebInspector.TimelineModel.NetworkRequest = function(event)
 {
     this.startTime = event.name === WebInspector.TimelineModel.RecordType.ResourceSendRequest ? event.startTime : 0;
     this.endTime = Infinity;
     /** @type {!Array<!WebInspector.TracingModel.Event>} */
     this.children = [];
     this.addEvent(event);
-}
+};
 
 WebInspector.TimelineModel.NetworkRequest.prototype = {
     /**
      * @param {!WebInspector.TracingModel.Event} event
      */
     addEvent: function(event)
     {
         this.children.push(event);
         var recordType = WebInspector.TimelineModel.RecordType;
         this.startTime = Math.min(this.startTime, event.startTime);
         var eventData = event.args["data"];
         if (eventData["mimeType"])
             this.mimeType = eventData["mimeType"];
         if ("priority" in eventData)
             this.priority = eventData["priority"];
         if (event.name === recordType.ResourceFinish)
             this.endTime = event.startTime;
         if (!this.responseTime && (event.name === recordType.ResourceReceiveResponse || event.name === recordType.ResourceReceivedData))
             this.responseTime = event.startTime;
         if (!this.url)
             this.url = eventData["url"];
         if (!this.requestMethod)
             this.requestMethod = eventData["requestMethod"];
     }
-}
+};
 
 /**
  * @constructor
  */
 WebInspector.TimelineModel.Filter = function()
 {
-}
+};
 
 WebInspector.TimelineModel.Filter.prototype = {
     /**
      * @param {!WebInspector.TracingModel.Event} event
      * @return {boolean}
      */
     accept: function(event)
     {
         return true;
     }
-}
+};
 
 /**
  * @constructor
  * @extends {WebInspector.TimelineModel.Filter}
  * @param {!Array.<string>} visibleTypes
  */
 WebInspector.TimelineVisibleEventsFilter = function(visibleTypes)
 {
     WebInspector.TimelineModel.Filter.call(this);
     this._visibleTypes = new Set(visibleTypes);
-}
+};
 
 WebInspector.TimelineVisibleEventsFilter.prototype = {
     /**
      * @override
      * @param {!WebInspector.TracingModel.Event} event
      * @return {boolean}
      */
     accept: function(event)
     {
         return this._visibleTypes.has(WebInspector.TimelineModel._eventType(event));
     },
 
     __proto__: WebInspector.TimelineModel.Filter.prototype
-}
+};
 
 /**
  * @constructor
  * @extends {WebInspector.TimelineModel.Filter}
  * @param {!Array<string>} excludeNames
  */
 WebInspector.ExclusiveNameFilter = function(excludeNames)
 {
     WebInspector.TimelineModel.Filter.call(this);
     this._excludeNames = new Set(excludeNames);
-}
+};
 
 WebInspector.ExclusiveNameFilter.prototype = {
     /**
      * @override
      * @param {!WebInspector.TracingModel.Event} event
      * @return {boolean}
      */
     accept: function(event)
     {
         return !this._excludeNames.has(event.name);
     },
 
     __proto__: WebInspector.TimelineModel.Filter.prototype
-}
+};
 
 /**
  * @constructor
  * @extends {WebInspector.TimelineModel.Filter}
  */
 WebInspector.ExcludeTopLevelFilter = function()
 {
     WebInspector.TimelineModel.Filter.call(this);
-}
+};
 
 WebInspector.ExcludeTopLevelFilter.prototype = {
     /**
      * @override
      * @param {!WebInspector.TracingModel.Event} event
      * @return {boolean}
      */
     accept: function(event)
     {
         return !WebInspector.TracingModel.isTopLevelEvent(event);
     },
 
     __proto__: WebInspector.TimelineModel.Filter.prototype
-}
+};
 
 /**
  * @constructor
  * @param {!WebInspector.TracingModel.Event} event
  */
 WebInspector.InvalidationTrackingEvent = function(event)
 {
     /** @type {string} */
     this.type = event.name;
     /** @type {number} */
@@ skipping 28 matching lines @@
     /** @type {?string} */
     this.extraData = eventData["extraData"];
     /** @type {?Array.<!Object.<string, number>>} */
     this.invalidationList = eventData["invalidationList"];
     /** @type {!WebInspector.InvalidationCause} */
     this.cause = {reason: eventData["reason"], stackTrace: eventData["stackTrace"]};
 
     // FIXME: Move this to TimelineUIUtils.js.
     if (!this.cause.reason && this.cause.stackTrace && this.type === WebInspector.TimelineModel.RecordType.LayoutInvalidationTracking)
         this.cause.reason = "Layout forced";
-}
+};
 
 /** @typedef {{reason: string, stackTrace: ?Array<!RuntimeAgent.CallFrame>}} */
 WebInspector.InvalidationCause;
 
 /**
  * @constructor
  */
 WebInspector.InvalidationTracker = function()
 {
     this._initializePerFrameState();
-}
+};
 
 WebInspector.InvalidationTracker.prototype = {
     /**
      * @param {!WebInspector.InvalidationTrackingEvent} invalidation
      */
     addInvalidation: function(invalidation)
     {
         this._startNewFrameIfNeeded();
 
         if (!invalidation.nodeId && !invalidation.paintId) {
@@ skipping 228 matching lines @@
     {
         /** @type {!Object.<string, !Array.<!WebInspector.InvalidationTrackingEvent>>} */
         this._invalidations = {};
         /** @type {!Object.<number, !Array.<!WebInspector.InvalidationTrackingEvent>>} */
         this._invalidationsByNodeId = {};
 
         this._lastRecalcStyle = undefined;
         this._lastPaintWithLayer = undefined;
         this._didPaint = false;
     }
-}
+};
 
 /**
  * @constructor
  */
 WebInspector.TimelineAsyncEventTracker = function()
 {
     WebInspector.TimelineAsyncEventTracker._initialize();
     /** @type {!Map<!WebInspector.TimelineModel.RecordType, !Map<string, !WebInspector.TracingModel.Event>>} */
     this._initiatorByType = new Map();
     for (var initiator of WebInspector.TimelineAsyncEventTracker._asyncEvents.keys())
         this._initiatorByType.set(initiator, new Map());
-}
+};
 
 WebInspector.TimelineAsyncEventTracker._initialize = function()
 {
     if (WebInspector.TimelineAsyncEventTracker._asyncEvents)
         return;
     var events = new Map();
     var type = WebInspector.TimelineModel.RecordType;
 
     events.set(type.TimerInstall, {causes: [type.TimerFire], joinBy: "timerId"});
     events.set(type.ResourceSendRequest, {causes: [type.ResourceReceiveResponse, type.ResourceReceivedData, type.ResourceFinish], joinBy: "requestId"});
     events.set(type.RequestAnimationFrame, {causes: [type.FireAnimationFrame], joinBy: "id"});
     events.set(type.RequestIdleCallback, {causes: [type.FireIdleCallback], joinBy: "id"});
     events.set(type.WebSocketCreate, {causes: [type.WebSocketSendHandshakeRequest, type.WebSocketReceiveHandshakeResponse, type.WebSocketDestroy], joinBy: "identifier"});
 
     WebInspector.TimelineAsyncEventTracker._asyncEvents = events;
     /** @type {!Map<!WebInspector.TimelineModel.RecordType, !WebInspector.TimelineModel.RecordType>} */
     WebInspector.TimelineAsyncEventTracker._typeToInitiator = new Map();
     for (var entry of events) {
         var types = entry[1].causes;
         for (type of types)
             WebInspector.TimelineAsyncEventTracker._typeToInitiator.set(type, entry[0]);
     }
-}
+};
 
 WebInspector.TimelineAsyncEventTracker.prototype = {
     /**
      * @param {!WebInspector.TracingModel.Event} event
      */
     processEvent: function(event)
     {
         var initiatorType = WebInspector.TimelineAsyncEventTracker._typeToInitiator.get(/** @type {!WebInspector.TimelineModel.RecordType} */ (event.name));
         var isInitiator = !initiatorType;
         if (!initiatorType)
             initiatorType = /** @type {!WebInspector.TimelineModel.RecordType} */ (event.name);
         var initiatorInfo = WebInspector.TimelineAsyncEventTracker._asyncEvents.get(initiatorType);
         if (!initiatorInfo)
             return;
         var id = event.args["data"][initiatorInfo.joinBy];
         if (!id)
             return;
         /** @type {!Map<string, !WebInspector.TracingModel.Event>|undefined} */
         var initiatorMap = this._initiatorByType.get(initiatorType);
         if (isInitiator)
             initiatorMap.set(id, event);
         else
             event.initiator = initiatorMap.get(id) || null;
     }
-}
+};