Adds the ability to load JSON log files to about:net-internals.

chrome/browser/resources/net_internals/main.js

 // Copyright (c) 2010 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.
 
 /**
  * Dictionary of constants (initialized by browser).
  */
 var LogEventType = null;
 var LogEventPhase = null;
 var ClientInfo = null;
@@ skipping 57 matching lines @@
                             'hostResolverIPv6Disabled',
                             'hostResolverEnableIPv6',
                             'hostResolverCacheCapacity',
                             'hostResolverCacheTTLSuccess',
                             'hostResolverCacheTTLFailure');
 
   // Create a view which will display import/export options to control the
   // captured data.
   var dataView = new DataView('dataTabContent', 'exportedDataText',
                               'exportToText', 'securityStrippingCheckbox',
-                              'byteLoggingCheckbox',
-                              'passivelyCapturedCount',
-                              'activelyCapturedCount',
-                              'dataViewDeleteAll');
+                              'byteLoggingCheckbox', 'passivelyCapturedCount',
+                              'activelyCapturedCount', 'dataViewDeleteAll',
+                              'dataViewDumpDataDiv', 'dataViewLoadDataDiv',
+                              'dataViewLoadLogFile',
+                              'dataViewCapturingTextSpan',
+                              'dataViewLoggingTextSpan');
 
   // Create a view which will display the results and controls for connection
   // tests.
   var testView = new TestView('testTabContent', 'testUrlInput',
                               'connectionTestsForm', 'testSummary');
 
   var httpCacheView = new HttpCacheView('httpCacheTabContent',
                                         'httpCacheStats');
 
   var socketsView = new SocketsView('socketsTabContent',
                                     'socketPoolDiv',
                                     'socketPoolGroupsDiv');
 
   var spdyView = new SpdyView('spdyTabContent',
                               'spdySessionNoneSpan',
                               'spdySessionLinkSpan',
                               'spdySessionDiv');
 
 
   var serviceView;
   if (g_browser.isPlatformWindows()) {
     serviceView = new ServiceProvidersView('serviceProvidersTab',
                                            'serviceProvidersTabContent',
                                            'serviceProvidersTbody',
                                            'namespaceProvidersTbody');
   }
 
   // Create a view which lets you tab between the different sub-views.
   var categoryTabSwitcher = new TabSwitcherView('categoryTabHandles');
+  g_browser.setTabSwitcher(categoryTabSwitcher);
 
   // Populate the main tabs.
   categoryTabSwitcher.addTab('eventsTab', eventsView, false);
   categoryTabSwitcher.addTab('proxyTab', proxyView, false);
   categoryTabSwitcher.addTab('dnsTab', dnsView, false);
   categoryTabSwitcher.addTab('socketsTab', socketsView, false);
   categoryTabSwitcher.addTab('spdyTab', spdyView, false);
   categoryTabSwitcher.addTab('httpCacheTab', httpCacheView, false);
   categoryTabSwitcher.addTab('dataTab', dataView, false);
   if (g_browser.isPlatformWindows())
@@ skipping 16 matching lines @@
 
   // Make this category tab widget the primary view, that fills the whole page.
   var windowView = new WindowView(categoryTabSwitcher);
 
   // Trigger initial layout.
   windowView.resetGeometry();
 
   // Select the initial view based on the current URL.
   window.onhashchange();
 
+  // Inform observers a log file is not currently being displayed.
+  g_browser.setIsViewingLogFile(false);
+
   // Tell the browser that we are ready to start receiving log events.
   g_browser.sendReady();
 }
 
 /**
  * This class provides a "bridge" for communicating between the javascript and
  * the browser.
  *
  * @constructor
  */
@@ skipping 27 matching lines @@
                                this.sendGetServiceProviders.bind(this));
   }
 
   // Cache of the data received.
   this.numPassivelyCapturedEvents_ = 0;
   this.capturedEvents_ = [];
 
   // Next unique id to be assigned to a log entry without a source.
   // Needed to simplify deletion, identify associated GUI elements, etc.
   this.nextSourcelessEventId_ = -1;
+
+  // True when viewing a log file rather than actively logged events.
+  // When viewing a log file, all tabs are hidden except the event view,
+  // and all received events are ignored.
+  this.isViewingLogFile_ = false;
 }
 
 /*
  * Takes the current hash in form of "#tab&param1=value1&param2=value2&...".
  * Puts the parameters in an object, and passes the resulting object to
  * |categoryTabSwitcher|.  Uses tab and |anchorMap| to find a tab ID,
  * which it also passes to the tab switcher.
  *
  * Parameters and values are decoded with decodeURIComponent().
  */
@@ skipping 91 matching lines @@
 };
 
 BrowserBridge.prototype.enableIPv6 = function() {
   chrome.send('enableIPv6');
 };
 
 BrowserBridge.prototype.setLogLevel = function(logLevel) {
   chrome.send('setLogLevel', ['' + logLevel]);
 }
 
