Timeline: check category presence in list, not string equality

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
  */
@@ skipping 104 matching lines @@
 {
     return WebInspector.TracingModel._flowEventsString.indexOf(phase) >= 0;
 }
 
 /**
  * @param {!WebInspector.TracingModel.Event} event
  * @return {boolean}
  */
 WebInspector.TracingModel.isTopLevelEvent = function(event)
 {
-    return event.category === WebInspector.TracingModel.TopLevelEventCategory ||
-        event.category === WebInspector.TracingModel.DevToolsMetadataEventCategory && event.name === "Program"; // Older timelines may have this instead of toplevel.
+    return event.hasCategory(WebInspector.TracingModel.TopLevelEventCategory) ||
+        event.hasCategory(WebInspector.TracingModel.DevToolsMetadataEventCategory) && event.name === "Program"; // Older timelines may have this instead of toplevel.
 }
 
 /**
  * @interface
  */
 WebInspector.BackingStorage = function()
 {
 }
 
 WebInspector.BackingStorage.prototype = {
@@ skipping 81 matching lines @@
         this._devtoolsWorkerMetadataEvents = [];
         this._backingStorage.reset();
         this._appendDelimiter = false;
         this._loadedFromFile = false;
         /** @type {!Array<!WebInspector.TracingModel.Event>} */
         this._asyncEvents = [];
         /** @type {!Map<string, !WebInspector.TracingModel.AsyncEvent>} */
         this._openAsyncEvents = new Map();
         /** @type {!Map<string, !Array<!WebInspector.TracingModel.AsyncEvent>>} */
         this._openNestableAsyncEvents = new Map();
+        /** @type {!Map<string, !Set<string>>} */
+        this._parsedCategories = new Map();
     },
 
     /**
       * @param {!WebInspector.TracingManager.EventPayload} payload
       */
     _addEvent: function(payload)
     {
         var process = this._processById[payload.pid];
         if (!process) {
-            process = new WebInspector.TracingModel.Process(payload.pid);
+            process = new WebInspector.TracingModel.Process(this, payload.pid);
             this._processById[payload.pid] = process;
         }
 
         var eventsDelimiter = ",\n";
         if (this._appendDelimiter)
             this._backingStorage.appendString(eventsDelimiter);
         this._appendDelimiter = true;
         var stringPayload = JSON.stringify(payload);
         var isAccessible = payload.ph === WebInspector.TracingModel.Phase.SnapshotObject;
         var backingStorage = null;
@@ skipping 14 matching lines @@
             var event = process._addEvent(payload);
             if (!event)
                 return;
             // Build async event when we've got events from all threads & processes, so we can sort them and process in the
             // chronological order. However, also add individual async events to the thread flow (above), so we can easily
             // display them on the same chart as other events, should we choose so.
             if (WebInspector.TracingModel.isAsyncPhase(payload.ph))
                 this._asyncEvents.push(event);
             event._setBackingStorage(backingStorage);
             if (event.name === WebInspector.TracingModel.DevToolsMetadataEvent.TracingStartedInPage &&
-                event.category === WebInspector.TracingModel.DevToolsMetadataEventCategory) {
+                event.hasCategory(WebInspector.TracingModel.DevToolsMetadataEventCategory)) {
                 this._devtoolsPageMetadataEvents.push(event);
             }
             if (event.name === WebInspector.TracingModel.DevToolsMetadataEvent.TracingSessionIdForWorker &&
-                event.category === WebInspector.TracingModel.DevToolsMetadataEventCategory) {
+                event.hasCategory(WebInspector.TracingModel.DevToolsMetadataEventCategory)) {
                 this._devtoolsWorkerMetadataEvents.push(event);
             }
             return;
         }
         switch (payload.name) {
         case WebInspector.TracingModel.MetadataEvent.ProcessSortIndex:
             process._setSortIndex(payload.args["sort_index"]);
             break;
         case WebInspector.TracingModel.MetadataEvent.ProcessName:
             var processName = payload.args["name"];
@@ skipping 128 matching lines @@
         }
         this._openNestableAsyncEvents.clear();
     },
 
     /**
      * @param {!WebInspector.TracingModel.Event} event
      */
     _addNestableAsyncEvent: function(event)
     {
         var phase = WebInspector.TracingModel.Phase;
-        var key = event.category + "." + event.id;
+        var key = event.categoriesString + "." + event.id;
         var openEventsStack = this._openNestableAsyncEvents.get(key);
 
         switch (event.phase) {
         case phase.NestableAsyncBegin:
             if (!openEventsStack) {
                 openEventsStack = [];
                 this._openNestableAsyncEvents.set(key, openEventsStack);
             }
             var asyncEvent = new WebInspector.TracingModel.AsyncEvent(event);
             openEventsStack.push(asyncEvent);
@@ skipping 16 matching lines @@
             top._addStep(event);
         }
     },
 
     /**
      * @param {!WebInspector.TracingModel.Event} event
      */
     _addAsyncEvent: function(event)
     {
         var phase = WebInspector.TracingModel.Phase;
-        var key = event.category + "." + event.name + "." + event.id;
+        var key = event.categoriesString + "." + event.name + "." + event.id;
         var asyncEvent = this._openAsyncEvents.get(key);
 
         if (event.phase === phase.AsyncBegin) {
             if (asyncEvent) {
                 console.error("Event " + event.name + " has already been started");
                 return;
             }
             asyncEvent = new WebInspector.TracingModel.AsyncEvent(event);
             this._openAsyncEvents.set(key, asyncEvent);
             event.thread._addAsyncEvent(asyncEvent);
@@ skipping 12 matching lines @@
             var lastStep = asyncEvent.steps.peekLast();
             if (lastStep.phase !== phase.AsyncBegin && lastStep.phase !== event.phase) {
                 console.assert(false, "Async event step phase mismatch: " + lastStep.phase + " at " + lastStep.startTime + " vs. " + event.phase + " at " + event.startTime);
                 return;
             }
             asyncEvent._addStep(event);
             return;
         }
         console.assert(false, "Invalid async event phase");
     },
