8 files changed, 288 insertions, 205 deletions

diff --git a/chrome/browser/net/chrome_net_log.cc b/chrome/browser/net/chrome_net_log.cc
index 86c8719..379f60a 100644
--- a/chrome/browser/net/chrome_net_log.cc
+++ b/chrome/browser/net/chrome_net_log.cc
@@ -13,67 +13,11 @@
 #include "chrome/browser/net/net_log_logger.h"
 #include "chrome/common/chrome_switches.h"
 
-ChromeNetLog::ThreadSafeObserverImpl::ThreadSafeObserverImpl(LogLevel log_level)
-    : net_log_(NULL),
-      ALLOW_THIS_IN_INITIALIZER_LIST(internal_observer_(this, log_level)) {
-}
-
-ChromeNetLog::ThreadSafeObserverImpl::~ThreadSafeObserverImpl() {
-  DCHECK(!net_log_);
-}
-
-void ChromeNetLog::ThreadSafeObserverImpl::AddAsObserver(
-    ChromeNetLog* net_log) {
-  DCHECK(!net_log_);
-  net_log_ = net_log;
-  net_log_->AddThreadSafeObserver(&internal_observer_);
-}
-
-void ChromeNetLog::ThreadSafeObserverImpl::RemoveAsObserver() {
-  DCHECK(net_log_);
-  net_log_->RemoveThreadSafeObserver(&internal_observer_);
-  net_log_ = NULL;
-}
-
-void ChromeNetLog::ThreadSafeObserverImpl::SetLogLevel(
-    net::NetLog::LogLevel log_level) {
-  DCHECK(net_log_);
-  base::AutoLock lock(net_log_->lock_);
-  internal_observer_.SetLogLevel(log_level);
-  net_log_->UpdateLogLevel();
-}
-
-void ChromeNetLog::ThreadSafeObserverImpl::AssertNetLogLockAcquired() const {
-  if (net_log_)
-    net_log_->lock_.AssertAcquired();
-}
-
-ChromeNetLog::ThreadSafeObserverImpl::PassThroughObserver::PassThroughObserver(
-    ChromeNetLog::ThreadSafeObserverImpl* owner,
-    net::NetLog::LogLevel log_level)
-    : net::NetLog::ThreadSafeObserver(log_level),
-      ALLOW_THIS_IN_INITIALIZER_LIST(owner_(owner)) {
-}
-
-void ChromeNetLog::ThreadSafeObserverImpl::PassThroughObserver::OnAddEntry(
-    net::NetLog::EventType type,
-    const base::TimeTicks& time,
-    const net::NetLog::Source& source,
-    net::NetLog::EventPhase phase,
-    net::NetLog::EventParameters* params) {
-  owner_->OnAddEntry(type, time, source, phase, params);
-}
-
-void ChromeNetLog::ThreadSafeObserverImpl::PassThroughObserver::SetLogLevel(
-    net::NetLog::LogLevel log_level) {
-  log_level_ = log_level;
-}
-
 ChromeNetLog::ChromeNetLog()
     : last_id_(0),
       base_log_level_(LOG_BASIC),
       effective_log_level_(LOG_BASIC),
-      load_timing_observer_(new LoadTimingObserver) {
+      load_timing_observer_(new LoadTimingObserver()) {
   const CommandLine* command_line = CommandLine::ForCurrentProcess();
   // Adjust base log level based on command line switch, if present.
   // This is done before adding any observers so the call to UpdateLogLevel when
@@ -89,20 +33,20 @@ ChromeNetLog::ChromeNetLog()
     }
   }
 
