Find feature for tracing, at long last.

chrome/browser/resources/tracing/timeline_model.js

 // Copyright (c) 2012 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.
 
+'use strict';
 
 /**
  * @fileoverview TimelineModel is a parsed representation of the
  * TraceEvents obtained from base/trace_event in which the begin-end
  * tokens are converted into a hierarchy of processes, threads,
  * subrows, and slices.
  *
  * The building block of the model is a slice. A slice is roughly
  * equivalent to function call executing on a specific thread. As a
  * result, slices may have one or more subslices.
@@ skipping 190 matching lines @@
     },
 
     /**
      * @return {String} User friendly details about this thread.
      */
     get userFriendlyDetails() {
       return 'pid: ' + this.parent.pid +
           ', tid: ' + this.tid +
           (this.name ? ', name: ' + this.name : '');
     }
-
   };
 
   /**
    * Comparison between threads that orders first by pid,
    * then by names, then by tid.
    */
   TimelineThread.compare = function(x, y) {
     if (x.parent.pid != y.parent.pid) {
       return TimelineProcess.compare(x.parent, y.parent.pid);
     }
@@ skipping 346 matching lines @@
         subGroupsByPTID[slicePTID].slices.push(slice);
       }
       var groups = [];
       for (var ptid in subGroupsByPTID) {
         var group = subGroupsByPTID[ptid];
         group.updateBounds();
         groups.push(group);
       }
       return groups;
     }
-
   };
 
   /**
    * Comparison between counters that orders by pid, then name.
    */
   TimelineCounter.compare = function(x, y) {
     if (x.parent.pid != y.parent.pid) {
       return TimelineProcess.compare(x.parent, y.parent.pid);
     }
     var tmp = x.name.localeCompare(y.name);
@@ skipping 406 matching lines @@
      *     by 15%. Defaults to true.
      * @param {Array=} opt_additionalEventData An array of eventData objects
      *     (e.g. array of arrays) to
      * import after importing the primary events.
      */
     importEvents: function(eventData,
                            opt_zeroAndBoost, opt_additionalEventData) {
       if (opt_zeroAndBoost === undefined)
         opt_zeroAndBoost = true;
 
-      activeImporters = [];
+      var activeImporters = [];
       var importer = this.importOneTrace_(eventData, false);
       activeImporters.push(importer);
       if (opt_additionalEventData) {
         for (var i = 0; i < opt_additionalEventData.length; ++i) {
           importer = this.importOneTrace_(opt_additionalEventData[i], true);
           activeImporters.push(importer);
         }
       }
       for (var i = 0; i < activeImporters.length; ++i)
         activeImporters[i].finalizeImport();
 
       for (var i = 0; i < activeImporters.length; ++i)
         this.pruneEmptyThreads();
 
       this.updateBounds();
 
       if (opt_zeroAndBoost)
         this.shiftWorldToZero();
 
       if (opt_zeroAndBoost &&
           this.minTimestamp !== undefined &&
           this.maxTimestamp !== undefined) {
         var boost = (this.maxTimestamp - this.minTimestamp) * 0.15;
         this.minTimestamp = this.minTimestamp - boost;
         this.maxTimestamp = this.maxTimestamp + boost;
       }
     }
   };
 
+  /**
+   * @constructor A filter that can be passed into
+   * Timeline.findAllObjectsMatchingFilter
+   */
+  function TimelineFilter(text) {
+    this.text_ = text;
+  }
+  TimelineFilter.prototype = {
+    __proto__: Object.prototype,
+
+    matchSlice: function(slice) {
+      if (this.text_.length == 0)
+        return false;
+      return slice.title.indexOf(this.text_) != -1;
+    }
+
+  };
+
   return {
     getPallette: getPallette,
     getPalletteHighlightIdBoost: getPalletteHighlightIdBoost,
     getColorIdByName: getColorIdByName,
     getStringHash: getStringHash,
     getStringColorId: getStringColorId,
 
     TimelineSlice: TimelineSlice,
     TimelineThreadSlice: TimelineThreadSlice,
     TimelineAsyncSlice: TimelineAsyncSlice,
     TimelineThread: TimelineThread,
     TimelineCounter: TimelineCounter,
     TimelineProcess: TimelineProcess,
     TimelineCpu: TimelineCpu,
     TimelineAsyncSliceGroup: TimelineAsyncSliceGroup,
-    TimelineModel: TimelineModel
+    TimelineModel: TimelineModel,
+    TimelineFilter: TimelineFilter
   };
 
 });