+
+    /**
+     * @param {string} str
+     * @return {!Set<string>}
+     */
+    _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 {!WebInspector.TracingModel} tracingModel
  */
 WebInspector.TracingModel.Loader = function(tracingModel)
 {
     this._tracingModel = tracingModel;
     this._firstChunkReceived = false;
@@ skipping 15 matching lines @@
     finish: function()
     {
         this._tracingModel._loadedFromFile = true;
         this._tracingModel.tracingComplete();
     }
 }
 
 
 /**
  * @constructor
- * @param {string} category
+ * @param {string} categories
  * @param {string} name
  * @param {!WebInspector.TracingModel.Phase} phase
  * @param {number} startTime
  * @param {!WebInspector.TracingModel.Thread} thread
  */
-WebInspector.TracingModel.Event = function(category, name, phase, startTime, thread)
+WebInspector.TracingModel.Event = function(categories, name, phase, startTime, thread)
 {
     /** @type {string} */
-    this.category = category;
+    this.categoriesString = categories;
+    /** @type {!Set<string>} */
+    this._parsedCategories = thread._model._parsedCategoriesForString(categories);
     /** @type {string} */
     this.name = name;
     /** @type {!WebInspector.TracingModel.Phase} */
     this.phase = phase;
     /** @type {number} */
     this.startTime = startTime;
     /** @type {!WebInspector.TracingModel.Thread} */
     this.thread = thread;
     /** @type {!Object} */
     this.args = {};
@@ skipping 29 matching lines @@
         console.error("Missing mandatory event argument 'args' at " + payload.ts / 1000);
     if (typeof payload.dur === "number")
         event.setEndTime((payload.ts + payload.dur) / 1000);
     if (payload.id)
         event.id = payload.id;
     return event;
 }
 
 WebInspector.TracingModel.Event.prototype = {
     /**
+     * @param {string} categoryName
+     * @return {boolean}
+     */
+    hasCategory: function(categoryName)
+    {
+        return this._parsedCategories.has(categoryName);
+    },
+
+    /**
      * @param {number} endTime
      */
     setEndTime: function(endTime)
     {
         if (endTime < this.startTime) {
             console.assert(false, "Event out of order: " + this.name);
             return;
         }
         this.endTime = endTime;
         this.duration = endTime - this.startTime;
@@ skipping 143 matching lines @@
     __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.category, 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)
     {
@@ skipping 55 matching lines @@
     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(id)
+WebInspector.TracingModel.Process = function(model, id)
 {
     WebInspector.TracingModel.NamedObject.call(this);
     this._setName("Process " + id);
     this._id = id;
     /** @type {!Object.<number, !WebInspector.TracingModel.Thread>} */
     this._threads = {};
     this._threadByName = new Map();
+    this._model = model;
 }
 
 WebInspector.TracingModel.Process.prototype = {
     /**
      * @return {number}
      */
     id: function()
     {
         return this._id;
     },
@@ skipping 57 matching lines @@
  * @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 = {
     /**
      * @return {?WebInspector.Target}
      */
     target: function()
     {
         //FIXME: correctly specify target
         if (this.name() === WebInspector.TracingModel._rendererMainThreadName)
@@ skipping 11 matching lines @@
         for (var i = 0; i < this._events.length; ++i) {
             var e = this._events[i];
             e.ordinal = i;
             switch (e.phase) {
             case phases.End:
                 this._events[i] = null;  // Mark for removal.
                 // Quietly ignore unbalanced close events, they're legit (we could have missed start one).
                 if (!stack.length)
                     continue;
                 var top = stack.pop();
-                if (top.name !== e.name || top.category !== e.category)
+                if (top.name !== e.name || top.categoriesString !== e.categoriesString)
                     console.error("B/E events mismatch at " + top.startTime + " (" + top.name + ") vs. " + e.startTime + " (" + e.name + ")");
                 else
                     top._complete(e);
                 break;
             case phases.Begin:
                 stack.push(e);
                 break;
             }
         }
         this._events.remove(null, false);
@@ skipping 63 matching lines @@
     /**
      * @return {!Array.<!WebInspector.TracingModel.AsyncEvent>}
      */
     asyncEvents: function()
     {
         return this._asyncEvents;
     },
 
     __proto__: WebInspector.TracingModel.NamedObject.prototype
 }