-  load_timing_observer_->AddAsObserver(this);
+  load_timing_observer_->StartObserving(this);
 
   if (command_line->HasSwitch(switches::kLogNetLog)) {
     net_log_logger_.reset(new NetLogLogger(
         command_line->GetSwitchValuePath(switches::kLogNetLog)));
-    net_log_logger_->AddAsObserver(this);
+    net_log_logger_->StartObserving(this);
   }
 }
 
 ChromeNetLog::~ChromeNetLog() {
-  load_timing_observer_->RemoveAsObserver();
-  if (net_log_logger_.get()) {
-    net_log_logger_->RemoveAsObserver();
-  }
+  // Remove the observers we own before we're destroyed.
+  RemoveThreadSafeObserver(load_timing_observer_.get());
+  if (net_log_logger_.get())
+    RemoveThreadSafeObserver(net_log_logger_.get());
 }
 
 void ChromeNetLog::AddEntry(EventType type,
@@ -128,16 +72,32 @@ net::NetLog::LogLevel ChromeNetLog::GetLogLevel() const {
 }
 
 void ChromeNetLog::AddThreadSafeObserver(
-    net::NetLog::ThreadSafeObserver* observer) {
+    net::NetLog::ThreadSafeObserver* observer,
+    LogLevel log_level) {
   base::AutoLock lock(lock_);
+
   observers_.AddObserver(observer);
+  OnAddObserver(observer, log_level);
+  UpdateLogLevel();
+}
+
+void ChromeNetLog::SetObserverLogLevel(
+    net::NetLog::ThreadSafeObserver* observer,
+    LogLevel log_level) {
+  base::AutoLock lock(lock_);
+
+  DCHECK(observers_.HasObserver(observer));
+  OnSetObserverLogLevel(observer, log_level);
   UpdateLogLevel();
 }
 
 void ChromeNetLog::RemoveThreadSafeObserver(
     net::NetLog::ThreadSafeObserver* observer) {
   base::AutoLock lock(lock_);
+
+  DCHECK(observers_.HasObserver(observer));
   observers_.RemoveObserver(observer);
+  OnRemoveObserver(observer);
   UpdateLogLevel();
 }
 
diff --git a/chrome/browser/net/chrome_net_log.h b/chrome/browser/net/chrome_net_log.h
index 78ee636..5335b33 100644
--- a/chrome/browser/net/chrome_net_log.h
+++ b/chrome/browser/net/chrome_net_log.h
@@ -19,75 +19,11 @@ class NetLogLogger;
 // 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::ThreadSafeObserverImpl functions may be called by an observer's
+// All methods are thread safe, with the exception that no NetLog or
+// NetLog::ThreadSafeObserver functions may be called by an observer's
 // OnAddEntry() method.  Doing so will result in a deadlock.
 class ChromeNetLog : public net::NetLog {
  public:
-  // Base class for observing the events logged by the network
-  // stack. This has some nice-to-have functionality for use by code
-  // within chrome/, but any net::NetLog::ThreadSafeObserver may be
-  // registered to observe the NetLog.
-  //
-  // This class uses composition rather than inheritance so that
-  // certain invariants can be maintained when subclasses of it are
-  // added as observers (through the AddAsObserver and
-  // RemoveAsObserver methods on this class).
-  class ThreadSafeObserverImpl {
-   public:
-    // Observers that need to see the full granularity of events can
-    // specify LOG_ALL.
-    explicit ThreadSafeObserverImpl(LogLevel log_level);
-    virtual ~ThreadSafeObserverImpl();
-
-    virtual void OnAddEntry(EventType type,
-                            const base::TimeTicks& time,
-                            const Source& source,
-                            EventPhase phase,
-                            EventParameters* params) = 0;
-
-    // These must be used instead of
-    // ChromeNetLog::Add/RemoveThreadSafeObserver to manage the
-    // association in this class with a given ChromeNetLog instance.
-    void AddAsObserver(ChromeNetLog* net_log);
-    void RemoveAsObserver();
-
-    void SetLogLevel(LogLevel log_level);
-
-   protected:
-    void AssertNetLogLockAcquired() const;
-
-   private:
-    class PassThroughObserver : public ThreadSafeObserver {
-     public:
-      PassThroughObserver(ThreadSafeObserverImpl* owner, LogLevel log_level);
-      virtual ~PassThroughObserver() {}
-      virtual void OnAddEntry(EventType type,
-                              const base::TimeTicks& time,
-                              const Source& source,
-                              EventPhase phase,
-                              EventParameters* params) OVERRIDE;
-
-      // Can only be called when actively observing a ChromeNetLog.
-      void SetLogLevel(LogLevel log_level);
-
-     private:
-      ThreadSafeObserverImpl* owner_;
-    };
-
-    friend class PassThroughObserver;
-
-    // ChromeNetLog currently being observed. Set by
-    // AddAsObserver/RemoveAsObserver.
-    ChromeNetLog* net_log_;
-
-    // The observer we register in AddAsObserver, that passes stuff
-    // through to us.
-    PassThroughObserver internal_observer_;
-
-    DISALLOW_COPY_AND_ASSIGN(ThreadSafeObserverImpl);
-  };
-
   ChromeNetLog();
   virtual ~ChromeNetLog();
 
@@ -99,22 +35,22 @@ class ChromeNetLog : public net::NetLog {
                         EventParameters* params) OVERRIDE;
   virtual uint32 NextID() OVERRIDE;
   virtual LogLevel GetLogLevel() const OVERRIDE;
+  virtual void AddThreadSafeObserver(ThreadSafeObserver* observer,
+                                     LogLevel log_level) OVERRIDE;
+  virtual void SetObserverLogLevel(ThreadSafeObserver* observer,
+                                   LogLevel log_level) OVERRIDE;
+  virtual void RemoveThreadSafeObserver(ThreadSafeObserver* observer) OVERRIDE;
 
   LoadTimingObserver* load_timing_observer() {
     return load_timing_observer_.get();
   }
 
  private:
-  // NetLog implementation
-  virtual void AddThreadSafeObserver(ThreadSafeObserver* observer) OVERRIDE;
-  virtual void RemoveThreadSafeObserver(ThreadSafeObserver* observer) OVERRIDE;
-
-  // Called whenever an observer is added or removed, or changes its log level.
-  // Must have acquired |lock_| prior to calling.
+  // Called whenever an observer is added or removed, or has its log level
+  // changed.  Must have acquired |lock_| prior to calling.
   void UpdateLogLevel();
 
-  // |lock_| protects access to |observers_| and, indirectly, to. Should not
-  // be acquired by observers.
+  // |lock_| protects access to |observers_|.
   base::Lock lock_;
 
   // Last assigned source ID.  Incremented to get the next one.
diff --git a/chrome/browser/net/chrome_net_log_unittest.cc b/chrome/browser/net/chrome_net_log_unittest.cc
index 9369f65..a8c5b15 100644
--- a/chrome/browser/net/chrome_net_log_unittest.cc
+++ b/chrome/browser/net/chrome_net_log_unittest.cc
@@ -13,92 +13,265 @@ namespace {
 const int kThreads = 10;
 const int kEvents = 100;
 
+class CountingObserver : public net::NetLog::ThreadSafeObserver {
+ public:
+  CountingObserver() : count_(0) {}
+
+  ~CountingObserver() {
+    if (net_log())
+      net_log()->RemoveThreadSafeObserver(this);
+  }
+
+  virtual void OnAddEntry(net::NetLog::EventType type,
+                          const base::TimeTicks& time,
+                          const net::NetLog::Source& source,
+                          net::NetLog::EventPhase phase,
+                          net::NetLog::EventParameters* params) OVERRIDE {
+    ++count_;
+  }
+
+  int count() const { return count_; }
+
+ private:
+  int count_;
+};
+
+void AddEvent(ChromeNetLog* net_log) {
+  net::NetLog::Source source(net::NetLog::SOURCE_SOCKET, net_log->NextID());
+  net_log->AddEntry(net::NetLog::TYPE_SOCKET_ALIVE, base::TimeTicks(),
+                    source, net::NetLog::PHASE_BEGIN, NULL);
+}
+
+// A thread that waits until an event has been signalled before calling
+// RunTestThread.
 class ChromeNetLogTestThread : public base::SimpleThread {
  public:
   ChromeNetLogTestThread() : base::SimpleThread("ChromeNetLogTest"),
-                             can_start_loop_(false, false),
-                             log_(NULL) {
+                             net_log_(NULL),
+                             start_event_(NULL) {
   }
 
-  void Init(ChromeNetLog* log) {
-    log_ = log;
+  // We'll wait for |start_event| to be triggered before calling a subclass's
+  // subclass's RunTestThread() function.
+  void Init(ChromeNetLog* net_log, base::WaitableEvent* start_event) {
+    start_event_ = start_event;
+    net_log_ = net_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);
-    }
+  virtual void Run() OVERRIDE {
+    start_event_->Wait();
+    RunTestThread();
   }
 
-  void ReallyStart() {
-    can_start_loop_.Signal();
-  }
+  // Subclasses must override this with the code they want to run on their
+  // thread.
+  virtual void RunTestThread() = 0;
 
- 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_;
+ protected:
+  ChromeNetLog* net_log_;
 
-  ChromeNetLog* log_;
+ private:
+  // Only triggered once all threads have been created, to make it less likely
+  // each thread completes before the next one starts.
+  base::WaitableEvent* start_event_;
 
   DISALLOW_COPY_AND_ASSIGN(ChromeNetLogTestThread);
 };
 
-class CountingObserver : public ChromeNetLog::ThreadSafeObserverImpl {
+// A thread that adds a bunch of events to the NetLog.
+class AddEventsTestThread : public ChromeNetLogTestThread {
  public:
-  CountingObserver()
-      : ChromeNetLog::ThreadSafeObserverImpl(net::NetLog::LOG_ALL),
-        count_(0) {}
+  AddEventsTestThread() {}
+  ~AddEventsTestThread() {}
 
-  virtual void OnAddEntry(net::NetLog::EventType type,
-                          const base::TimeTicks& time,
-                          const net::NetLog::Source& source,
-                          net::NetLog::EventPhase phase,
-                          net::NetLog::EventParameters* params) OVERRIDE {
-    count_++;
+ private:
+  virtual void RunTestThread() OVERRIDE {
+    for (int i = 0; i < kEvents; ++i)
+      AddEvent(net_log_);
   }
 
-  int count() const { return count_; }
+  DISALLOW_COPY_AND_ASSIGN(AddEventsTestThread);
+};
+
+// A thread that adds and removes an observer from the NetLog repeatedly.
+class AddRemoveObserverTestThread : public ChromeNetLogTestThread {
+ public:
+  AddRemoveObserverTestThread() {}
+
+  ~AddRemoveObserverTestThread() {
+    EXPECT_TRUE(!observer_.net_log());
+  }
 
  private:
-  int count_;
-};
+  virtual void RunTestThread() OVERRIDE {
+    for (int i = 0; i < kEvents; ++i) {
+      ASSERT_FALSE(observer_.net_log());
 
-}  // namespace
+      net_log_->AddThreadSafeObserver(&observer_, net::NetLog::LOG_BASIC);
+      ASSERT_EQ(net_log_, observer_.net_log());
+      ASSERT_EQ(net::NetLog::LOG_BASIC, observer_.log_level());
 
-// Makes sure that events are dispatched to all observers, and that this
-// operation works correctly when run on multiple threads.
-TEST(ChromeNetLogTest, NetLogThreads) {
-  ChromeNetLog log;
-  ChromeNetLogTestThread threads[kThreads];
+      net_log_->SetObserverLogLevel(&observer_, net::NetLog::LOG_ALL_BUT_BYTES);
+      ASSERT_EQ(net_log_, observer_.net_log());
+      ASSERT_EQ(net::NetLog::LOG_ALL_BUT_BYTES, observer_.log_level());
+      ASSERT_LE(net_log_->GetLogLevel(), net::NetLog::LOG_ALL_BUT_BYTES);
 
-  // Attach some observers
-  CountingObserver observers[3];
-  for (size_t i = 0; i < arraysize(observers); ++i)
-    observers[i].AddAsObserver(&log);
+      net_log_->SetObserverLogLevel(&observer_, net::NetLog::LOG_ALL);
+      ASSERT_EQ(net_log_, observer_.net_log());
+      ASSERT_EQ(net::NetLog::LOG_ALL, observer_.log_level());
+      ASSERT_LE(net_log_->GetLogLevel(), net::NetLog::LOG_ALL);
 
-  // Run a bunch of threads to completion, each of which will emit events to
-  // |log|.
-  for (int i = 0; i < kThreads; ++i) {
-    threads[i].Init(&log);
+      net_log_->RemoveThreadSafeObserver(&observer_);
+      ASSERT_TRUE(!observer_.net_log());
+    }
+  }
+
+  CountingObserver observer_;
+
+  DISALLOW_COPY_AND_ASSIGN(AddRemoveObserverTestThread);
+};
+
+// Creates |kThreads| threads of type |ThreadType| and then runs them all
+// to completion.
+template<class ThreadType>
+void RunTestThreads(ChromeNetLog* net_log) {
+  ThreadType threads[kThreads];
+  base::WaitableEvent start_event(true, false);
+
+  for (size_t i = 0; i < arraysize(threads); ++i) {
+    threads[i].Init(net_log, &start_event);
     threads[i].Start();
   }
 
-  for (int i = 0; i < kThreads; ++i)
-    threads[i].ReallyStart();
+  start_event.Signal();
 
-  for (int i = 0; i < kThreads; ++i)
+  for (size_t i = 0; i < arraysize(threads); ++i)
     threads[i].Join();
+}
+
+// Makes sure that events on multiple threads are dispatched to all observers.
+TEST(ChromeNetLogTest, NetLogEventThreads) {
+  ChromeNetLog net_log;
+
+  // Attach some observers.  Since they're created after |net_log|, they'll
+  // safely detach themselves on destruction.
+  CountingObserver observers[3];
+  for (size_t i = 0; i < arraysize(observers); ++i)
+    net_log.AddThreadSafeObserver(&observers[i], net::NetLog::LOG_BASIC);
+
+  // Run a bunch of threads to completion, each of which will emit events to
+  // |net_log|.
+  RunTestThreads<AddEventsTestThread>(&net_log);
 
   // Check that each observer saw the emitted events.
   const int kTotalEvents = kThreads * kEvents;
   for (size_t i = 0; i < arraysize(observers); ++i)
     EXPECT_EQ(kTotalEvents, observers[i].count());
+}
 
-  // Detach all the observers
-  for (size_t i = 0; i < arraysize(observers); ++i)
-    observers[i].RemoveAsObserver();
+// Test adding and removing a single observer.
+TEST(ChromeNetLogTest, NetLogAddRemoveObserver) {
+  ChromeNetLog net_log;
+  CountingObserver observer;
+
+  AddEvent(&net_log);
+  EXPECT_EQ(0, observer.count());
+  EXPECT_EQ(NULL, observer.net_log());
+  EXPECT_EQ(net::NetLog::LOG_BASIC, net_log.GetLogLevel());
+
+  // Add the observer and add an event.
+  net_log.AddThreadSafeObserver(&observer, net::NetLog::LOG_BASIC);
+  EXPECT_EQ(&net_log, observer.net_log());
+  EXPECT_EQ(net::NetLog::LOG_BASIC, observer.log_level());
+  EXPECT_EQ(net::NetLog::LOG_BASIC, net_log.GetLogLevel());
+
+  AddEvent(&net_log);
+  EXPECT_EQ(1, observer.count());
+
+  // Change the observer's logging level and add an event.
+  net_log.SetObserverLogLevel(&observer, net::NetLog::LOG_ALL);
+  EXPECT_EQ(&net_log, observer.net_log());
+  EXPECT_EQ(net::NetLog::LOG_ALL, observer.log_level());
+  EXPECT_EQ(net::NetLog::LOG_ALL, net_log.GetLogLevel());
+
+  AddEvent(&net_log);
+  EXPECT_EQ(2, observer.count());
+
+  // Remove observer and add an event.
+  net_log.RemoveThreadSafeObserver(&observer);
+  EXPECT_EQ(NULL, observer.net_log());
+  EXPECT_EQ(net::NetLog::LOG_BASIC, net_log.GetLogLevel());
+
+  AddEvent(&net_log);
+  EXPECT_EQ(2, observer.count());
+
+  // Add the observer a final time, and add an event.
+  net_log.AddThreadSafeObserver(&observer, net::NetLog::LOG_ALL);
+  EXPECT_EQ(&net_log, observer.net_log());
+  EXPECT_EQ(net::NetLog::LOG_ALL, observer.log_level());
+  EXPECT_EQ(net::NetLog::LOG_ALL, net_log.GetLogLevel());
+
+  AddEvent(&net_log);
+  EXPECT_EQ(3, observer.count());
+}
+
+// Test adding and removing two observers.
+TEST(ChromeNetLogTest, NetLogTwoObservers) {
+  ChromeNetLog net_log;
+  CountingObserver observer[2];
+
+  // Add first observer.
+  net_log.AddThreadSafeObserver(&observer[0], net::NetLog::LOG_ALL_BUT_BYTES);
+  EXPECT_EQ(&net_log, observer[0].net_log());
+  EXPECT_EQ(NULL, observer[1].net_log());
+  EXPECT_EQ(net::NetLog::LOG_ALL_BUT_BYTES, observer[0].log_level());
+  EXPECT_EQ(net::NetLog::LOG_ALL_BUT_BYTES, net_log.GetLogLevel());
+
+  // Add second observer observer.
+  net_log.AddThreadSafeObserver(&observer[1], net::NetLog::LOG_ALL);
+  EXPECT_EQ(&net_log, observer[0].net_log());
+  EXPECT_EQ(&net_log, observer[1].net_log());
+  EXPECT_EQ(net::NetLog::LOG_ALL_BUT_BYTES, observer[0].log_level());
+  EXPECT_EQ(net::NetLog::LOG_ALL, observer[1].log_level());
+  EXPECT_EQ(net::NetLog::LOG_ALL, net_log.GetLogLevel());
+
+  // Add event and make sure both observers receive it.
+  AddEvent(&net_log);
+  EXPECT_EQ(1, observer[0].count());
+  EXPECT_EQ(1, observer[1].count());
+
+  // Remove second observer.
+  net_log.RemoveThreadSafeObserver(&observer[1]);
+  EXPECT_EQ(&net_log, observer[0].net_log());
+  EXPECT_EQ(NULL, observer[1].net_log());
+  EXPECT_EQ(net::NetLog::LOG_ALL_BUT_BYTES, observer[0].log_level());
+  EXPECT_EQ(net::NetLog::LOG_ALL_BUT_BYTES, net_log.GetLogLevel());
+
+  // Add event and make sure only second observer gets it.
+  AddEvent(&net_log);
+  EXPECT_EQ(2, observer[0].count());
+  EXPECT_EQ(1, observer[1].count());
+
+  // Remove first observer.
+  net_log.RemoveThreadSafeObserver(&observer[0]);
+  EXPECT_EQ(NULL, observer[0].net_log());
+  EXPECT_EQ(NULL, observer[1].net_log());
+  EXPECT_EQ(net::NetLog::LOG_BASIC, net_log.GetLogLevel());
+
+  // Add event and make sure neither observer gets it.
+  AddEvent(&net_log);
+  EXPECT_EQ(2, observer[0].count());
+  EXPECT_EQ(1, observer[1].count());
 }
+
+// Makes sure that adding and removing observers simultaneously on different
+// threads works.
+TEST(ChromeNetLogTest, NetLogAddRemoveObserverThreads) {
+  ChromeNetLog net_log;
+
+  // Run a bunch of threads to completion, each of which will repeatedly add
+  // and remove an observer, and set its logging level.
+  RunTestThreads<AddRemoveObserverTestThread>(&net_log);
+}
+
+}  // namespace
diff --git a/chrome/browser/net/load_timing_observer.cc b/chrome/browser/net/load_timing_observer.cc
index b3bd189..b6760bc 100644
--- a/chrome/browser/net/load_timing_observer.cc
+++ b/chrome/browser/net/load_timing_observer.cc
@@ -1,4 +1,4 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Copyright (c) 2012 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.
 
@@ -63,13 +63,16 @@ LoadTimingObserver::HTTPStreamJobRecord::HTTPStreamJobRecord()
 }
 
 LoadTimingObserver::LoadTimingObserver()
-    : ThreadSafeObserverImpl(net::NetLog::LOG_BASIC),
-      last_connect_job_id_(net::NetLog::Source::kInvalidId) {
+    : last_connect_job_id_(net::NetLog::Source::kInvalidId) {
 }
 
 LoadTimingObserver::~LoadTimingObserver() {
 }
 
+void LoadTimingObserver::StartObserving(net::NetLog* net_log) {
+  net_log->AddThreadSafeObserver(this, net::NetLog::LOG_BASIC);
+}
+
 LoadTimingObserver::URLRequestRecord*
 LoadTimingObserver::GetURLRequestRecord(uint32 source_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
diff --git a/chrome/browser/net/load_timing_observer.h b/chrome/browser/net/load_timing_observer.h
index a44a3be..56d3f8e 100644
--- a/chrome/browser/net/load_timing_observer.h
+++ b/chrome/browser/net/load_timing_observer.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Copyright (c) 2012 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.
 
@@ -9,7 +9,6 @@
 #include "base/gtest_prod_util.h"
 #include "base/hash_tables.h"
 #include "base/time.h"
-#include "chrome/browser/net/chrome_net_log.h"
 #include "net/base/net_log.h"
 #include "webkit/glue/resource_loader_bridge.h"
 
@@ -26,7 +25,7 @@ class URLRequest;
 //
 // 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::ThreadSafeObserverImpl {
+class LoadTimingObserver : public net::NetLog::ThreadSafeObserver {
  public:
   struct URLRequestRecord {
     URLRequestRecord();
@@ -64,9 +63,13 @@ class LoadTimingObserver : public ChromeNetLog::ThreadSafeObserverImpl {
   LoadTimingObserver();
   virtual ~LoadTimingObserver();
 
+  // Starts observing specified NetLog.  Must not already be watching a NetLog.
+  // Separate from constructor to enforce thread safety.
+  void StartObserving(net::NetLog* net_log);
+
   URLRequestRecord* GetURLRequestRecord(uint32 source_id);
 
-  // ThreadSafeObserver implementation:
+  // net::NetLog::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 ec63798..e0b66f6 100644
--- a/chrome/browser/net/load_timing_observer_unittest.cc
+++ b/chrome/browser/net/load_timing_observer_unittest.cc
@@ -1,4 +1,4 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Copyright (c) 2012 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.
 
@@ -20,7 +20,7 @@ using base::TimeDelta;
 using content::BrowserThread;
 using net::NetLog;
 
-// Serves to Identify the current thread as the IO thread.
+// Serves to identify the current thread as the IO thread.
 class LoadTimingObserverTest : public testing::Test {
  public:
   LoadTimingObserverTest() : io_thread_(BrowserThread::IO, &message_loop_) {
diff --git a/chrome/browser/net/net_log_logger.cc b/chrome/browser/net/net_log_logger.cc
index c52abf7..bc9cd6a 100644
--- a/chrome/browser/net/net_log_logger.cc
+++ b/chrome/browser/net/net_log_logger.cc
@@ -8,13 +8,13 @@
 
 #include "base/file_util.h"
 #include "base/json/json_writer.h"
+#include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/values.h"
 #include "chrome/browser/ui/webui/net_internals/net_internals_ui.h"
 
-NetLogLogger::NetLogLogger(const FilePath &log_path)
-    : ThreadSafeObserverImpl(net::NetLog::LOG_ALL_BUT_BYTES) {
+NetLogLogger::NetLogLogger(const FilePath &log_path) {
   if (!log_path.empty()) {
     base::ThreadRestrictions::ScopedAllowIO allow_io;
     file_.Set(file_util::OpenFile(log_path, "w"));
@@ -33,6 +33,10 @@ NetLogLogger::NetLogLogger(const FilePath &log_path)
 NetLogLogger::~NetLogLogger() {
 }
 
+void NetLogLogger::StartObserving(net::NetLog* net_log) {
+  net_log->AddThreadSafeObserver(this, net::NetLog::LOG_ALL_BUT_BYTES);
+}
+
 void NetLogLogger::OnAddEntry(net::NetLog::EventType type,
                               const base::TimeTicks& time,
                               const net::NetLog::Source& source,
diff --git a/chrome/browser/net/net_log_logger.h b/chrome/browser/net/net_log_logger.h
index f04fcc8..fc54462 100644
--- a/chrome/browser/net/net_log_logger.h
+++ b/chrome/browser/net/net_log_logger.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Copyright (c) 2012 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.
 
@@ -7,7 +7,7 @@
 #pragma once
 
 #include "base/memory/scoped_handle.h"
-#include "chrome/browser/net/chrome_net_log.h"
+#include "net/base/net_log.h"
 
 class FilePath;
 
@@ -21,7 +21,7 @@ class FilePath;
 //
 // Relies on ChromeNetLog only calling an Observer once at a time for
 // thread-safety.
-class NetLogLogger : public ChromeNetLog::ThreadSafeObserverImpl {
+class NetLogLogger : public net::NetLog::ThreadSafeObserver {
  public:
   // If |log_path| is empty or file creation fails, writes to VLOG(1).
   // Otherwise, writes to |log_path|.  Uses one line per entry, for
@@ -29,7 +29,11 @@ class NetLogLogger : public ChromeNetLog::ThreadSafeObserverImpl {
   explicit NetLogLogger(const FilePath &log_path);
   virtual ~NetLogLogger();
 
-  // ThreadSafeObserver implementation:
+  // Starts observing specified NetLog.  Must not already be watching a NetLog.
+  // Separate from constructor to enforce thread safety.
+  void StartObserving(net::NetLog* net_log);
+
+  // net::NetLog::ThreadSafeObserver implementation:
   virtual void OnAddEntry(net::NetLog::EventType type,
                           const base::TimeTicks& time,
                           const net::NetLog::Source& source,