Add a timeline view to about:net-internals.

chrome/browser/resources/net_internals/source_tracker.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.
 
 var SourceTracker = (function() {
   'use strict';
 
   /**
    * This class keeps track of all NetLog events.
    * It receives events from the browser and when loading a log file, and passes
    * them on to all its observers.
    *
    * @constructor
    */
   function SourceTracker() {
-    this.observers_ = [];
+    // Observers that are sent all events as they happen.  This allows for easy
+    // watching for particular events.
+    this.logEntryObservers_ = [];
+
+    // Observers that only want to receive lists of updated SourceEntries.
+    this.sourceEntryObservers_ = [];
 
     // True when cookies and authentication information should be removed from
     // displayed events.  When true, such information should be hidden from
     // all pages.
     this.enableSecurityStripping_ = true;
 
     this.clearEntries_();
   }
 
   SourceTracker.prototype = {
@@ skipping 81 matching lines @@
         logEntries[i].wasPassivelyCaptured = true;
 
       this.onReceivedLogEntries(logEntries);
 
       // Add back early actively captured events, if any.
       if (earlyActivelyCapturedEvents.length)
         this.onReceivedLogEntries(earlyActivelyCapturedEvents);
     },
 
     /**
-     * Sends each entry to all log observers, and updates |capturedEvents_|.
+     * Sends each entry to all observers and updates |capturedEvents_|.
      * Also assigns unique ids to log entries without a source.
      */
     onReceivedLogEntries: function(logEntries) {
       // List source entries with new log entries.  Sorted chronologically, by
       // first new log entry.
       var updatedSourceEntries = [];
 
       var updatedSourceEntryIdMap = {};
 
       for (var e = 0; e < logEntries.length; ++e) {
@@ skipping 17 matching lines @@
         }
 
         // Add to updated SourceEntry list, if not already in it.
         if (!updatedSourceEntryIdMap[logEntry.source.id]) {
           updatedSourceEntryIdMap[logEntry.source.id] = sourceEntry;
           updatedSourceEntries.push(sourceEntry);
         }
       }
 
       this.capturedEvents_ = this.capturedEvents_.concat(logEntries);
-      for (var i = 0; i < this.observers_.length; ++i)
-        this.observers_[i].onSourceEntriesUpdated(updatedSourceEntries);
+      for (var i = 0; i < this.sourceEntryObservers_.length; ++i) {
+        this.sourceEntryObservers_[i].onSourceEntriesUpdated(
+            updatedSourceEntries);
+      }
+      for (var i = 0; i < this.logEntryObservers_.length; ++i)
+        this.logEntryObservers_[i].onReceivedLogEntries(logEntries);
     },
 
     /**
      * Deletes captured events with source IDs in |sourceEntryIds|.
      */
     deleteSourceEntries: function(sourceEntryIds) {
       var sourceIdDict = {};
       for (var i = 0; i < sourceEntryIds.length; i++) {
         sourceIdDict[sourceEntryIds[i]] = true;
         delete this.sourceEntries_[sourceEntryIds[i]];
       }
 
       var newEventList = [];
       for (var i = 0; i < this.capturedEvents_.length; ++i) {
         var id = this.capturedEvents_[i].source.id;
         if (id in sourceIdDict) {
           if (this.capturedEvents_[i].wasPassivelyCaptured)
             --this.numPassivelyCapturedEvents_;
           continue;
         }
         newEventList.push(this.capturedEvents_[i]);
       }
       this.capturedEvents_ = newEventList;
 
-      for (var i = 0; i < this.observers_.length; ++i)
-        this.observers_[i].onSourceEntriesDeleted(sourceEntryIds);
+      for (var i = 0; i < this.sourceEntryObservers_.length; ++i)
+        this.sourceEntryObservers_[i].onSourceEntriesDeleted(sourceEntryIds);
     },
 
     /**
      * Deletes all captured events.
      */
     deleteAllSourceEntries: function() {
       this.clearEntries_();
-      for (var i = 0; i < this.observers_.length; ++i)
-        this.observers_[i].onAllSourceEntriesDeleted();
+      for (var i = 0; i < this.sourceEntryObservers_.length; ++i)
+        this.sourceEntryObservers_[i].onAllSourceEntriesDeleted();
+      for (var i = 0; i < this.logEntryObservers_.length; ++i)
+        this.logEntryObservers_[i].onAllLogEntriesDeleted();
     },
 
     /**
      * Sets the value of |enableSecurityStripping_| and informs log observers
      * of the change.
      */
     setSecurityStripping: function(enableSecurityStripping) {
       this.enableSecurityStripping_ = enableSecurityStripping;
-      for (var i = 0; i < this.observers_.length; ++i) {
-        if (this.observers_[i].onSecurityStrippingChanged)
-          this.observers_[i].onSecurityStrippingChanged();
+      for (var i = 0; i < this.sourceEntryObservers_.length; ++i) {
+        if (this.sourceEntryObservers_[i].onSecurityStrippingChanged)
+          this.sourceEntryObservers_[i].onSecurityStrippingChanged();
       }
     },
 
     /**
      * Returns whether or not cookies and authentication information should be
      * displayed for events that contain them.
      */
     getSecurityStripping: function() {
       return this.enableSecurityStripping_;
     },
 
     /**
+     * Adds a listener of SourceEntries. |observer| will be called back when
+     * SourceEntries are added or modified, source entries are deleted, or
+     * security stripping changes through:

[eroman, 2011/11/16 04:03:46]

nit: "through" seems unnecessary, can probably remove it.

[mmenke, 2011/11/16 18:39:35]

Done.

+     *
+     *   observer.onSourceEntriesUpdated(sourceEntries)
+     *   observer.onSourceEntriesDeleted(sourceEntryIds)
+     *   ovserver.onAllSourceEntriesDeleted()
+     *   observer.onSecurityStrippingChanged()
+     */
+    addSourceEntryObserver: function(observer) {
+      this.sourceEntryObservers_.push(observer);
+    },
+
+    /**
      * Adds a listener of log entries. |observer| will be called back when new
-     * log data arrives, source entries are deleted, or security stripping
-     * changes through:
+     * log data arrives or all entries are deleted through:
      *
-     *   observer.onSourceEntriesUpdated(sourceEntries)
-     *   observer.deleteSourceEntries(sourceEntryIds)
-     *   ovserver.deleteAllSourceEntries()
-     *   observer.onSecurityStrippingChanged()
+     *   observer.onReceivedLogEntries(entries)
+     *   ovserver.onAllLogEntriesDeleted()
      */
-    addObserver: function(observer) {
-      this.observers_.push(observer);
+    addLogEntryObserver: function(observer) {
+      this.logEntryObservers_.push(observer);
     }
   };
 
   return SourceTracker;
 })();