13 files changed, 386 insertions, 171 deletions

diff --git a/chrome/browser/net/chrome_net_log.cc b/chrome/browser/net/chrome_net_log.cc
index b6ef86e..6cfc893 100644
--- a/chrome/browser/net/chrome_net_log.cc
+++ b/chrome/browser/net/chrome_net_log.cc
@@ -9,27 +9,59 @@
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/string_util.h"
-#include "chrome/browser/browser_thread.h"
+#include "base/values.h"
 #include "chrome/browser/net/load_timing_observer.h"
 #include "chrome/browser/net/net_log_logger.h"
 #include "chrome/browser/net/passive_log_collector.h"
 #include "chrome/common/chrome_switches.h"
 
-ChromeNetLog::Observer::Observer(LogLevel log_level) : log_level_(log_level) {}
+ChromeNetLog::ThreadSafeObserver::ThreadSafeObserver(LogLevel log_level)
+    : net_log_(NULL),
+      log_level_(log_level) {
+}
+
+ChromeNetLog::ThreadSafeObserver::~ThreadSafeObserver() {
+  DCHECK(!net_log_);
+}
 
-net::NetLog::LogLevel ChromeNetLog::Observer::log_level() const {
+net::NetLog::LogLevel ChromeNetLog::ThreadSafeObserver::log_level() const {
   return log_level_;
 }
 
-void ChromeNetLog::Observer::set_log_level(net::NetLog::LogLevel log_level) {
+void ChromeNetLog::ThreadSafeObserver::AssertNetLogLockAcquired() const {
+  if (net_log_)
+    net_log_->lock_.AssertAcquired();
+}
+
+void ChromeNetLog::ThreadSafeObserver::SetLogLevel(
+    net::NetLog::LogLevel log_level) {
+  DCHECK(net_log_);
+  AutoLock lock(net_log_->lock_);
   log_level_ = log_level;
+  net_log_->UpdateLogLevel_();
+}
+
+ChromeNetLog::Entry::Entry(uint32 order,
+                           net::NetLog::EventType type,
+                           const base::TimeTicks& time,
+                           net::NetLog::Source source,
+                           net::NetLog::EventPhase phase,
+                           net::NetLog::EventParameters* params)
+    : order(order),
+      type(type),
+      time(time),
+      source(source),
+      phase(phase),
+      params(params) {
 }
 
+ChromeNetLog::Entry::~Entry() {}
+
 ChromeNetLog::ChromeNetLog()
-    : next_id_(1),
+    : last_id_(0),
+      log_level_(LOG_BASIC),
       passive_collector_(new PassiveLogCollector),
       load_timing_observer_(new LoadTimingObserver) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   AddObserver(passive_collector_.get());
   AddObserver(load_timing_observer_.get());
 
@@ -41,7 +73,6 @@ ChromeNetLog::ChromeNetLog()
 }
 
 ChromeNetLog::~ChromeNetLog() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   RemoveObserver(passive_collector_.get());
   RemoveObserver(load_timing_observer_.get());
   if (net_log_logger_.get()) {
@@ -54,42 +85,69 @@ void ChromeNetLog::AddEntry(EventType type,
                             const Source& source,
                             EventPhase phase,
                             EventParameters* params) {
-  // This must be invoked when we're on the IO thread, or if the IO thread's
-  // message loop isn't valid. The later can happen if this is invoked when the
-  // IOThread is shuting down the MessageLoop.
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO) ||
-         !BrowserThread::IsMessageLoopValid(BrowserThread::IO));
+  AutoLock lock(lock_);
 
   // Notify all of the log observers.
-  FOR_EACH_OBSERVER(Observer, observers_,
+  FOR_EACH_OBSERVER(ThreadSafeObserver, observers_,
                     OnAddEntry(type, time, source, phase, params));
 }
 
 uint32 ChromeNetLog::NextID() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  return next_id_++;
+  return base::subtle::NoBarrier_AtomicIncrement(&last_id_, 1);
 }
 
 net::NetLog::LogLevel ChromeNetLog::GetLogLevel() const {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  base::subtle::Atomic32 log_level = base::subtle::NoBarrier_Load(&log_level_);
+  return static_cast<net::NetLog::LogLevel>(log_level);
+}
+
+void ChromeNetLog::AddObserver(ThreadSafeObserver* observer) {
+  AutoLock lock(lock_);
+  AddObserverWhileLockHeld(observer);
+}
+
+void ChromeNetLog::RemoveObserver(ThreadSafeObserver* observer) {
+  AutoLock lock(lock_);
+  DCHECK_EQ(observer->net_log_, this);
+  observer->net_log_ = NULL;
+  observers_.RemoveObserver(observer);
+  UpdateLogLevel_();
+}
+
+void ChromeNetLog::AddObserverAndGetAllPassivelyCapturedEvents(
+    ThreadSafeObserver* observer, EntryList* passive_entries) {
+  AutoLock lock(lock_);
+  AddObserverWhileLockHeld(observer);
+  passive_collector_->GetAllCapturedEvents(passive_entries);
+}
+
+void ChromeNetLog::GetAllPassivelyCapturedEvents(EntryList* passive_entries) {
+  AutoLock lock(lock_);
+  passive_collector_->GetAllCapturedEvents(passive_entries);
+}
+
+void ChromeNetLog::ClearAllPassivelyCapturedEvents() {
+  AutoLock lock(lock_);
+  passive_collector_->Clear();
+}
+
+void ChromeNetLog::UpdateLogLevel_() {
+  lock_.AssertAcquired();
 
   // Look through all the observers and find the finest granularity
   // log level (higher values of the enum imply *lower* log levels).
-  LogLevel log_level = LOG_BASIC;
-  ObserverListBase<Observer>::Iterator it(observers_);
-  Observer* observer;
+  LogLevel new_log_level = LOG_BASIC;
+  ObserverListBase<ThreadSafeObserver>::Iterator it(observers_);
+  ThreadSafeObserver* observer;
   while ((observer = it.GetNext()) != NULL) {
-    log_level = std::min(log_level, observer->log_level());
+    new_log_level = std::min(new_log_level, observer->log_level());
   }
-  return log_level;
+  base::subtle::NoBarrier_Store(&log_level_, new_log_level);
 }
 
-void ChromeNetLog::AddObserver(Observer* observer) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+void ChromeNetLog::AddObserverWhileLockHeld(ThreadSafeObserver* observer) {
+  DCHECK(!observer->net_log_);
+  observer->net_log_ = this;
   observers_.AddObserver(observer);
-}
-
-void ChromeNetLog::RemoveObserver(Observer* observer) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  observers_.RemoveObserver(observer);
+  UpdateLogLevel_();
 }
diff --git a/chrome/browser/net/chrome_net_log.h b/chrome/browser/net/chrome_net_log.h
index aac09e6..f6a5c20 100644
--- a/chrome/browser/net/chrome_net_log.h
+++ b/chrome/browser/net/chrome_net_log.h
@@ -6,8 +6,13 @@
 #define CHROME_BROWSER_NET_CHROME_NET_LOG_H_
 #pragma once
 