+BrowserBridge.prototype.loadLogFile = function(logLevel) {

[eroman, 2011/01/12 05:57:34]

the parameter here is unused.

[mmenke, 2011/01/13 03:45:29]

Oops...Removed.

+  chrome.send('loadLogFile');
+}
+
 //------------------------------------------------------------------------------
 // Messages received from the browser
 //------------------------------------------------------------------------------
 
 BrowserBridge.prototype.receivedLogEntries = function(logEntries) {
-  for (var e = 0; e < logEntries.length; ++e) {
-    var logEntry = logEntries[e];
-
-    // Assign unique ID, if needed.
-    if (logEntry.source.id == 0) {
-      logEntry.source.id = this.nextSourcelessEventId_;
-      --this.nextSourcelessEventId_;
-    }
-    this.capturedEvents_.push(logEntry);
-    for (var i = 0; i < this.logObservers_.length; ++i)
-      this.logObservers_[i].onLogEntryAdded(logEntry);
-  }
+  // Does nothing if viewing a log file.
+  if (this.isViewingLogFile_)
+    return;
+  this.addLogEntries(logEntries);
 };
 
 BrowserBridge.prototype.receivedLogEventTypeConstants = function(constantsMap) {
   LogEventType = constantsMap;
 };
 
 BrowserBridge.prototype.receivedClientInfo =
 function(info) {
   ClientInfo = info;
 };
@@ skipping 100 matching lines @@
 
 BrowserBridge.prototype.receivedCompletedConnectionTestSuite = function() {
   for (var i = 0; i < this.connectionTestsObservers_.length; ++i)
     this.connectionTestsObservers_[i].onCompletedConnectionTestSuite();
 };
 
 BrowserBridge.prototype.receivedHttpCacheInfo = function(info) {
   this.pollableDataHelpers_.httpCacheInfo.update(info);
 };
 
