Update NetLog to be thread safe.

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 171 matching lines @@
   if (this.isPlatformWindows()) {
     this.pollableDataHelpers_.serviceProviders =
         new PollableDataHelper('onServiceProvidersChanged',
                                this.sendGetServiceProviders.bind(this));
   }
 
   // Cache of the data received.
   this.numPassivelyCapturedEvents_ = 0;
   this.capturedEvents_ = [];
 
+  // It's possible for a few actively captured events to be received before any
+  // passively captured events.  When this happens, the actively captured
+  // events aren't processed until after the passively captured events have been
+  // received.
+  this.receivedPassivelyCapturedEvents_ = false;
+  this.delayedActivelyCapturedEvents_ = [];
+
   // 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;
 }
 
 /*
  * 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.
@@ skipping 99 matching lines @@
 
 BrowserBridge.prototype.setLogLevel = function(logLevel) {
   chrome.send('setLogLevel', ['' + logLevel]);
 }
 
 //------------------------------------------------------------------------------
 // Messages received from the browser
 //------------------------------------------------------------------------------
 
 BrowserBridge.prototype.receivedLogEntry = function(logEntry) {
-  // Silently drop entries received before ready to receive them.
-  if (!this.areLogTypesReady_())
+  // Delay processing any active events received before passive events.
+  if (!this.receivedPassivelyCapturedEvents_) {

[eroman, 2010/11/18 18:04:03]

What I don't like about this approach, is we pay a cost on every entry added,
for a situation which is unlikely to happen.

Would it be possible instead to just add the logic to
receivedPassiveLogEntries()?

I reckon how that would work, is in receivedPassiveLogEntries(), we would check
the length of capturedEvents. If it is 0, then everything is peachy (and that is
the common case).

However if it is not 0, then we would swap out capturedEvents, and call the
deleteAllEvents() method to reset state.

Next we would play back the received passive events, and then play back the old
capturedEvents.

WDYT?

(I find it easier to read when the special casing code is localized at the
problem area, as opposed to in other methods).

[mmenke, 2010/11/23 16:48:45]

Don't really like the idea of starting to populate the events pane and then
clearing it.  Know it will almost never happen, but it just seems wrong...  I
can live with it, though.  Good point about the localized special case code.

+    this.delayedActivelyCapturedEvents_.push(logEntry);
     return;
+  }
   // 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);
 };
 
@@ skipping 58 matching lines @@
 BrowserBridge.prototype.receivedSpdySessionInfo = function(spdySessionInfo) {
   this.pollableDataHelpers_.spdySessionInfo.update(spdySessionInfo);
 };
 
 BrowserBridge.prototype.receivedServiceProviders = function(serviceProviders) {
   this.pollableDataHelpers_.serviceProviders.update(serviceProviders);
 };
 
 BrowserBridge.prototype.receivedPassiveLogEntries = function(entries) {
   this.numPassivelyCapturedEvents_ += entries.length;
+  this.receivedPassivelyCapturedEvents_ = true;
   for (var i = 0; i < entries.length; ++i) {
     var entry = entries[i];
     entry.wasPassivelyCaptured = true;
     this.receivedLogEntry(entry);
   }
+  // Handle delayed actively captured events, if any.
+  for (var i = 0; i < this.delayedActivelyCapturedEvents_.length; ++i) {
+    this.receivedLogEntry(this.delayedActivelyCapturedEvents_[i]);
+  }
+  this.delayedActivelyCapturedEvents_ = [];
 };
 
 
 BrowserBridge.prototype.receivedStartConnectionTestSuite = function() {
   for (var i = 0; i < this.connectionTestsObservers_.length; ++i)
     this.connectionTestsObservers_[i].onStartedConnectionTestSuite();
 };
 
 BrowserBridge.prototype.receivedStartConnectionTestExperiment = function(
     experiment) {
@@ skipping 13 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.areLogTypesReady_ = function() {
-  return (LogEventType  != null &&
-          LogEventPhase != null &&
-          LogSourceType != null);
-};
-
 //------------------------------------------------------------------------------
 
 /**
  * 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 303 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_);
 };