about:gpu support for thread name metadata.

chrome/browser/resources/gpu_internals/timeline_model.js

 // Copyright (c) 2011 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.
 
 
 /**
  * @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.
@@ skipping 47 matching lines @@
    * @constructor
    */
   function TimelineThread(parent, tid) {
     this.parent = parent;
     this.tid = tid;
     this.subRows = [[]];
     this.nonNestedSubRows = [];
   }
 
   TimelineThread.prototype = {
+    name: undefined,
+
     getSubrow: function(i) {
       while (i >= this.subRows.length)
         this.subRows.push([]);
       return this.subRows[i];
     },
 
     addNonNestedSlice: function(slice) {
       for (var i = 0; i < this.nonNestedSubRows.length; i++) {
         var currSubRow = this.nonNestedSubRows[i];
         var lastSlice = currSubRow[currSubRow.length - 1];
@@ skipping 144 matching lines @@
 
             // Add the slice to the subSlices array of its parent.
             if (state.openSlices.length) {
               var parentSlice = state.openSlices[state.openSlices.length - 1];
               parentSlice.slice.subSlices.push(slice);
             }
           }
         } else if (event.ph == 'I') {
           // TODO(nduca): Implement parsing of immediate events.
           console.log('Parsing of I-type events not implemented.');
+        } else if (event.ph == 'M') {
+          if (event.name == 'thread_name') {
+            var thread = this.getProcess(event.pid).getThread(event.tid);
+            thread.name = event.args.name;
+          } else {
+            console.log('Unrecognized metadata name: ' + event.name);
+          }
         } else {
-          throw new Error('Unrecognized event phase: ' + event.ph +
+          console.log('Unrecognized event phase: ' + event.ph +

[nduca, 2011/07/26 09:46:33]

stop throwing errors and switch to logging. Unrecognized event phases aren't
catastrophic to parsing, they just aren't meaningful. This way if someone opens
a file from a newer chrome, or records a trace event that was unexpected, we
don't explode.

                           '(' + event.name + ')');
         }
       }
 
       this.updateBounds();
 
       // Add end events for any events that are still on the stack. These
       // are events that were still open when trace was ended, and can often
       // indicate deadlock behavior.
       for (var ptid in threadStateByPTID) {
@@ skipping 24 matching lines @@
       this.maxTimestamp = this.maxTimestamp + boost;
     },
 
     updateBounds: function() {
       var wmin = Infinity;
       var wmax = -wmin;
       var threads = this.getAllThreads();
       for (var tI = 0; tI < threads.length; tI++) {
         var thread = threads[tI];
         thread.updateBounds();
-        if (thread.minTimestamp && thread.maxTimestamp) {
+        if (thread.minTimestamp != undefined &&

[nduca, 2011/07/26 09:46:33]

Fix a small issue spotted by tonyg for small traces where threads that start at
exactly zero die. (because 0 is falsy)

+            thread.maxTimestamp != undefined) {
           wmin = Math.min(wmin, thread.minTimestamp);
           wmax = Math.max(wmax, thread.maxTimestamp);
         }
       }
       this.minTimestamp = wmin;
       this.maxTimestamp = wmax;
     },
 
     shiftWorldToMicroseconds: function() {
       var timeBase = this.minTimestamp;
@@ skipping 31 matching lines @@
 
   };
 
   return {
     TimelineSlice: TimelineSlice,
     TimelineThread: TimelineThread,
     TimelineProcess: TimelineProcess,
     TimelineModel: TimelineModel
   };
 });