+BrowserBridge.prototype.loadedLogFile = function(logFileContents) {
+  var match;
+  // Replace carriage returns with linebreaks and then split around linebreaks.
+  var lines = logFileContents.replace(/\r/g, '\n').split('\n');
+  var entries = [];
+
+  for (var i = 0; i < lines.length; ++i) {
+    // Parse all valid lines, skipping any others.
+    try {
+      var entry = JSON.parse(lines[i]);
+      if (entry &&
+          typeof(entry) == 'object' &&
+          entry.phase != undefined &&
+          entry.source != undefined &&
+          entry.time != undefined &&
+          entry.type != undefined) {
+        entries.push(entry);
+      }
+    } catch (err) {
+      err = err;

[eroman, 2011/01/12 05:57:34]

is this line intended to be a no-op?

Perhaps we should console.log it in case need to debug.

[mmenke, 2011/01/13 03:45:29]

Forgot to remove that line.  Was using it as a break point while debugging.

Blank lines make us end up here.  We get blank lines at the end of the file, and
from any CRLF we split earlier.

Logging non-blank lines sounds like a reasonable idea.  Done (Logging lines that
are valid JSON but aren't valid log lines, too).

+    }
+  }
+
+  if (entries.length == 0) {
+    window.alert("Loading log file failed.");
+    return;
+  }
+
+  this.deleteAllEvents();
+
+  this.setIsViewingLogFile(true);
+
+  var validEntries = [];
+  for (var i = 0; i < entries.length; ++i) {
+    entries[i].wasPassivelyCaptured = true;

[eroman, 2011/01/12 05:57:34]

any reason to initialize this to true rather than false?

[mmenke, 2011/01/13 03:45:29]

I was just thinking the (P) emphasizes that we're not actively logging anything.
 Loading a log file seems more like getting events from the passive log than
displaying actively logged events as they come in, to me.

If you think it's better to emphasize that the events in the log files more
closely resemble active logs, or think this isn't the way to go for some other
reason, I'm happy to remove the line.  I don't have strong feelings about it,
either way.

+    entries[i].source.type = LogSourceType[entries[i].source.type]
+    entries[i].type = LogEventType[entries[i].type]
+    entries[i].phase = LogEventPhase[entries[i].phase];
+    if (entries[i].source.type != undefined &&
+        entries[i].type != undefined &&
+        entries[i].phase != undefined) {
+      // TODO(mmenke):  Do something reasonable when the event type isn't
+      //                found, which could happen when event types are
+      //                removed or added between versions.  Could also happen
+      //                with source types, but less likely.
+      validEntries.push(entries[i]);
+    }
+  }
+
+  this.numPassivelyCapturedEvents_ = validEntries.length;
+  this.addLogEntries(validEntries);
+
+  var numInvalidEntries = entries.length - validEntries.length;
+  if (numInvalidEntries > 0) {
+    window.alert(numInvalidEntries.toString() +
+      " entries could not be loaded, possibly due to version differences.");
+  }
+}
+
 //------------------------------------------------------------------------------
 
 /**
+ * Sets the |categoryTabSwitcher_| of BrowserBridge.  Since views depend on
+ * g_browser being initialized, have to have a BrowserBridge prior to tab
+ * construction.
+ */
+BrowserBridge.prototype.setTabSwitcher = function(categoryTabSwitcher) {
+  this.categoryTabSwitcher_ = categoryTabSwitcher;
+};
+
+/**
  * Adds a listener of log entries. |observer| will be called back when new log
  * data arrives, through:
  *
  *   observer.onLogEntryAdded(logEntry)
  */
 BrowserBridge.prototype.addLogObserver = function(observer) {
   this.logObservers_.push(observer);
 };
 
 /**
@@ skipping 130 matching lines @@
 
 /**
  * Returns the number of events that were captured passively by the
  * browser prior to when the net-internals page was started.
  */
 BrowserBridge.prototype.getNumPassivelyCapturedEvents = function() {
   return this.numPassivelyCapturedEvents_;
 };
 
 /**
+ * Sends each entry to all log observers, and updates |capturedEvents_|.
+ * Also assigns unique ids to log entries without a source.
+ */
+BrowserBridge.prototype.addLogEntries = function(logEntries) {
+  for (var e = 0; e < logEntries.length; ++e) {
+    var logEntry = logEntries[e];
+
+    // Assign unique ID, if needed.
+    if (logEntry.source.id == 0) {
+      logEntry.source.id = this.nextSourcelessEventId_;
+      --this.nextSourcelessEventId_;
+    }
+    this.capturedEvents_.push(logEntry);
+    for (var i = 0; i < this.logObservers_.length; ++i)
+      this.logObservers_[i].onLogEntryAdded(logEntry);
+  }
+};
+
+/**
  * Deletes captured events with source IDs in |sourceIds|.
  */
 BrowserBridge.prototype.deleteEventsBySourceId = function(sourceIds) {
   var sourceIdDict = {};
   for (var i = 0; i < sourceIds.length; i++)
     sourceIdDict[sourceIds[i]] = true;
 
   var newEventList = [];
   for (var i = 0; i < this.capturedEvents_.length; ++i) {
     var id = this.capturedEvents_[i].source.id;
@@ skipping 14 matching lines @@
  * Deletes all captured events.
  */
 BrowserBridge.prototype.deleteAllEvents = function() {
   this.capturedEvents_ = [];
   this.numPassivelyCapturedEvents_ = 0;
   for (var i = 0; i < this.logObservers_.length; ++i)
     this.logObservers_[i].onAllLogEntriesDeleted();
 };
 
 /**
- * If |force| is true, calls all startUpdate functions.  Otherwise, just
- * runs updates with active observers.
+ * Informs log observers whether or not future events will be from a log file.
+ * Hides all tabs except the events and data tabs when viewing a log file, shows
+ * them all otherwise.
+ */
+BrowserBridge.prototype.setIsViewingLogFile = function(isViewingLogFile) {
+  this.isViewingLogFile_ = isViewingLogFile;
+  var tabIds = this.categoryTabSwitcher_.getAllTabIds();
+
+  for (var i = 0; i < this.logObservers_.length; ++i)
+    this.logObservers_[i].onSetIsViewingLogFile(isViewingLogFile);
+
+  // Shows/hides tabs not used when viewing a log file.
+  for (var i = 0; i < tabIds.length; ++i) {
+    if (tabIds[i] == 'eventsTab' || tabIds[i] == 'dataTab')
+      continue;
+    this.categoryTabSwitcher_.showTabHandleNode(tabIds[i], !isViewingLogFile);
+  }
+
+  if (isViewingLogFile) {
+    var activeTab = this.categoryTabSwitcher_.findActiveTab();
+    if (activeTab.id != 'eventsTab')
+      this.categoryTabSwitcher_.switchToTab('dataTab', null);
+  }
+};
+
+/**
+ * If |force| is true, calls all startUpdate functions.  Otherwise, just runs
+ * updates with active observers.
  */
 BrowserBridge.prototype.checkForUpdatedInfo = function(force) {
   for (name in this.pollableDataHelpers_) {
     var helper = this.pollableDataHelpers_[name];
     if (force || helper.hasActiveObserver())
       helper.startUpdate();
   }
 };
 
 /**
@@ skipping 114 matching lines @@
   return true;
 };
 
 UpdateAllObserver.prototype.onDataReceived_ = function(helper, name, data) {
   helper.removeObserver(this);
   --this.observingCount_;
   this.updatedData_[name] = data;
   if (this.observingCount_ == 0)
     this.callback_(this.updatedData_);
 };