Add the ability to export the captured NetLog data to a formatted text file, ...

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 LogSourceType = null;
@@ skipping 39 matching lines @@
                                 "clearBadProxies");
 
   // Create a view which will display information on the host resolver.
   var dnsView = new DnsView("dnsTabContent",
                             "hostResolverCacheTbody",
                             "clearHostResolverCache",
                             "hostResolverCacheCapacity",
                             "hostResolverCacheTTLSuccess",
                             "hostResolverCacheTTLFailure");
 
+  // Create a view which will display import/export options to control the
+  // captured data.
+  var dataView = new DataView("dataTabContent", "exportToJson", "exportToText");
+
   // Create a view which lets you tab between the different sub-views.
   var categoryTabSwitcher =
       new TabSwitcherView(new DivView('categoryTabHandles'));
 
   // Populate the main tabs.
   categoryTabSwitcher.addTab('requestsTab', requestsView, false);
   categoryTabSwitcher.addTab('proxyTab', proxyView, false);
   categoryTabSwitcher.addTab('dnsTab', dnsView, false);
   categoryTabSwitcher.addTab('socketsTab', new DivView('socketsTabContent'),
                              false);
   categoryTabSwitcher.addTab('httpCacheTab',
                              new DivView('httpCacheTabContent'), false);
+  categoryTabSwitcher.addTab('dataTab', dataView, false);
 
   // Build a map from the anchor name of each tab handle to its "tab ID".
   // We will consider navigations to the #hash as a switch tab request.
   var anchorMap = {};
   var tabIds = categoryTabSwitcher.getAllTabIds();
   for (var i = 0; i < tabIds.length; ++i) {
     var aNode = document.getElementById(tabIds[i]);
     anchorMap[aNode.hash] = tabIds[i];
   }
   // Default the empty hash to the requests tab.
@@ skipping 20 matching lines @@
 
 /**
  * This class provides a "bridge" for communicating between the javascript and
  * the browser.
  *
  * @constructor
  */
 function BrowserBridge() {
   // List of observers for various bits of browser state.
   this.logObservers_ = [];
-  this.proxySettingsObservers_ = [];
-  this.badProxiesObservers_ = [];
-  this.hostResolverCacheObservers_ = [];
+  this.proxySettings_ = new PollableDataHelper('onProxySettingsChanged');
+  this.badProxies_ = new PollableDataHelper('onBadProxiesChanged');
+  this.hostResolverCache_ = new PollableDataHelper('onHostResolverCacheChanged');
 
-  // Map from observer method name (i.e. 'onProxySettingsChanged',
-  // 'onBadProxiesChanged') to the previously received data for that type. Used
-  // to tell if the data has actually changed since we last polled it.
-  this.prevPollData_ = {};
+  // Cache of the data received.
+  // TODO(eroman): the controls to clear data in the "Requests" tab should be
+  //               affecting this as well.
+  this.passivelyCapturedEvents_ = [];
+  this.activelyCapturedEvents_ = [];
 }
 
 /**
  * Delay in milliseconds between polling of certain browser information.
  */
 BrowserBridge.POLL_INTERVAL_MS = 5000;
 
 //------------------------------------------------------------------------------
 // Messages sent to the browser
 //------------------------------------------------------------------------------
@@ skipping 32 matching lines @@
 };
 
 BrowserBridge.prototype.sendClearHostResolverCache = function() {
   chrome.send('clearHostResolverCache');
 };
 
 //------------------------------------------------------------------------------
 // Messages received from the browser
 //------------------------------------------------------------------------------
 