+#include <vector>
+
+#include "base/atomicops.h"
+#include "base/lock.h"
 #include "base/observer_list.h"
 #include "base/scoped_ptr.h"
+#include "chrome/browser/browser_thread.h"
 #include "net/base/net_log.h"
 
 class LoadTimingObserver;
@@ -17,39 +22,85 @@ class PassiveLogCollector;
 // ChromeNetLog is an implementation of NetLog that dispatches network log
 // messages to a list of observers.
 //
+// All methods are thread safe, with the exception that no ChromeNetLog or
+// ChromeNetLog::ThreadSafeObserver functions may be called by an observer's
+// OnAddEntry() method.  Doing so will result in a deadlock.
+//
 // By default, ChromeNetLog will attach the observer PassiveLogCollector which
 // will keep track of recent request information (which used when displaying
 // the about:net-internals page).
 //
-// TODO(eroman): Move this default observer out of ChromeNetLog.
-//
 class ChromeNetLog : public net::NetLog {
  public:
+  // This structure encapsulates all of the parameters of an event,
+  // including an "order" field that identifies when it was captured relative
+  // to other events.
+  struct Entry {
+    Entry(uint32 order,
+          net::NetLog::EventType type,
+          const base::TimeTicks& time,
+          net::NetLog::Source source,
+          net::NetLog::EventPhase phase,
+          net::NetLog::EventParameters* params);
+    ~Entry();
+
+    uint32 order;
+    net::NetLog::EventType type;
+    base::TimeTicks time;
+    net::NetLog::Source source;
+    net::NetLog::EventPhase phase;
+    scoped_refptr<net::NetLog::EventParameters> params;
+  };
+
+  typedef std::vector<Entry> EntryList;
+
   // Interface for observing the events logged by the network stack.
-  class Observer {
+  class ThreadSafeObserver {
    public:
     // Constructs an observer that wants to see network events, with
-    // the specified minimum event granularity.
+    // the specified minimum event granularity.  A ThreadSafeObserver can only
+    // observe a single ChromeNetLog at a time.
     //
     // Typical observers should specify LOG_BASIC.
     //
     // Observers that need to see the full granularity of events can
     // specify LOG_ALL. However doing so will have performance consequences,
-    // and may cause PassiveLogCollector to use more memory than anticiapted.
-    explicit Observer(LogLevel log_level);
+    // and may cause PassiveLogCollector to use more memory than anticipated.
+    //
+    // Observers will be called on the same thread an entry is added on,
+    // and are responsible for ensuring their own thread safety.
+    explicit ThreadSafeObserver(LogLevel log_level);
+
+    virtual ~ThreadSafeObserver();
 
-    virtual ~Observer() {}
+    // This method will be called on the thread that the event occurs on.  It
+    // is the responsibility of the observer to handle it in a thread safe
+    // manner.
+    //
+    // It is illegal for an Observer to call any ChromeNetLog or
+    // ChromeNetLog::ThreadSafeObserver functions in response to a call to
+    // OnAddEntry.
     virtual void OnAddEntry(EventType type,
                             const base::TimeTicks& time,
                             const Source& source,
                             EventPhase phase,
                             EventParameters* params) = 0;
     LogLevel log_level() const;
+
    protected:
-    void set_log_level(LogLevel log_level);
+    void AssertNetLogLockAcquired() const;
+
+    // Can only be called when actively observing a ChromeNetLog.
+    void SetLogLevel(LogLevel log_level);
+
+    // ChromeNetLog currently being observed, if any.  Set by ChromeNetLog's
+    // AddObserver and RemoveObserver methods.
+    ChromeNetLog* net_log_;
+
    private:
+    friend class ChromeNetLog;
     LogLevel log_level_;
-    DISALLOW_COPY_AND_ASSIGN(Observer);
+    DISALLOW_COPY_AND_ASSIGN(ThreadSafeObserver);
   };
 
   ChromeNetLog();
@@ -64,26 +115,48 @@ class ChromeNetLog : public net::NetLog {
   virtual uint32 NextID();
   virtual LogLevel GetLogLevel() const;
 
-  void AddObserver(Observer* observer);
-  void RemoveObserver(Observer* observer);
+  void AddObserver(ThreadSafeObserver* observer);
+  void RemoveObserver(ThreadSafeObserver* observer);
 
-  PassiveLogCollector* passive_collector() {
-    return passive_collector_.get();
-  }
+  // Adds |observer| and writes all passively captured events to
+  // |passive_entries|. Guarantees that no events in |passive_entries| will be
+  // sent to |observer| and all future events that have yet been sent to the
+  // PassiveLogCollector will be sent to |observer|.
+  void AddObserverAndGetAllPassivelyCapturedEvents(ThreadSafeObserver* observer,
+                                                   EntryList* passive_entries);
+
+  void GetAllPassivelyCapturedEvents(EntryList* passive_entries);
+
+  void ClearAllPassivelyCapturedEvents();
 
   LoadTimingObserver* load_timing_observer() {
     return load_timing_observer_.get();
   }
 
  private:
-  uint32 next_id_;
+  void AddObserverWhileLockHeld(ThreadSafeObserver* observer);
+
+  // Called whenever an observer is added or removed, or changes its log level.
+  // Must have acquired |lock_| prior to calling.
+  void UpdateLogLevel_();
+
+  // |lock_| protects access to |observers_| and, indirectly, to
+  // |passive_collector_|.  Should not be acquired by observers.
+  Lock lock_;
+
+  // Last assigned source ID.  Incremented to get the next one.
+  base::subtle::Atomic32 last_id_;
+
+  base::subtle::Atomic32 log_level_;
+
+  // Not thread safe.  Must only be used when |lock_| is acquired.
   scoped_ptr<PassiveLogCollector> passive_collector_;
+
   scoped_ptr<LoadTimingObserver> load_timing_observer_;
   scoped_ptr<NetLogLogger> net_log_logger_;
 
-  // Note that this needs to be "mutable" so we can iterate over the observer
-  // list in GetLogLevel().
-  mutable ObserverList<Observer, true> observers_;
+  // |lock_| must be acquired whenever reading or writing to this.
+  ObserverList<ThreadSafeObserver, true> observers_;
 
   DISALLOW_COPY_AND_ASSIGN(ChromeNetLog);
 };
diff --git a/chrome/browser/net/chrome_net_log_unittest.cc b/chrome/browser/net/chrome_net_log_unittest.cc
new file mode 100644
index 0000000..7bd9301
--- /dev/null
+++ b/chrome/browser/net/chrome_net_log_unittest.cc
@@ -0,0 +1,73 @@
+// 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.
+
+#include "chrome/browser/net/chrome_net_log.h"
+
+#include "base/waitable_event.h"
+#include "base/simple_thread.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace {
+
+const int kThreads = 10;
+const int kEvents = 100;
+
+class ChromeNetLogTestThread : public base::SimpleThread {
+ public:
+  ChromeNetLogTestThread() : base::SimpleThread("ChromeNetLogTest"),
+                             can_start_loop_(false, false),
+                             log_(NULL) {
+  }
+
+  void Init(ChromeNetLog* log) {
+    log_ = log;
+  }
+
+  virtual void Run() {
+    can_start_loop_.Wait();
+    for (int i = 0; i < kEvents; ++i) {
+      net::NetLog::Source source(net::NetLog::SOURCE_SOCKET, log_->NextID());
+      log_->AddEntry(net::NetLog::TYPE_SOCKET_ALIVE, base::TimeTicks(),
+                     source, net::NetLog::PHASE_BEGIN, NULL);
+    }
+    log_->ClearAllPassivelyCapturedEvents();
+  }
+
+  void ReallyStart() {
+    can_start_loop_.Signal();
+  }
+
+ private:
+  // Only triggered once all threads have been created, to make it much less
+  // likely each thread completes before the next one starts.
+  base::WaitableEvent can_start_loop_;
+
+  ChromeNetLog* log_;
+
+  DISALLOW_COPY_AND_ASSIGN(ChromeNetLogTestThread);
+};
+
+}  // namespace
+
+// Attempts to check thread safety, exercising checks in ChromeNetLog and
+// PassiveLogCollector.
+TEST(ChromeNetLogTest, NetLogThreads) {
+  ChromeNetLog log;
+  ChromeNetLogTestThread threads[kThreads];
+
+  for (int i = 0; i < kThreads; ++i) {
+    threads[i].Init(&log);
+    threads[i].Start();
+  }
+
+  for (int i = 0; i < kThreads; ++i)
+    threads[i].ReallyStart();
+
+  for (int i = 0; i < kThreads; ++i)
+    threads[i].Join();
+
+  ChromeNetLog::EntryList entries;
+  log.GetAllPassivelyCapturedEvents(&entries);
+  EXPECT_EQ(0u, entries.size());
+}
diff --git a/chrome/browser/net/chrome_url_request_context.cc b/chrome/browser/net/chrome_url_request_context.cc
index 81a0402..f153162 100644
--- a/chrome/browser/net/chrome_url_request_context.cc
+++ b/chrome/browser/net/chrome_url_request_context.cc
@@ -273,7 +273,7 @@ ChromeURLRequestContext* FactoryForOriginal::Create() {
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
 
   context->set_proxy_service(
-      CreateProxyService(io_thread_globals->net_log.get(),
+      CreateProxyService(io_thread()->net_log(),
                          context,
                          proxy_config_service_.release(),
                          command_line,
@@ -290,7 +290,7 @@ ChromeURLRequestContext* FactoryForOriginal::Create() {
                          context->ssl_config_service(),
                          context->http_auth_handler_factory(),
                          &io_thread_globals->network_delegate,
-                         io_thread_globals->net_log.get(),
+                         io_thread()->net_log(),
                          backend);
 
   bool record_mode = chrome::kRecordModeEnabled &&
@@ -324,7 +324,7 @@ ChromeURLRequestContext* FactoryForOriginal::Create() {
 
   appcache_service_->set_request_context(context);
 
-  context->set_net_log(io_thread_globals->net_log.get());
+  context->set_net_log(io_thread()->net_log());
   return context;
 }
 
@@ -417,7 +417,7 @@ ChromeURLRequestContext* FactoryForOffTheRecord::Create() {
                          context->ssl_config_service(),
                          context->http_auth_handler_factory(),
                          &io_thread_globals->network_delegate,
-                         io_thread_globals->net_log.get(),
+                         io_thread()->net_log(),
                          backend);
   context->set_cookie_store(new net::CookieMonster(NULL,
       cookie_monster_delegate_));
@@ -430,7 +430,7 @@ ChromeURLRequestContext* FactoryForOffTheRecord::Create() {
 
   appcache_service_->set_request_context(context);
 
-  context->set_net_log(io_thread_globals->net_log.get());
+  context->set_net_log(io_thread()->net_log());
   return context;
 }
 
@@ -510,12 +510,12 @@ ChromeURLRequestContext* FactoryForMedia::Create() {
                                main_context->ssl_config_service(),
                                main_context->http_auth_handler_factory(),
                                &io_thread_globals->network_delegate,
-                               io_thread_globals->net_log.get(),
+                               io_thread()->net_log(),
                                backend);
   }
 
   context->set_http_transaction_factory(cache);
-  context->set_net_log(io_thread_globals->net_log.get());
+  context->set_net_log(io_thread()->net_log());
 
   return context;
 }
diff --git a/chrome/browser/net/connection_tester_unittest.cc b/chrome/browser/net/connection_tester_unittest.cc
index 5bab81e..409c676 100644
--- a/chrome/browser/net/connection_tester_unittest.cc
+++ b/chrome/browser/net/connection_tester_unittest.cc
@@ -78,7 +78,7 @@ class ConnectionTesterTest : public PlatformTest {
             FilePath(FILE_PATH_LITERAL("net/data/url_request_unittest"))),
         message_loop_(MessageLoop::TYPE_IO),
         pref_service(new TestingPrefService()),
-        io_thread_(pref_service.get()) {
+        io_thread_(pref_service.get(), NULL) {
     scoped_refptr<net::RuleBasedHostResolverProc> catchall_resolver(
         new net::RuleBasedHostResolverProc(NULL));
 
diff --git a/chrome/browser/net/load_timing_observer.cc b/chrome/browser/net/load_timing_observer.cc
index f5b27d5..7d2571c 100644
--- a/chrome/browser/net/load_timing_observer.cc
+++ b/chrome/browser/net/load_timing_observer.cc
@@ -44,7 +44,7 @@ static int32 TimeTicksToOffset(
       (time_ticks - record->base_ticks).InMillisecondsRoundedUp());
 }
 
-}
+}  // namespace
 
 LoadTimingObserver::URLRequestRecord::URLRequestRecord()
     : connect_job_id(net::NetLog::Source::kInvalidId),
@@ -53,7 +53,7 @@ LoadTimingObserver::URLRequestRecord::URLRequestRecord()
 }
 
 LoadTimingObserver::LoadTimingObserver()
-    : Observer(net::NetLog::LOG_BASIC),
+    : ThreadSafeObserver(net::NetLog::LOG_BASIC),
       last_connect_job_id_(net::NetLog::Source::kInvalidId) {
 }
 
@@ -62,6 +62,8 @@ LoadTimingObserver::~LoadTimingObserver() {
 
 LoadTimingObserver::URLRequestRecord*
 LoadTimingObserver::GetURLRequestRecord(uint32 source_id) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
   URLRequestToRecordMap::iterator it = url_request_to_record_.find(source_id);
   if (it != url_request_to_record_.end())
     return &it->second;
@@ -73,6 +75,9 @@ void LoadTimingObserver::OnAddEntry(net::NetLog::EventType type,
                                     const net::NetLog::Source& source,
                                     net::NetLog::EventPhase phase,
                                     net::NetLog::EventParameters* params) {
+  // The events that the Observer is interested in only occur on the IO thread.
+  if (!BrowserThread::CurrentlyOn(BrowserThread::IO))
+    return;
   if (source.type == net::NetLog::SOURCE_URL_REQUEST)
     OnAddURLRequestEntry(type, time, source, phase, params);
   else if (source.type == net::NetLog::SOURCE_CONNECT_JOB)
@@ -84,6 +89,7 @@ void LoadTimingObserver::OnAddEntry(net::NetLog::EventType type,
 // static
 void LoadTimingObserver::PopulateTimingInfo(net::URLRequest* request,
                                             ResourceResponse* response) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (!(request->load_flags() & net::LOAD_ENABLE_LOAD_TIMING))
     return;
 
@@ -109,6 +115,8 @@ void LoadTimingObserver::OnAddURLRequestEntry(
     const net::NetLog::Source& source,
     net::NetLog::EventPhase phase,
     net::NetLog::EventParameters* params) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
   bool is_begin = phase == net::NetLog::PHASE_BEGIN;
   bool is_end = phase == net::NetLog::PHASE_END;
 
@@ -210,6 +218,8 @@ void LoadTimingObserver::OnAddConnectJobEntry(
     const net::NetLog::Source& source,
     net::NetLog::EventPhase phase,
     net::NetLog::EventParameters* params) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
   bool is_begin = phase == net::NetLog::PHASE_BEGIN;
   bool is_end = phase == net::NetLog::PHASE_END;
 
@@ -253,6 +263,8 @@ void LoadTimingObserver::OnAddSocketEntry(
     const net::NetLog::Source& source,
     net::NetLog::EventPhase phase,
     net::NetLog::EventParameters* params) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
   bool is_begin = phase == net::NetLog::PHASE_BEGIN;
   bool is_end = phase == net::NetLog::PHASE_END;
 
diff --git a/chrome/browser/net/load_timing_observer.h b/chrome/browser/net/load_timing_observer.h
index ec3c2e5..a280398 100644
--- a/chrome/browser/net/load_timing_observer.h
+++ b/chrome/browser/net/load_timing_observer.h
@@ -21,7 +21,10 @@ struct ResourceResponse;
 
 // LoadTimingObserver watches the NetLog event stream and collects the network
 // timing information.
-class LoadTimingObserver : public ChromeNetLog::Observer {
+//
+// LoadTimingObserver lives completely on the IOThread and ignores events from
+// other threads.  It is not safe to use from other threads.
+class LoadTimingObserver : public ChromeNetLog::ThreadSafeObserver {
  public:
   struct URLRequestRecord {
     URLRequestRecord();
@@ -48,7 +51,7 @@ class LoadTimingObserver : public ChromeNetLog::Observer {
 
   URLRequestRecord* GetURLRequestRecord(uint32 source_id);
 
-  // Observer implementation:
+  // ThreadSafeObserver implementation:
   virtual void OnAddEntry(net::NetLog::EventType type,
                           const base::TimeTicks& time,
                           const net::NetLog::Source& source,
diff --git a/chrome/browser/net/load_timing_observer_unittest.cc b/chrome/browser/net/load_timing_observer_unittest.cc
index 98c50be..7d5ffa9 100644
--- a/chrome/browser/net/load_timing_observer_unittest.cc
+++ b/chrome/browser/net/load_timing_observer_unittest.cc
@@ -17,6 +17,17 @@ namespace {
 using net::NetLog;
 using base::TimeDelta;
 
+// Serves to Identify the current thread as the IO thread.
+class LoadTimingObserverTest : public testing::Test {
+ public:
+  LoadTimingObserverTest() : io_thread_(BrowserThread::IO, &message_loop_) {
+  }
+
+ private:
+  MessageLoop message_loop_;
+  BrowserThread io_thread_;
+};
+
 base::TimeTicks current_time;
 
 void AddStartEntry(LoadTimingObserver& observer,
@@ -82,7 +93,7 @@ void AddEndSocketEntries(LoadTimingObserver& observer, uint32 id) {
 }  // namespace
 
 // Test that net::URLRequest with no load timing flag is not processed.
-TEST(LoadTimingObserverTest, NoLoadTimingEnabled) {
+TEST_F(LoadTimingObserverTest, NoLoadTimingEnabled) {
   LoadTimingObserver observer;
 
   AddStartURLRequestEntries(observer, 0, false);
@@ -92,7 +103,7 @@ TEST(LoadTimingObserverTest, NoLoadTimingEnabled) {
 }
 
 // Test that URLRequestRecord is created, deleted and is not growing unbound.
-TEST(LoadTimingObserverTest, URLRequestRecord) {
+TEST_F(LoadTimingObserverTest, URLRequestRecord) {
   LoadTimingObserver observer;
 
   // Create record.
@@ -114,7 +125,7 @@ TEST(LoadTimingObserverTest, URLRequestRecord) {
 }
 
 // Test that ConnectJobRecord is created, deleted and is not growing unbound.
-TEST(LoadTimingObserverTest, ConnectJobRecord) {
+TEST_F(LoadTimingObserverTest, ConnectJobRecord) {
   LoadTimingObserver observer;
 
   // Create record.
@@ -135,7 +146,7 @@ TEST(LoadTimingObserverTest, ConnectJobRecord) {
 }
 
 // Test that SocketRecord is created, deleted and is not growing unbound.
-TEST(LoadTimingObserverTest, SocketRecord) {
+TEST_F(LoadTimingObserverTest, SocketRecord) {
   LoadTimingObserver observer;
 
   // Create record.
@@ -157,7 +168,7 @@ TEST(LoadTimingObserverTest, SocketRecord) {
 }
 
 // Test that basic time is set to the request.
-TEST(LoadTimingObserverTest, BaseTicks) {
+TEST_F(LoadTimingObserverTest, BaseTicks) {
   LoadTimingObserver observer;
   current_time += TimeDelta::FromSeconds(1);
   AddStartURLRequestEntries(observer, 0, true);
@@ -168,7 +179,7 @@ TEST(LoadTimingObserverTest, BaseTicks) {
 }
 
 // Test proxy time detection.
-TEST(LoadTimingObserverTest, ProxyTime) {
+TEST_F(LoadTimingObserverTest, ProxyTime) {
   LoadTimingObserver observer;
   current_time += TimeDelta::FromSeconds(1);
 
@@ -187,7 +198,7 @@ TEST(LoadTimingObserverTest, ProxyTime) {
 }
 
 // Test connect time detection.
-TEST(LoadTimingObserverTest, ConnectTime) {
+TEST_F(LoadTimingObserverTest, ConnectTime) {
   LoadTimingObserver observer;
   current_time += TimeDelta::FromSeconds(1);
 
@@ -206,7 +217,7 @@ TEST(LoadTimingObserverTest, ConnectTime) {
 }
 
 // Test dns time detection.
-TEST(LoadTimingObserverTest, DnsTime) {
+TEST_F(LoadTimingObserverTest, DnsTime) {
   LoadTimingObserver observer;
 
   // Start request.
@@ -240,7 +251,7 @@ TEST(LoadTimingObserverTest, DnsTime) {
 }
 
 // Test send time detection.
-TEST(LoadTimingObserverTest, SendTime) {
+TEST_F(LoadTimingObserverTest, SendTime) {
   LoadTimingObserver observer;
 
   // Start request.
@@ -266,7 +277,7 @@ TEST(LoadTimingObserverTest, SendTime) {
 }
 
 // Test receive time detection.
-TEST(LoadTimingObserverTest, ReceiveTime) {
+TEST_F(LoadTimingObserverTest, ReceiveTime) {
   LoadTimingObserver observer;
 
   // Start request.
@@ -292,7 +303,7 @@ TEST(LoadTimingObserverTest, ReceiveTime) {
 }
 
 // Test ssl time detection.
-TEST(LoadTimingObserverTest, SslTime) {
+TEST_F(LoadTimingObserverTest, SslTime) {
   LoadTimingObserver observer;
 
   // Start request.
diff --git a/chrome/browser/net/net_log_logger.cc b/chrome/browser/net/net_log_logger.cc
index b533e95..bba75ca 100644
--- a/chrome/browser/net/net_log_logger.cc
+++ b/chrome/browser/net/net_log_logger.cc
@@ -7,7 +7,9 @@
 #include "base/json/json_writer.h"
 #include "base/values.h"
 
-NetLogLogger::NetLogLogger() : Observer(net::NetLog::LOG_ALL_BUT_BYTES) {}
+NetLogLogger::NetLogLogger()
+    : ThreadSafeObserver(net::NetLog::LOG_ALL_BUT_BYTES) {
+}
 
 NetLogLogger::~NetLogLogger() {}
 
diff --git a/chrome/browser/net/net_log_logger.h b/chrome/browser/net/net_log_logger.h
index 7f90d94..564f232 100644
--- a/chrome/browser/net/net_log_logger.h
+++ b/chrome/browser/net/net_log_logger.h
@@ -11,12 +11,12 @@
 // NetLogLogger watches the NetLog event stream, and sends all entries to
 // VLOG(1).  This is to debug errors that prevent getting to the
 // about:net-internals page.
-class NetLogLogger : public ChromeNetLog::Observer {
+class NetLogLogger : public ChromeNetLog::ThreadSafeObserver {
  public:
   NetLogLogger();
   ~NetLogLogger();
 
-  // Observer implementation:
+  // ThreadSafeObserver implementation:
   virtual void OnAddEntry(net::NetLog::EventType type,
                           const base::TimeTicks& time,
                           const net::NetLog::Source& source,
diff --git a/chrome/browser/net/passive_log_collector.cc b/chrome/browser/net/passive_log_collector.cc
index 84a9403..b7ef11e 100644
--- a/chrome/browser/net/passive_log_collector.cc
+++ b/chrome/browser/net/passive_log_collector.cc
@@ -7,6 +7,7 @@
 #include <algorithm>
 
 #include "base/compiler_specific.h"
+#include "base/lock.h"
 #include "base/string_util.h"
 #include "base/format_macros.h"
 #include "chrome/browser/browser_thread.h"
@@ -18,7 +19,7 @@ namespace {
 
 const size_t kMaxNumEntriesPerLog = 30;
 
-void AddEntryToSourceInfo(const PassiveLogCollector::Entry& entry,
+void AddEntryToSourceInfo(const ChromeNetLog::Entry& entry,
                           PassiveLogCollector::SourceInfo* out_info) {
   // Start dropping new entries when the log has gotten too big.
   if (out_info->entries.size() + 1 <= kMaxNumEntriesPerLog) {
@@ -30,29 +31,13 @@ void AddEntryToSourceInfo(const PassiveLogCollector::Entry& entry,
 }
 
 // Comparator to sort entries by their |order| property, ascending.
-bool SortByOrderComparator(const PassiveLogCollector::Entry& a,
-                           const PassiveLogCollector::Entry& b) {
+bool SortByOrderComparator(const ChromeNetLog::Entry& a,
+                           const ChromeNetLog::Entry& b) {
   return a.order < b.order;
 }
 
 }  // namespace
 
-PassiveLogCollector::Entry::Entry(uint32 order,
-                                  net::NetLog::EventType type,
-                                  const base::TimeTicks& time,
-                                  net::NetLog::Source source,
-                                  net::NetLog::EventPhase phase,
-                                  net::NetLog::EventParameters* params)
-    : order(order),
-      type(type),
-      time(time),
-      source(source),
-      phase(phase),
-      params(params) {
-}
-
-PassiveLogCollector::Entry::~Entry() {}
-
 PassiveLogCollector::SourceInfo::SourceInfo()
     : source_id(net::NetLog::Source::kInvalidId),
       num_entries_truncated(0),
@@ -67,7 +52,7 @@ PassiveLogCollector::SourceInfo::~SourceInfo() {}
 //----------------------------------------------------------------------------
 
 PassiveLogCollector::PassiveLogCollector()
-    : Observer(net::NetLog::LOG_BASIC),
+    : ThreadSafeObserver(net::NetLog::LOG_BASIC),
       ALLOW_THIS_IN_INITIALIZER_LIST(connect_job_tracker_(this)),
       ALLOW_THIS_IN_INITIALIZER_LIST(url_request_tracker_(this)),
       ALLOW_THIS_IN_INITIALIZER_LIST(socket_stream_tracker_(this)),
@@ -100,28 +85,33 @@ void PassiveLogCollector::OnAddEntry(
     const net::NetLog::Source& source,
     net::NetLog::EventPhase phase,
     net::NetLog::EventParameters* params) {
+  AssertNetLogLockAcquired();
   // Package the parameters into a single struct for convenience.
-  Entry entry(num_events_seen_++, type, time, source, phase, params);
+  ChromeNetLog::Entry entry(num_events_seen_++, type, time, source, phase,
+                            params);
 
-  SourceTrackerInterface* tracker = GetTrackerForSourceType(entry.source.type);
+  SourceTrackerInterface* tracker = GetTrackerForSourceType_(entry.source.type);
   if (tracker)
     tracker->OnAddEntry(entry);
 }
 
+void PassiveLogCollector::Clear() {
+  AssertNetLogLockAcquired();
+  for (size_t i = 0; i < arraysize(trackers_); ++i)
+    trackers_[i]->Clear();
+}
+
 PassiveLogCollector::SourceTrackerInterface*
-PassiveLogCollector::GetTrackerForSourceType(
+PassiveLogCollector::GetTrackerForSourceType_(
     net::NetLog::SourceType source_type) {
   DCHECK_LE(source_type, static_cast<int>(arraysize(trackers_)));
   DCHECK_GE(source_type, 0);
   return trackers_[source_type];
 }
 
-void PassiveLogCollector::Clear() {
-  for (size_t i = 0; i < arraysize(trackers_); ++i)
-    trackers_[i]->Clear();
-}
-
-void PassiveLogCollector::GetAllCapturedEvents(EntryList* out) const {
+void PassiveLogCollector::GetAllCapturedEvents(
+    ChromeNetLog::EntryList* out) const {
+  AssertNetLogLockAcquired();
   out->clear();
 
   // Append all of the captured entries held by the various trackers to
@@ -137,7 +127,7 @@ std::string PassiveLogCollector::SourceInfo::GetURL() const {
   // Note: we look at the first *two* entries, since the outer REQUEST_ALIVE
   // doesn't actually contain any data.
   for (size_t i = 0; i < 2 && i < entries.size(); ++i) {
-    const PassiveLogCollector::Entry& entry = entries[i];
+    const ChromeNetLog::Entry& entry = entries[i];
     if (entry.phase == net::NetLog::PHASE_BEGIN && entry.params) {
       switch (entry.type) {
         case net::NetLog::TYPE_URL_REQUEST_START_JOB:
@@ -161,7 +151,8 @@ std::string PassiveLogCollector::SourceInfo::GetURL() const {
 PassiveLogCollector::GlobalSourceTracker::GlobalSourceTracker() {}
 PassiveLogCollector::GlobalSourceTracker::~GlobalSourceTracker() {}
 
-void PassiveLogCollector::GlobalSourceTracker::OnAddEntry(const Entry& entry) {
+void PassiveLogCollector::GlobalSourceTracker::OnAddEntry(
+    const ChromeNetLog::Entry& entry) {
   const size_t kMaxEntries = 30u;
   entries_.push_back(entry);
   if (entries_.size() > kMaxEntries)
@@ -173,7 +164,7 @@ void PassiveLogCollector::GlobalSourceTracker::Clear() {
 }
 
 void PassiveLogCollector::GlobalSourceTracker::AppendAllEntries(
-    EntryList* out) const {
+    ChromeNetLog::EntryList* out) const {
   out->insert(out->end(), entries_.begin(), entries_.end());
 }
 
@@ -192,7 +183,8 @@ PassiveLogCollector::SourceTracker::SourceTracker(
 
 PassiveLogCollector::SourceTracker::~SourceTracker() {}
 
-void PassiveLogCollector::SourceTracker::OnAddEntry(const Entry& entry) {
+void PassiveLogCollector::SourceTracker::OnAddEntry(
+    const ChromeNetLog::Entry& entry) {
   // Lookup or insert a new entry into the bounded map.
   SourceIDToInfoMap::iterator it = sources_.find(entry.source.id);
   if (it == sources_.end()) {
@@ -259,7 +251,7 @@ void PassiveLogCollector::SourceTracker::Clear() {
 }
 
 void PassiveLogCollector::SourceTracker::AppendAllEntries(
-    EntryList* out) const {
+    ChromeNetLog::EntryList* out) const {
   // Append all of the entries for each of the sources.
   for (SourceIDToInfoMap::const_iterator it = sources_.begin();
        it != sources_.end();
@@ -344,7 +336,7 @@ void PassiveLogCollector::SourceTracker::AddReferenceToSourceDependency(
   DCHECK(parent_);
   DCHECK_NE(source.type, net::NetLog::SOURCE_NONE);
   SourceTracker* tracker = static_cast<SourceTracker*>(
-      parent_->GetTrackerForSourceType(source.type));
+      parent_->GetTrackerForSourceType_(source.type));
   DCHECK(tracker);
 
   // Tell the owning tracker to increment the reference count of |source|.
@@ -366,7 +358,7 @@ PassiveLogCollector::SourceTracker::ReleaseAllReferencesToDependencies(
     DCHECK(parent_);
     DCHECK_NE(source.type, net::NetLog::SOURCE_NONE);
     SourceTracker* tracker = static_cast<SourceTracker*>(
-        parent_->GetTrackerForSourceType(source.type));
+        parent_->GetTrackerForSourceType_(source.type));
     DCHECK(tracker);
 
     // Tell the owning tracker to decrement the reference count of |source|.
@@ -389,8 +381,8 @@ PassiveLogCollector::ConnectJobTracker::ConnectJobTracker(
 }
 
 PassiveLogCollector::SourceTracker::Action
-PassiveLogCollector::ConnectJobTracker::DoAddEntry(const Entry& entry,
-                                                   SourceInfo* out_info) {
+PassiveLogCollector::ConnectJobTracker::DoAddEntry(
+    const ChromeNetLog::Entry& entry, SourceInfo* out_info) {
   AddEntryToSourceInfo(entry, out_info);
 
   if (entry.type == net::NetLog::TYPE_CONNECT_JOB_SET_SOCKET) {
@@ -420,7 +412,7 @@ PassiveLogCollector::SocketTracker::SocketTracker()
 }
 
 PassiveLogCollector::SourceTracker::Action
-PassiveLogCollector::SocketTracker::DoAddEntry(const Entry& entry,
+PassiveLogCollector::SocketTracker::DoAddEntry(const ChromeNetLog::Entry& entry,
                                                SourceInfo* out_info) {
   // TODO(eroman): aggregate the byte counts once truncation starts to happen,
   //               to summarize transaction read/writes for each SOCKET_IN_USE
@@ -452,8 +444,8 @@ PassiveLogCollector::RequestTracker::RequestTracker(PassiveLogCollector* parent)
 }
 
 PassiveLogCollector::SourceTracker::Action
-PassiveLogCollector::RequestTracker::DoAddEntry(const Entry& entry,
-                                                SourceInfo* out_info) {
+PassiveLogCollector::RequestTracker::DoAddEntry(
+    const ChromeNetLog::Entry& entry, SourceInfo* out_info) {
   if (entry.type == net::NetLog::TYPE_SOCKET_POOL_BOUND_TO_CONNECT_JOB ||
       entry.type == net::NetLog::TYPE_SOCKET_POOL_BOUND_TO_SOCKET) {
     const net::NetLog::Source& source_dependency =
@@ -491,7 +483,7 @@ PassiveLogCollector::InitProxyResolverTracker::InitProxyResolverTracker()
 
 PassiveLogCollector::SourceTracker::Action
 PassiveLogCollector::InitProxyResolverTracker::DoAddEntry(
-    const Entry& entry, SourceInfo* out_info) {
+    const ChromeNetLog::Entry& entry, SourceInfo* out_info) {
   AddEntryToSourceInfo(entry, out_info);
   if (entry.type == net::NetLog::TYPE_INIT_PROXY_RESOLVER &&
       entry.phase == net::NetLog::PHASE_END) {
@@ -513,8 +505,8 @@ PassiveLogCollector::SpdySessionTracker::SpdySessionTracker()
 }
 
 PassiveLogCollector::SourceTracker::Action
-PassiveLogCollector::SpdySessionTracker::DoAddEntry(const Entry& entry,
-                                                    SourceInfo* out_info) {
+PassiveLogCollector::SpdySessionTracker::DoAddEntry(
+    const ChromeNetLog::Entry& entry, SourceInfo* out_info) {
   AddEntryToSourceInfo(entry, out_info);
   if (entry.type == net::NetLog::TYPE_SPDY_SESSION &&
       entry.phase == net::NetLog::PHASE_END) {
@@ -536,8 +528,8 @@ PassiveLogCollector::DNSRequestTracker::DNSRequestTracker()
 }
 
 PassiveLogCollector::SourceTracker::Action
-PassiveLogCollector::DNSRequestTracker::DoAddEntry(const Entry& entry,
-                                                   SourceInfo* out_info) {
+PassiveLogCollector::DNSRequestTracker::DoAddEntry(
+    const ChromeNetLog::Entry& entry, SourceInfo* out_info) {
   AddEntryToSourceInfo(entry, out_info);
   if (entry.type == net::NetLog::TYPE_HOST_RESOLVER_IMPL_REQUEST &&
       entry.phase == net::NetLog::PHASE_END) {
@@ -559,7 +551,7 @@ PassiveLogCollector::DNSJobTracker::DNSJobTracker()
 }
 
 PassiveLogCollector::SourceTracker::Action
-PassiveLogCollector::DNSJobTracker::DoAddEntry(const Entry& entry,
+PassiveLogCollector::DNSJobTracker::DoAddEntry(const ChromeNetLog::Entry& entry,
                                                SourceInfo* out_info) {
   AddEntryToSourceInfo(entry, out_info);
   if (entry.type == net::NetLog::TYPE_HOST_RESOLVER_IMPL_JOB &&
diff --git a/chrome/browser/net/passive_log_collector.h b/chrome/browser/net/passive_log_collector.h
index 164aa66..114e439 100644
--- a/chrome/browser/net/passive_log_collector.h
+++ b/chrome/browser/net/passive_log_collector.h
@@ -32,29 +32,12 @@
 // The data captured by PassiveLogCollector is grouped by NetLog::Source, into
 // a SourceInfo structure. These in turn are grouped by NetLog::SourceType, and
 // owned by a SourceTracker instance for the specific source type.
-class PassiveLogCollector : public ChromeNetLog::Observer {
+//
+// The PassiveLogCollector is owned by the ChromeNetLog itself, and is not
+// thread safe.  The ChromeNetLog is responsible for calling it in a thread safe
+// manner.
+class PassiveLogCollector : public ChromeNetLog::ThreadSafeObserver {
  public:
-  // This structure encapsulates all of the parameters of a captured event,
-  // including an "order" field that identifies when it was captured relative
-  // to other events.
-  struct Entry {
-    Entry(uint32 order,
-          net::NetLog::EventType type,
-          const base::TimeTicks& time,
-          net::NetLog::Source source,
-          net::NetLog::EventPhase phase,
-          net::NetLog::EventParameters* params);
-    ~Entry();
-
-    uint32 order;
-    net::NetLog::EventType type;
-    base::TimeTicks time;
-    net::NetLog::Source source;
-    net::NetLog::EventPhase phase;
-    scoped_refptr<net::NetLog::EventParameters> params;
-  };
-
-  typedef std::vector<Entry> EntryList;
   typedef std::vector<net::NetLog::Source> SourceDependencyList;
 
   struct SourceInfo {
@@ -67,7 +50,7 @@ class PassiveLogCollector : public ChromeNetLog::Observer {
     std::string GetURL() const;
 
     uint32 source_id;
-    EntryList entries;
+    ChromeNetLog::EntryList entries;
     size_t num_entries_truncated;
 
     // List of other sources which contain information relevant to this
@@ -93,13 +76,13 @@ class PassiveLogCollector : public ChromeNetLog::Observer {
    public:
     virtual ~SourceTrackerInterface() {}
 
-    virtual void OnAddEntry(const Entry& entry) = 0;
+    virtual void OnAddEntry(const ChromeNetLog::Entry& entry) = 0;
 
     // Clears all the passively logged data from this tracker.
     virtual void Clear() = 0;
 
     // Appends all the captured entries to |out|. The ordering is undefined.
-    virtual void AppendAllEntries(EntryList* out) const = 0;
+    virtual void AppendAllEntries(ChromeNetLog::EntryList* out) const = 0;
   };
 
   // This source tracker is intended for TYPE_NONE. All entries go into a
@@ -110,12 +93,12 @@ class PassiveLogCollector : public ChromeNetLog::Observer {
     ~GlobalSourceTracker();
 
     // SourceTrackerInterface implementation:
-    virtual void OnAddEntry(const Entry& entry);
+    virtual void OnAddEntry(const ChromeNetLog::Entry& entry);
     virtual void Clear();
-    virtual void AppendAllEntries(EntryList* out) const;
+    virtual void AppendAllEntries(ChromeNetLog::EntryList* out) const;
 
    private:
-    typedef std::deque<Entry> CircularEntryList;
+    typedef std::deque<ChromeNetLog::Entry> CircularEntryList;
     CircularEntryList entries_;
     DISALLOW_COPY_AND_ASSIGN(GlobalSourceTracker);
   };
@@ -136,9 +119,9 @@ class PassiveLogCollector : public ChromeNetLog::Observer {
     virtual ~SourceTracker();
 
     // SourceTrackerInterface implementation:
-    virtual void OnAddEntry(const Entry& entry);
+    virtual void OnAddEntry(const ChromeNetLog::Entry& entry);
     virtual void Clear();
-    virtual void AppendAllEntries(EntryList* out) const;
+    virtual void AppendAllEntries(ChromeNetLog::EntryList* out) const;
 
 #ifdef UNIT_TEST
     // Helper used to inspect the current state by unit-tests.
@@ -172,7 +155,8 @@ class PassiveLogCollector : public ChromeNetLog::Observer {
 
     // Updates |out_info| with the information from |entry|. Returns an action
     // to perform for this map entry on completion.
-    virtual Action DoAddEntry(const Entry& entry, SourceInfo* out_info) = 0;
+    virtual Action DoAddEntry(const ChromeNetLog::Entry& entry,
+                              SourceInfo* out_info) = 0;
 
     // Removes |source_id| from |sources_|. This also releases any references
     // to dependencies held by this source.
@@ -217,7 +201,8 @@ class PassiveLogCollector : public ChromeNetLog::Observer {
     explicit ConnectJobTracker(PassiveLogCollector* parent);
 
    protected:
-    virtual Action DoAddEntry(const Entry& entry, SourceInfo* out_info);
+    virtual Action DoAddEntry(const ChromeNetLog::Entry& entry,
+                              SourceInfo* out_info);
    private:
     DISALLOW_COPY_AND_ASSIGN(ConnectJobTracker);
   };
@@ -231,7 +216,8 @@ class PassiveLogCollector : public ChromeNetLog::Observer {
     SocketTracker();
 
    protected:
-    virtual Action DoAddEntry(const Entry& entry, SourceInfo* out_info);
+    virtual Action DoAddEntry(const ChromeNetLog::Entry& entry,
+                              SourceInfo* out_info);
 
    private:
     DISALLOW_COPY_AND_ASSIGN(SocketTracker);
@@ -246,7 +232,8 @@ class PassiveLogCollector : public ChromeNetLog::Observer {
     explicit RequestTracker(PassiveLogCollector* parent);
 
    protected:
-    virtual Action DoAddEntry(const Entry& entry, SourceInfo* out_info);
+    virtual Action DoAddEntry(const ChromeNetLog::Entry& entry,
+                              SourceInfo* out_info);
 
    private:
     DISALLOW_COPY_AND_ASSIGN(RequestTracker);
@@ -262,7 +249,8 @@ class PassiveLogCollector : public ChromeNetLog::Observer {
     InitProxyResolverTracker();
 
    protected:
-    virtual Action DoAddEntry(const Entry& entry, SourceInfo* out_info);
+    virtual Action DoAddEntry(const ChromeNetLog::Entry& entry,
+                              SourceInfo* out_info);
 
    private:
     DISALLOW_COPY_AND_ASSIGN(InitProxyResolverTracker);
@@ -277,7 +265,8 @@ class PassiveLogCollector : public ChromeNetLog::Observer {
     SpdySessionTracker();
 
    protected:
-    virtual Action DoAddEntry(const Entry& entry, SourceInfo* out_info);
+    virtual Action DoAddEntry(const ChromeNetLog::Entry& entry,
+                              SourceInfo* out_info);
 
    private:
     DISALLOW_COPY_AND_ASSIGN(SpdySessionTracker);
@@ -292,7 +281,8 @@ class PassiveLogCollector : public ChromeNetLog::Observer {
     DNSRequestTracker();
 
    protected:
-    virtual Action DoAddEntry(const Entry& entry, SourceInfo* out_info);
+    virtual Action DoAddEntry(const ChromeNetLog::Entry& entry,
+                              SourceInfo* out_info);
 
    private:
     DISALLOW_COPY_AND_ASSIGN(DNSRequestTracker);
@@ -307,7 +297,8 @@ class PassiveLogCollector : public ChromeNetLog::Observer {
     DNSJobTracker();
 
    protected:
-    virtual Action DoAddEntry(const Entry& entry, SourceInfo* out_info);
+    virtual Action DoAddEntry(const ChromeNetLog::Entry& entry,
+                              SourceInfo* out_info);
 
    private:
     DISALLOW_COPY_AND_ASSIGN(DNSJobTracker);
@@ -316,25 +307,25 @@ class PassiveLogCollector : public ChromeNetLog::Observer {
   PassiveLogCollector();
   ~PassiveLogCollector();
 
-  // Observer implementation:
+  // ThreadSafeObserver implementation:
   virtual void OnAddEntry(net::NetLog::EventType type,
                           const base::TimeTicks& time,
                           const net::NetLog::Source& source,
                           net::NetLog::EventPhase phase,
                           net::NetLog::EventParameters* params);
 
-  // Returns the tracker to use for sources of type |source_type|, or NULL.
-  SourceTrackerInterface* GetTrackerForSourceType(
-      net::NetLog::SourceType source_type);
-
   // Clears all of the passively logged data.
   void Clear();
 
   // Fills |out| with the full list of events that have been passively
   // captured. The list is ordered by capture time.
-  void GetAllCapturedEvents(EntryList* out) const;
+  void GetAllCapturedEvents(ChromeNetLog::EntryList* out) const;
 
  private:
+  // Returns the tracker to use for sources of type |source_type|, or NULL.
+  SourceTrackerInterface* GetTrackerForSourceType_(
+      net::NetLog::SourceType source_type);
+
   FRIEND_TEST_ALL_PREFIXES(PassiveLogCollectorTest,
                            HoldReferenceToDependentSource);
   FRIEND_TEST_ALL_PREFIXES(PassiveLogCollectorTest,
diff --git a/chrome/browser/net/passive_log_collector_unittest.cc b/chrome/browser/net/passive_log_collector_unittest.cc
index e7d6074..fb2a1a2 100644
--- a/chrome/browser/net/passive_log_collector_unittest.cc
+++ b/chrome/browser/net/passive_log_collector_unittest.cc
@@ -19,9 +19,9 @@ using net::NetLog;
 
 const NetLog::SourceType kSourceType = NetLog::SOURCE_NONE;
 
-PassiveLogCollector::Entry MakeStartLogEntryWithURL(int source_id,
-                                                    const std::string& url) {
-  return PassiveLogCollector::Entry(
+ChromeNetLog::Entry MakeStartLogEntryWithURL(int source_id,
+                                             const std::string& url) {
+  return ChromeNetLog::Entry(
       0,
       NetLog::TYPE_URL_REQUEST_START_JOB,
       base::TimeTicks(),
@@ -30,13 +30,13 @@ PassiveLogCollector::Entry MakeStartLogEntryWithURL(int source_id,
       new URLRequestStartEventParameters(GURL(url), "GET", 0, net::LOW));
 }
 
-PassiveLogCollector::Entry MakeStartLogEntry(int source_id) {
+ChromeNetLog::Entry MakeStartLogEntry(int source_id) {
   return MakeStartLogEntryWithURL(source_id,
                                   StringPrintf("http://req%d", source_id));
 }
 
-PassiveLogCollector::Entry MakeEndLogEntry(int source_id) {
-  return PassiveLogCollector::Entry(
+ChromeNetLog::Entry MakeEndLogEntry(int source_id) {
+  return ChromeNetLog::Entry(
       0,
       NetLog::TYPE_REQUEST_ALIVE,
       base::TimeTicks(),
@@ -176,7 +176,7 @@ TEST(SpdySessionTracker, MovesToGraveyard) {
   EXPECT_EQ(0u, GetLiveSources(tracker).size());
   EXPECT_EQ(0u, GetDeadSources(tracker).size());
 
-  PassiveLogCollector::Entry begin(
+  ChromeNetLog::Entry begin(
       0u,
       NetLog::TYPE_SPDY_SESSION,
       base::TimeTicks(),
@@ -188,7 +188,7 @@ TEST(SpdySessionTracker, MovesToGraveyard) {
   EXPECT_EQ(1u, GetLiveSources(tracker).size());
   EXPECT_EQ(0u, GetDeadSources(tracker).size());
 
-  PassiveLogCollector::Entry end(
+  ChromeNetLog::Entry end(
       0u,
       NetLog::TYPE_SPDY_SESSION,
       base::TimeTicks(),