-BrowserBridge.prototype.receivedLogEntry = function(logEntry) {
+BrowserBridge.prototype.receivedLogEntry = function(logEntry,
+                                                    wasCapturedPassively) {
+  if (!wasCapturedPassively) {
+    this.activelyCapturedEvents_.push(logEntry);
+  }
   for (var i = 0; i < this.logObservers_.length; ++i)
     this.logObservers_[i].onLogEntryAdded(logEntry);
 };
 
 BrowserBridge.prototype.receivedLogEventTypeConstants = function(constantsMap) {
   LogEventType = constantsMap;
 };
 
 BrowserBridge.prototype.receivedLogEventPhaseConstants =
 function(constantsMap) {
   LogEventPhase = constantsMap;
 };
 
 BrowserBridge.prototype.receivedLogSourceTypeConstants =
 function(constantsMap) {
   LogSourceType = constantsMap;
 };
 
 BrowserBridge.prototype.receivedTimeTickOffset = function(timeTickOffset) {
   this.timeTickOffset_ = timeTickOffset;
 };
 
 BrowserBridge.prototype.receivedProxySettings = function(proxySettings) {
-  this.dispatchToObserversFromPoll_(
-      this.proxySettingsObservers_, 'onProxySettingsChanged', proxySettings);
+  this.proxySettings_.update(proxySettings);
 };
 
 BrowserBridge.prototype.receivedBadProxies = function(badProxies) {
-  this.dispatchToObserversFromPoll_(
-      this.badProxiesObservers_, 'onBadProxiesChanged', badProxies);
+  this.badProxies_.update(badProxies);
 };
 
 BrowserBridge.prototype.receivedHostResolverCache =
 function(hostResolverCache) {
-  this.dispatchToObserversFromPoll_(
-      this.hostResolverCacheObservers_, 'onHostResolverCacheChanged',
-      hostResolverCache);
+  this.hostResolverCache_.update(hostResolverCache);
 };
 
 BrowserBridge.prototype.receivedPassiveLogEntries = function(entries) {
+  this.passivelyCapturedEvents_ =
+      this.passivelyCapturedEvents_.concat(entries);
   for (var i = 0; i < entries.length; ++i)
-    this.receivedLogEntry(entries[i]);
+    this.receivedLogEntry(entries[i], true);
 };
 
 //------------------------------------------------------------------------------
 
 /**
  * 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);
 };
 
 /**
  * Adds a listener of the proxy settings. |observer| will be called back when
  * data is received, through:
  *
  *   observer.onProxySettingsChanged(proxySettings)
  *
  * |proxySettings| is a formatted string describing the settings.
  * TODO(eroman): send a dictionary instead.
  */
 BrowserBridge.prototype.addProxySettingsObserver = function(observer) {
-  this.proxySettingsObservers_.push(observer);
+  this.proxySettings_.addObserver(observer);
 };
 
 /**
  * Adds a listener of the proxy settings. |observer| will be called back when
  * data is received, through:
  *
  *   observer.onBadProxiesChanged(badProxies)
  *
  * |badProxies| is an array, where each entry has the property:
  *   badProxies[i].proxy_uri: String identify the proxy.
  *   badProxies[i].bad_until: The time when the proxy stops being considered
  *                            bad. Note the time is in time ticks.
  */
 BrowserBridge.prototype.addBadProxiesObsever = function(observer) {
-  this.badProxiesObservers_.push(observer);
+  this.badProxies_.addObserver(observer);
 };
 
 /**
  * Adds a listener of the host resolver cache. |observer| will be called back
  * when data is received, through:
  *
  *   observer.onHostResolverCacheChanged(hostResolverCache)
  */
 BrowserBridge.prototype.addHostResolverCacheObserver = function(observer) {
-  this.hostResolverCacheObservers_.push(observer);
+  this.hostResolverCache_.addObserver(observer);
 };
 
 /**
  * The browser gives us times in terms of "time ticks" in milliseconds.
  * This function converts the tick count to a Date() object.
  *
  * @param {String} timeTicks.
  * @returns {Date} The time that |timeTicks| represents.
  */
 BrowserBridge.prototype.convertTimeTicksToDate = function(timeTicks) {
   // Note that the subtraction by 0 is to cast to a number (probably a float
   // since the numbers are big).
   var timeStampMs = (this.timeTickOffset_ - 0) + (timeTicks - 0);
   var d = new Date();
   d.setTime(timeStampMs);
   return d;
 };
 
+/**
+ * Returns a list of all the events that were captured while we were
+ * listening for events.
+ */
+BrowserBridge.prototype.getAllActivelyCapturedEvents = function() {
+  return this.activelyCapturedEvents_;
+};
+
+/**
+ * Returns a list of all the events that were captured passively by the
+ * browser prior to when the net-internals page was started.
+ */
+BrowserBridge.prototype.getAllPassivelyCapturedEvents = function() {
+  return this.passivelyCapturedEvents_;
+};
+
 BrowserBridge.prototype.doPolling_ = function() {
   // TODO(eroman): Optimize this by using a separate polling frequency for the
   // data consumed by the currently active view. Everything else can be on a low
   // frequency poll since it won't impact the display.
   this.sendGetProxySettings();
   this.sendGetBadProxies();
   this.sendGetHostResolverCache();
 };
 
 /**
+ * This is a helper class used by BrowserBridge, to keep track of:
+ *   - the list of observers interested in some piece of data.
+ *   - the last known value of that piece of data.
+ *   - the name of the callback method to invoke on observers.
+ * @constructor
+ */
+function PollableDataHelper(observerMethodName) {
+  this.observerMethodName_ = observerMethodName;
+  this.observers_ = [];
+}
+
+PollableDataHelper.prototype.addObserver = function(observer) {
+  this.observers_.push(observer);
+};
+
+/**
  * Helper function to handle calling all the observers, but ONLY if the data has
  * actually changed since last time. This is used for data we received from
  * browser on a poll loop.
  */
-BrowserBridge.prototype.dispatchToObserversFromPoll_ = function(
-    observerList, method, data) {
-  var prevData = this.prevPollData_[method];
+PollableDataHelper.prototype.update = function(data) {
+  var prevData = this.currentData_;
 
   // If the data hasn't changed since last time, no need to notify observers.
   if (prevData && JSON.stringify(prevData) == JSON.stringify(data))
     return;
 
-  this.prevPollData_[method] = data;
+  this.currentData_ = data;
 
   // Ok, notify the observers of the change.
-  for (var i = 0; i < observerList.length; ++i)
-    observerList[i][method](data);
+  for (var i = 0; i < this.observers_.length; ++i)
+    var observer = this.observers_[i];
+    observer[this.observerMethodName_](data);
 };