Revert 204861 "Refactor net::NetLog to provide implementation of..."

> Refactor net::NetLog to provide implementation of observer pattern, not just the interface.
> This would make use of net::NetLog::ThreadSafeObserver available from base/net, so custom NetLog implementations can focus on implementing OnAddEntry() without re-implementing all NetLog methods.
> 
> The implementation of observer pattern was previously provided in ChromeNetLog.
> The contents of chrome_net_log_unittest are merged to net_log_unittest.
> 
> TESTS=net_log_unittest
> BUG=None
> 
> Review URL: https://chromiumcodereview.appspot.com/16137008

TBR=kouhei@chromium.org

Review URL: https://codereview.chromium.org/15927035

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@204892 0039d316-1c4b-4281-b951-d872f2087c98

15 files changed, 597 insertions, 517 deletions

diff --git a/chrome/browser/net/chrome_net_log.cc b/chrome/browser/net/chrome_net_log.cc
index 7e9a2fc..b1594dc 100644
--- a/chrome/browser/net/chrome_net_log.cc
+++ b/chrome/browser/net/chrome_net_log.cc
@@ -16,7 +16,10 @@
 #include "chrome/common/chrome_switches.h"
 
 ChromeNetLog::ChromeNetLog()
-    : net_log_temp_file_(new NetLogTempFile(this)) {
+    : last_id_(0),
+      base_log_level_(LOG_NONE),
+      effective_log_level_(LOG_NONE),
+      net_log_temp_file_(new NetLogTempFile(this)) {
   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
@@ -28,7 +31,7 @@ ChromeNetLog::ChromeNetLog()
     if (base::StringToInt(log_level_string, &command_line_log_level) &&
         command_line_log_level >= LOG_ALL &&
         command_line_log_level <= LOG_NONE) {
-      SetBaseLogLevel(static_cast<LogLevel>(command_line_log_level));
+      base_log_level_ = static_cast<LogLevel>(command_line_log_level);
     }
   }
 
@@ -65,3 +68,65 @@ ChromeNetLog::~ChromeNetLog() {
     RemoveThreadSafeObserver(net_log_logger_.get());
 }
 
+void ChromeNetLog::OnAddEntry(const net::NetLog::Entry& entry) {
+  base::AutoLock lock(lock_);
+
+  // Notify all of the log observers.
+  FOR_EACH_OBSERVER(ThreadSafeObserver, observers_, OnAddEntry(entry));
+}
+
+uint32 ChromeNetLog::NextID() {
+  return base::subtle::NoBarrier_AtomicIncrement(&last_id_, 1);
+}
+
+net::NetLog::LogLevel ChromeNetLog::GetLogLevel() const {
+  base::subtle::Atomic32 log_level =
+      base::subtle::NoBarrier_Load(&effective_log_level_);
+  return static_cast<net::NetLog::LogLevel>(log_level);
+}
+
+void ChromeNetLog::AddThreadSafeObserver(
+    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();
+}
+
+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 new_effective_log_level = base_log_level_;
+  ObserverListBase<ThreadSafeObserver>::Iterator it(observers_);
+  ThreadSafeObserver* observer;
+  while ((observer = it.GetNext()) != NULL) {
+    new_effective_log_level =
+        std::min(new_effective_log_level, observer->log_level());
+  }
+  base::subtle::NoBarrier_Store(&effective_log_level_,
+                                new_effective_log_level);
+}
diff --git a/chrome/browser/net/chrome_net_log.h b/chrome/browser/net/chrome_net_log.h
index 10e45fb..9bbf152 100644
--- a/chrome/browser/net/chrome_net_log.h
+++ b/chrome/browser/net/chrome_net_log.h
@@ -25,14 +25,46 @@ class ChromeNetLog : public net::NetLog {
   ChromeNetLog();
   virtual ~ChromeNetLog();
 
+  // NetLog implementation:
+  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;
+
   NetLogTempFile* net_log_temp_file() {
     return net_log_temp_file_.get();
   }
 
  private:
+  // NetLog implementation:
+  virtual void OnAddEntry(const net::NetLog::Entry& entry) OVERRIDE;
+
+  // 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_|.
+  base::Lock lock_;
+
+  // Last assigned source ID.  Incremented to get the next one.
+  base::subtle::Atomic32 last_id_;
+
+  // The lowest allowed log level, regardless of any ChromeNetLogObservers.
+  // Normally defaults to LOG_BASIC, but can be changed with command line flags.
+  LogLevel base_log_level_;
+
+  // The current log level.
+  base::subtle::Atomic32 effective_log_level_;
+
   scoped_ptr<NetLogLogger> net_log_logger_;
   scoped_ptr<NetLogTempFile> net_log_temp_file_;
 
+  // |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..6eb0912
--- /dev/null
+++ b/chrome/browser/net/chrome_net_log_unittest.cc
@@ -0,0 +1,271 @@
+// 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.
+
+#include "chrome/browser/net/chrome_net_log.h"
+
+#include "base/synchronization/waitable_event.h"
+#include "base/threading/simple_thread.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace {
+
+const int kThreads = 10;
+const int kEvents = 100;
+
+class CountingObserver : public net::NetLog::ThreadSafeObserver {
+ public:
+  CountingObserver() : count_(0) {}
+
+  virtual ~CountingObserver() {
+    if (net_log())
+      net_log()->RemoveThreadSafeObserver(this);
+  }
+
+  virtual void OnAddEntry(const net::NetLog::Entry& entry) OVERRIDE {
+    ++count_;
+  }
+
+  int count() const { return count_; }
+
+ private:
+  int count_;
+};
+
+void AddEvent(ChromeNetLog* net_log) {
+  net_log->AddGlobalEntry(net::NetLog::TYPE_CANCELLED);
+}
+
+// A thread that waits until an event has been signalled before calling
+// RunTestThread.
+class ChromeNetLogTestThread : public base::SimpleThread {
+ public:
+  ChromeNetLogTestThread() : base::SimpleThread("ChromeNetLogTest"),
+                             net_log_(NULL),
+                             start_event_(NULL) {
+  }
+
+  // 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() OVERRIDE {
+    start_event_->Wait();
+    RunTestThread();
+  }
+
+  // Subclasses must override this with the code they want to run on their
+  // thread.
+  virtual void RunTestThread() = 0;
+
+ protected:
+  ChromeNetLog* net_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);
+};
+
+// A thread that adds a bunch of events to the NetLog.
+class AddEventsTestThread : public ChromeNetLogTestThread {
+ public:
+  AddEventsTestThread() {}
+  virtual ~AddEventsTestThread() {}
+
+ private:
+  virtual void RunTestThread() OVERRIDE {
+    for (int i = 0; i < kEvents; ++i)
+      AddEvent(net_log_);
+  }
+
+  DISALLOW_COPY_AND_ASSIGN(AddEventsTestThread);
+};
+
+// A thread that adds and removes an observer from the NetLog repeatedly.
+class AddRemoveObserverTestThread : public ChromeNetLogTestThread {
+ public:
+  AddRemoveObserverTestThread() {}
+
+  virtual ~AddRemoveObserverTestThread() {
+    EXPECT_TRUE(!observer_.net_log());
+  }
+
+ private:
+  virtual void RunTestThread() OVERRIDE {
+    for (int i = 0; i < kEvents; ++i) {
+      ASSERT_FALSE(observer_.net_log());
+
+      net_log_->AddThreadSafeObserver(&observer_, net::NetLog::LOG_BASIC);
+      ASSERT_EQ(net_log_, observer_.net_log());
+      ASSERT_EQ(net::NetLog::LOG_BASIC, observer_.log_level());
+
+      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);
+
+      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);
+
+      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();
+  }
+
+  start_event.Signal();
+
+  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());
+}
+
+// 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_NONE, 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_NONE, 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_NONE, 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/chrome_tests_unit.gypi b/chrome/chrome_tests_unit.gypi
index ee3da99..ff6281e 100644
--- a/chrome/chrome_tests_unit.gypi
+++ b/chrome/chrome_tests_unit.gypi
@@ -941,6 +941,7 @@
         'browser/nacl_host/nacl_validation_cache_unittest.cc',
         'browser/nacl_host/pnacl_translation_cache_unittest.cc',
         'browser/net/chrome_fraudulent_certificate_reporter_unittest.cc',
+        'browser/net/chrome_net_log_unittest.cc',
         'browser/net/chrome_network_delegate_unittest.cc',
         'browser/net/connection_tester_unittest.cc',
         'browser/net/dns_probe_job_unittest.cc',
diff --git a/net/base/capturing_net_log.cc b/net/base/capturing_net_log.cc
index f938931..b90dcae 100644
--- a/net/base/capturing_net_log.cc
+++ b/net/base/capturing_net_log.cc
@@ -67,19 +67,20 @@ std::string CapturingNetLog::CapturedEntry::GetParamsJson() const {
   return json;
 }
 
-CapturingNetLog::Observer::Observer() {}
+CapturingNetLog::CapturingNetLog()
+    : last_id_(0),
+      log_level_(LOG_ALL_BUT_BYTES) {
+}
 
-CapturingNetLog::Observer::~Observer() {}
+CapturingNetLog::~CapturingNetLog() {}
 
-void CapturingNetLog::Observer::GetEntries(
-    CapturedEntryList* entry_list) const {
+void CapturingNetLog::GetEntries(CapturedEntryList* entry_list) const {
   base::AutoLock lock(lock_);
   *entry_list = captured_entries_;
 }
 
-void CapturingNetLog::Observer::GetEntriesForSource(
-    NetLog::Source source,
-    CapturedEntryList* entry_list) const {
+void CapturingNetLog::GetEntriesForSource(NetLog::Source source,
+                                          CapturedEntryList* entry_list) const {
   base::AutoLock lock(lock_);
   entry_list->clear();
   for (CapturedEntryList::const_iterator entry = captured_entries_.begin();
@@ -89,17 +90,22 @@ void CapturingNetLog::Observer::GetEntriesForSource(
   }
 }
 
-size_t CapturingNetLog::Observer::GetSize() const {
+size_t CapturingNetLog::GetSize() const {
   base::AutoLock lock(lock_);
   return captured_entries_.size();
 }
 
-void CapturingNetLog::Observer::Clear() {
+void CapturingNetLog::Clear() {
   base::AutoLock lock(lock_);
   captured_entries_.clear();
 }
 
-void CapturingNetLog::Observer::OnAddEntry(const net::NetLog::Entry& entry) {
+void CapturingNetLog::SetLogLevel(NetLog::LogLevel log_level) {
+  base::AutoLock lock(lock_);
+  log_level_ = log_level;
+}
+
+void CapturingNetLog::OnAddEntry(const net::NetLog::Entry& entry) {
   // Only BoundNetLogs without a NetLog should have an invalid source.
   CHECK(entry.source().IsValid());
 
@@ -120,35 +126,29 @@ void CapturingNetLog::Observer::OnAddEntry(const net::NetLog::Entry& entry) {
                     scoped_ptr<DictionaryValue>(param_dict)));
 }
 
-CapturingNetLog::CapturingNetLog() {
-  AddThreadSafeObserver(&capturing_net_log_observer_, LOG_ALL_BUT_BYTES);
-}
-
-CapturingNetLog::~CapturingNetLog() {
-  RemoveThreadSafeObserver(&capturing_net_log_observer_);
+uint32 CapturingNetLog::NextID() {
+  return base::subtle::NoBarrier_AtomicIncrement(&last_id_, 1);
 }
 
-void CapturingNetLog::SetLogLevel(NetLog::LogLevel log_level) {
-  SetObserverLogLevel(&capturing_net_log_observer_, log_level);
-}
-
-void CapturingNetLog::GetEntries(
-    CapturingNetLog::CapturedEntryList* entry_list) const {
-  capturing_net_log_observer_.GetEntries(entry_list);
+NetLog::LogLevel CapturingNetLog::GetLogLevel() const {
+  base::AutoLock lock(lock_);
+  return log_level_;
 }
 
-void CapturingNetLog::GetEntriesForSource(
-    NetLog::Source source,
-    CapturedEntryList* entry_list) const {
-  capturing_net_log_observer_.GetEntriesForSource(source, entry_list);
+void CapturingNetLog::AddThreadSafeObserver(
+    NetLog::ThreadSafeObserver* observer,
+    NetLog::LogLevel log_level) {
+  NOTIMPLEMENTED() << "Not currently used by net unit tests.";
 }
 
-size_t CapturingNetLog::GetSize() const {
-  return capturing_net_log_observer_.GetSize();
+void CapturingNetLog::SetObserverLogLevel(ThreadSafeObserver* observer,
+                                          LogLevel log_level) {
+  NOTIMPLEMENTED() << "Not currently used by net unit tests.";
 }
 
-void CapturingNetLog::Clear() {
-  capturing_net_log_observer_.Clear();
+void CapturingNetLog::RemoveThreadSafeObserver(
+    NetLog::ThreadSafeObserver* observer) {
+  NOTIMPLEMENTED() << "Not currently used by net unit tests.";
 }
 
 CapturingBoundNetLog::CapturingBoundNetLog()
diff --git a/net/base/capturing_net_log.h b/net/base/capturing_net_log.h
index d23beb9..d3586d1 100644
--- a/net/base/capturing_net_log.h
+++ b/net/base/capturing_net_log.h
@@ -23,10 +23,9 @@ class DictionaryValue;
 
 namespace net {
 
-// CapturingNetLog is a NetLog which instantiates Observer that saves messages
-// to a bounded buffer.  It is intended for testing only, and is part of the
-// net_test_support project. This is provided for convinience and compatilbility
-// with the old unittests.
+// CapturingNetLog is an implementation of NetLog that saves messages to a
+// bounded buffer.  It is intended for testing only, and is part of the
+// net_test_support project.
 class CapturingNetLog : public NetLog {
  public:
   struct CapturedEntry {
@@ -72,48 +71,40 @@ class CapturingNetLog : public NetLog {
   CapturingNetLog();
   virtual ~CapturingNetLog();
 
-  void SetLogLevel(LogLevel log_level);
-
-  // Below methods are forwarded to capturing_net_log_observer_.
+  // Returns the list of all entries in the log.
   void GetEntries(CapturedEntryList* entry_list) const;
-  void GetEntriesForSource(Source source, CapturedEntryList* entry_list) const;
-  size_t GetSize() const;
-  void Clear();
 
- private:
-  // Observer is an implementation of NetLog::ThreadSafeObserver
-  // that saves messages to a bounded buffer. It is intended for testing only,
-  // and is part of the net_test_support project.
-  class Observer : public NetLog::ThreadSafeObserver {
-   public:
-    Observer();
-    virtual ~Observer();
-
-    // Returns the list of all entries in the log.
-    void GetEntries(CapturedEntryList* entry_list) const;
+  // Fills |entry_list| with all entries in the log from the specified Source.
+  void GetEntriesForSource(NetLog::Source source,
+                           CapturedEntryList* entry_list) const;
 
-    // Fills |entry_list| with all entries in the log from the specified Source.
-    void GetEntriesForSource(Source source,
-                             CapturedEntryList* entry_list) const;
+  // Returns number of entries in the log.
+  size_t GetSize() const;
 
-    // Returns number of entries in the log.
-    size_t GetSize() const;
+  void Clear();
 
-    void Clear();
+  void SetLogLevel(NetLog::LogLevel log_level);
 
-   private:
-    // ThreadSafeObserver implementation:
-    virtual void OnAddEntry(const Entry& entry) OVERRIDE;
+  // NetLog implementation:
+  virtual void OnAddEntry(const net::NetLog::Entry& entry) 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;
 
-    // Needs to be "mutable" so can use it in GetEntries().
-    mutable base::Lock lock_;
+ private:
+  // Needs to be "mutable" so can use it in GetEntries().
+  mutable base::Lock lock_;
 
-    CapturedEntryList captured_entries_;
+  // Last assigned source ID.  Incremented to get the next one.
+  base::subtle::Atomic32 last_id_;
 
-    DISALLOW_COPY_AND_ASSIGN(Observer);
-  };
+  CapturedEntryList captured_entries_;
 
-  Observer capturing_net_log_observer_;
+  NetLog::LogLevel log_level_;
 
   DISALLOW_COPY_AND_ASSIGN(CapturingNetLog);
 };
diff --git a/net/base/net_log.cc b/net/base/net_log.cc
index 1b61698..0ca551e 100644
--- a/net/base/net_log.cc
+++ b/net/base/net_log.cc
@@ -187,15 +187,6 @@ NetLog* NetLog::ThreadSafeObserver::net_log() const {
   return net_log_;
 }
 
-NetLog::NetLog()
-    : last_id_(0),
-      base_log_level_(LOG_NONE),
-      effective_log_level_(LOG_NONE) {
-}
-
-NetLog::~NetLog() {
-}
-
 void NetLog::AddGlobalEntry(EventType type) {
   AddEntry(type,
            Source(net::NetLog::SOURCE_NONE, NextID()),
@@ -212,73 +203,6 @@ void NetLog::AddGlobalEntry(
            &parameters_callback);
 }
 
-uint32 NetLog::NextID() {
-  return base::subtle::NoBarrier_AtomicIncrement(&last_id_, 1);
-}
-
-void NetLog::SetBaseLogLevel(LogLevel log_level) {
-  base::AutoLock lock(lock_);
-  base_log_level_ = log_level;
-
-  UpdateLogLevel();
-}
-
-NetLog::LogLevel NetLog::GetLogLevel() const {
-  base::subtle::Atomic32 log_level =
-      base::subtle::NoBarrier_Load(&effective_log_level_);
-  return static_cast<net::NetLog::LogLevel>(log_level);
-}
-
-void NetLog::AddThreadSafeObserver(
-    net::NetLog::ThreadSafeObserver* observer,
-    LogLevel log_level) {
-  base::AutoLock lock(lock_);
-
-  DCHECK(!observer->net_log_);
-  observers_.AddObserver(observer);
-  observer->net_log_ = this;
-  observer->log_level_ = log_level;
-  UpdateLogLevel();
-}
-
-void NetLog::SetObserverLogLevel(
-    net::NetLog::ThreadSafeObserver* observer,
-    LogLevel log_level) {
-  base::AutoLock lock(lock_);
-
-  DCHECK(observers_.HasObserver(observer));
-  DCHECK_EQ(this, observer->net_log_);
-  observer->log_level_ = log_level;
-  UpdateLogLevel();
-}
-
-void NetLog::RemoveThreadSafeObserver(
-    net::NetLog::ThreadSafeObserver* observer) {
-  base::AutoLock lock(lock_);
-
-  DCHECK(observers_.HasObserver(observer));
-  DCHECK_EQ(this, observer->net_log_);
-  observers_.RemoveObserver(observer);
-  observer->net_log_ = NULL;
-  UpdateLogLevel();
-}
-
-void NetLog::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 new_effective_log_level = base_log_level_;
-  ObserverListBase<ThreadSafeObserver>::Iterator it(observers_);
-  ThreadSafeObserver* observer;
-  while ((observer = it.GetNext()) != NULL) {
-    new_effective_log_level =
-        std::min(new_effective_log_level, observer->log_level());
-  }
-  base::subtle::NoBarrier_Store(&effective_log_level_,
-                                new_effective_log_level);
-}
-
 // static
 std::string NetLog::TickCountToString(const base::TimeTicks& time) {
   int64 delta_time = (time - base::TimeTicks()).InMilliseconds();
@@ -377,6 +301,23 @@ NetLog::ParametersCallback NetLog::StringCallback(const char* name,
   return base::Bind(&NetLogString16Callback, name, value);
 }
 
+void NetLog::OnAddObserver(ThreadSafeObserver* observer, LogLevel log_level) {
+  DCHECK(!observer->net_log_);
+  observer->net_log_ = this;
+  observer->log_level_ = log_level;
+}
+
+void NetLog::OnSetObserverLogLevel(ThreadSafeObserver* observer,
+                                   LogLevel log_level) {
+  DCHECK_EQ(this, observer->net_log_);
+  observer->log_level_ = log_level;
+}
+
+void NetLog::OnRemoveObserver(ThreadSafeObserver* observer) {
+  DCHECK_EQ(this, observer->net_log_);
+  observer->net_log_ = NULL;
+}
+
 void NetLog::AddEntry(EventType type,
                       const Source& source,
                       EventPhase phase,
@@ -386,10 +327,7 @@ void NetLog::AddEntry(EventType type,
     return;
   Entry entry(type, source, phase, base::TimeTicks::Now(),
               parameters_callback, log_level);
-
-  // Notify all of the log observers.
-  base::AutoLock lock(lock_);
-  FOR_EACH_OBSERVER(ThreadSafeObserver, observers_, OnAddEntry(entry));
+  OnAddEntry(entry);
 }
 
 void BoundNetLog::AddEntry(NetLog::EventType type,
diff --git a/net/base/net_log.h b/net/base/net_log.h
index fb5637d..8ae33e9 100644
--- a/net/base/net_log.h
+++ b/net/base/net_log.h
@@ -7,13 +7,10 @@
 
 #include <string>
 
-#include "base/atomicops.h"
 #include "base/basictypes.h"
 #include "base/callback_forward.h"
 #include "base/compiler_specific.h"
-#include "base/observer_list.h"
 #include "base/string16.h"
-#include "base/synchronization/lock.h"
 #include "base/time.h"
 #include "net/base/net_export.h"
 
@@ -201,8 +198,8 @@ class NET_EXPORT NetLog {
     DISALLOW_COPY_AND_ASSIGN(ThreadSafeObserver);
   };
 
-  NetLog();
-  virtual ~NetLog();
+  NetLog() {}
+  virtual ~NetLog() {}
 
   // Emits a global event to the log stream, with its own unique source ID.
   void AddGlobalEntry(EventType type);
@@ -211,11 +208,11 @@ class NET_EXPORT NetLog {
 
   // Returns a unique ID which can be used as a source ID.  All returned IDs
   // will be unique and greater than 0.
-  uint32 NextID();
+  virtual uint32 NextID() = 0;
 
   // Returns the logging level for this NetLog. This is used to avoid computing
   // and saving expensive log entries.
-  LogLevel GetLogLevel() const;
+  virtual LogLevel GetLogLevel() const = 0;
 
   // Adds an observer and sets its log level.  The observer must not be
   // watching any NetLog, including this one, when this is called.
@@ -227,19 +224,21 @@ class NET_EXPORT NetLog {
   //
   // NetLog implementations must call NetLog::OnAddObserver to update the
   // observer's internal state.
-  void AddThreadSafeObserver(ThreadSafeObserver* observer, LogLevel log_level);
+  virtual void AddThreadSafeObserver(ThreadSafeObserver* observer,
+                                     LogLevel log_level) = 0;
 
   // Sets the log level of |observer| to |log_level|.  |observer| must be
   // watching |this|.  NetLog implementations must call
   // NetLog::OnSetObserverLogLevel to update the observer's internal state.
-  void SetObserverLogLevel(ThreadSafeObserver* observer, LogLevel log_level);
+  virtual void SetObserverLogLevel(ThreadSafeObserver* observer,
+                                   LogLevel log_level) = 0;
 
   // Removes an observer.  NetLog implementations must call
   // NetLog::OnAddObserver to update the observer's internal state.
   //
   // For thread safety reasons, it is recommended that this not be called in
   // an object's destructor.
-  void RemoveThreadSafeObserver(ThreadSafeObserver* observer);
+  virtual void RemoveThreadSafeObserver(ThreadSafeObserver* observer) = 0;
 
   // Converts a time to the string format that the NetLog uses to represent
   // times.  Strings are used since integers may overflow.
@@ -294,8 +293,16 @@ class NET_EXPORT NetLog {
                                            const base::string16* value);
 
  protected:
-  // Set the lowest allowed log level, regardless of any Observers.
-  void SetBaseLogLevel(LogLevel log_level);
+  // Child classes should respond to the new entry here.  This includes
+  // creating the Entry object and alerting their observers.
+  virtual void OnAddEntry(const Entry& entry) = 0;
+
+  // Subclasses must call these in the corresponding functions to set an
+  // observer's |net_log_| and |log_level_| values.
+  void OnAddObserver(ThreadSafeObserver* observer, LogLevel log_level);
+  void OnSetObserverLogLevel(ThreadSafeObserver* observer,
+                             LogLevel log_level);
+  void OnRemoveObserver(ThreadSafeObserver* observer);
 
  private:
   friend class BoundNetLog;
@@ -305,26 +312,6 @@ class NET_EXPORT NetLog {
                 EventPhase phase,
                 const NetLog::ParametersCallback* parameters_callback);
 
-  // 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_|.
-  base::Lock lock_;
-
-  // Last assigned source ID.  Incremented to get the next one.
-  base::subtle::Atomic32 last_id_;
-
-  // The lowest allowed log level, regardless of any Observers.
-  // Normally defaults to LOG_NONE, but can be changed with SetBaseLogLevel
-  LogLevel base_log_level_;
-
-  // The current log level.
-  base::subtle::Atomic32 effective_log_level_;
-
-  // |lock_| must be acquired whenever reading or writing to this.
-  ObserverList<ThreadSafeObserver, true> observers_;
-
   DISALLOW_COPY_AND_ASSIGN(NetLog);
 };
 
diff --git a/net/base/net_log_unittest.cc b/net/base/net_log_unittest.cc
index 7a98f79..d52f3b7 100644
--- a/net/base/net_log_unittest.cc
+++ b/net/base/net_log_unittest.cc
@@ -5,8 +5,6 @@
 #include "net/base/net_log_unittest.h"
 
 #include "base/bind.h"
-#include "base/synchronization/waitable_event.h"
-#include "base/threading/simple_thread.h"
 #include "base/values.h"
 #include "net/base/net_errors.h"
 
@@ -14,9 +12,6 @@ namespace net {
 
 namespace {
 
-const int kThreads = 10;
-const int kEvents = 100;
-
 base::Value* NetLogLevelCallback(NetLog::LogLevel log_level) {
   base::DictionaryValue* dict = new base::DictionaryValue();
   dict->SetInteger("log_level", log_level);
@@ -25,7 +20,7 @@ base::Value* NetLogLevelCallback(NetLog::LogLevel log_level) {
 
 TEST(NetLogTest, Basic) {
   CapturingNetLog net_log;
-  CapturingNetLog::CapturedEntryList entries;
+  net::CapturingNetLog::CapturedEntryList entries;
   net_log.GetEntries(&entries);
   EXPECT_EQ(0u, entries.size());
 
@@ -53,7 +48,7 @@ TEST(NetLogTest, LogLevels) {
     net_log.AddGlobalEntry(NetLog::TYPE_SOCKET_ALIVE,
                            base::Bind(NetLogLevelCallback));
 
-    CapturingNetLog::CapturedEntryList entries;
+    net::CapturingNetLog::CapturedEntryList entries;
     net_log.GetEntries(&entries);
 
     if (log_level == NetLog::LOG_NONE) {
@@ -75,262 +70,6 @@ TEST(NetLogTest, LogLevels) {
   }
 }
 
-class CountingObserver : public NetLog::ThreadSafeObserver {
- public:
-  CountingObserver() : count_(0) {}
-
-  virtual ~CountingObserver() {
-    if (net_log())
-      net_log()->RemoveThreadSafeObserver(this);
-  }
-
-  virtual void OnAddEntry(const NetLog::Entry& entry) OVERRIDE {
-    ++count_;
-  }
-
-  int count() const { return count_; }
-
- private:
-  int count_;
-};
-
-void AddEvent(NetLog* net_log) {
-  net_log->AddGlobalEntry(NetLog::TYPE_CANCELLED);
-}
-
-// A thread that waits until an event has been signalled before calling
-// RunTestThread.
-class NetLogTestThread : public base::SimpleThread {
- public:
-  NetLogTestThread()
-      : base::SimpleThread("NetLogTest"),
-        net_log_(NULL),
-        start_event_(NULL) {
-  }
-
-  // We'll wait for |start_event| to be triggered before calling a subclass's
-  // subclass's RunTestThread() function.
-  void Init(NetLog* net_log, base::WaitableEvent* start_event) {
-    start_event_ = start_event;
-    net_log_ = net_log;
-  }
-
-  virtual void Run() OVERRIDE {
-    start_event_->Wait();
-    RunTestThread();
-  }
-
-  // Subclasses must override this with the code they want to run on their
-  // thread.
-  virtual void RunTestThread() = 0;
-
- protected:
-  NetLog* net_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(NetLogTestThread);
-};
-
-// A thread that adds a bunch of events to the NetLog.
-class AddEventsTestThread : public NetLogTestThread {
- public:
-  AddEventsTestThread() {}
-  virtual ~AddEventsTestThread() {}
-
- private:
-  virtual void RunTestThread() OVERRIDE {
-    for (int i = 0; i < kEvents; ++i)
-      AddEvent(net_log_);
-  }
-
-  DISALLOW_COPY_AND_ASSIGN(AddEventsTestThread);
-};
-
-// A thread that adds and removes an observer from the NetLog repeatedly.
-class AddRemoveObserverTestThread : public NetLogTestThread {
- public:
-  AddRemoveObserverTestThread() {}
-
-  virtual ~AddRemoveObserverTestThread() {
-    EXPECT_TRUE(!observer_.net_log());
-  }
-
- private:
-  virtual void RunTestThread() OVERRIDE {
-    for (int i = 0; i < kEvents; ++i) {
-      ASSERT_FALSE(observer_.net_log());
-
-      net_log_->AddThreadSafeObserver(&observer_, NetLog::LOG_BASIC);
-      ASSERT_EQ(net_log_, observer_.net_log());
-      ASSERT_EQ(NetLog::LOG_BASIC, observer_.log_level());
-
-      net_log_->SetObserverLogLevel(&observer_, NetLog::LOG_ALL_BUT_BYTES);
-      ASSERT_EQ(net_log_, observer_.net_log());
-      ASSERT_EQ(NetLog::LOG_ALL_BUT_BYTES, observer_.log_level());
-      ASSERT_LE(net_log_->GetLogLevel(), NetLog::LOG_ALL_BUT_BYTES);
-
-      net_log_->SetObserverLogLevel(&observer_, NetLog::LOG_ALL);
-      ASSERT_EQ(net_log_, observer_.net_log());
-      ASSERT_EQ(NetLog::LOG_ALL, observer_.log_level());
-      ASSERT_LE(net_log_->GetLogLevel(), NetLog::LOG_ALL);
-
-      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(NetLog* 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();
-  }
-
-  start_event.Signal();
-
-  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(NetLogTest, NetLogEventThreads) {
-  NetLog 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], 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());
-}
-
-// Test adding and removing a single observer.
-TEST(NetLogTest, NetLogAddRemoveObserver) {
-  NetLog net_log;
-  CountingObserver observer;
-
-  AddEvent(&net_log);
-  EXPECT_EQ(0, observer.count());
-  EXPECT_EQ(NULL, observer.net_log());
-  EXPECT_EQ(NetLog::LOG_NONE, net_log.GetLogLevel());
-
-  // Add the observer and add an event.
-  net_log.AddThreadSafeObserver(&observer, NetLog::LOG_BASIC);
-  EXPECT_EQ(&net_log, observer.net_log());
-  EXPECT_EQ(NetLog::LOG_BASIC, observer.log_level());
-  EXPECT_EQ(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, NetLog::LOG_ALL);
-  EXPECT_EQ(&net_log, observer.net_log());
-  EXPECT_EQ(NetLog::LOG_ALL, observer.log_level());
-  EXPECT_EQ(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(NetLog::LOG_NONE, 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, NetLog::LOG_ALL);
-  EXPECT_EQ(&net_log, observer.net_log());
-  EXPECT_EQ(NetLog::LOG_ALL, observer.log_level());
-  EXPECT_EQ(NetLog::LOG_ALL, net_log.GetLogLevel());
-
-  AddEvent(&net_log);
-  EXPECT_EQ(3, observer.count());
-}
-
-// Test adding and removing two observers.
-TEST(NetLogTest, NetLogTwoObservers) {
-  NetLog net_log;
-  CountingObserver observer[2];
-
-  // Add first observer.
-  net_log.AddThreadSafeObserver(&observer[0], NetLog::LOG_ALL_BUT_BYTES);
-  EXPECT_EQ(&net_log, observer[0].net_log());
-  EXPECT_EQ(NULL, observer[1].net_log());
-  EXPECT_EQ(NetLog::LOG_ALL_BUT_BYTES, observer[0].log_level());
-  EXPECT_EQ(NetLog::LOG_ALL_BUT_BYTES, net_log.GetLogLevel());
-
-  // Add second observer observer.
-  net_log.AddThreadSafeObserver(&observer[1], NetLog::LOG_ALL);
-  EXPECT_EQ(&net_log, observer[0].net_log());
-  EXPECT_EQ(&net_log, observer[1].net_log());
-  EXPECT_EQ(NetLog::LOG_ALL_BUT_BYTES, observer[0].log_level());
-  EXPECT_EQ(NetLog::LOG_ALL, observer[1].log_level());
-  EXPECT_EQ(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(NetLog::LOG_ALL_BUT_BYTES, observer[0].log_level());
-  EXPECT_EQ(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(NetLog::LOG_NONE, 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(NetLogTest, NetLogAddRemoveObserverThreads) {
-  NetLog 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
 
 }  // namespace net
diff --git a/net/tools/gdig/file_net_log.cc b/net/tools/gdig/file_net_log.cc
index 7c755c8..51cf78d 100644
--- a/net/tools/gdig/file_net_log.cc
+++ b/net/tools/gdig/file_net_log.cc
@@ -12,20 +12,24 @@
 
 namespace net {
 
-FileNetLogObserver::FileNetLogObserver(FILE* destination)
-    : destination_(destination) {
+FileNetLog::FileNetLog(FILE* destination, LogLevel level)
+    : log_level_(level),
+      destination_(destination) {
   DCHECK(destination != NULL);
+  // Without calling GetNext() once here, the first GetNext will return 0
+  // that is not a valid id.
+  sequence_number_.GetNext();
 }
 
-FileNetLogObserver::~FileNetLogObserver() {
+FileNetLog::~FileNetLog() {
 }
 
-void FileNetLogObserver::OnAddEntry(const net::NetLog::Entry& entry) {
+void FileNetLog::OnAddEntry(const net::NetLog::Entry& entry) {
   // Only BoundNetLogs without a NetLog should have an invalid source.
   DCHECK(entry.source().IsValid());
 
-  const char* source = NetLog::SourceTypeToString(entry.source().type);
-  const char* type = NetLog::EventTypeToString(entry.type());
+  const char* source = SourceTypeToString(entry.source().type);
+  const char* type = EventTypeToString(entry.type());
 
   scoped_ptr<Value> param_value(entry.ParametersToValue());
   std::string params;
@@ -45,4 +49,28 @@ void FileNetLogObserver::OnAddEntry(const net::NetLog::Entry& entry) {
           entry.source().id, source, type, params.c_str());
 }
 
+uint32 FileNetLog::NextID() {
+  return sequence_number_.GetNext();
+}
+
+NetLog::LogLevel FileNetLog::GetLogLevel() const {
+  return log_level_;
+}
+
+void FileNetLog::AddThreadSafeObserver(
+    NetLog::ThreadSafeObserver* observer,
+    NetLog::LogLevel log_level) {
+  NOTIMPLEMENTED() << "Not currently used by gdig.";
+}
+
+void FileNetLog::SetObserverLogLevel(ThreadSafeObserver* observer,
+                                          LogLevel log_level) {
+  NOTIMPLEMENTED() << "Not currently used by gdig.";
+}
+
+void FileNetLog::RemoveThreadSafeObserver(
+    NetLog::ThreadSafeObserver* observer) {
+  NOTIMPLEMENTED() << "Not currently used by gdig.";
+}
+
 }  // namespace net
diff --git a/net/tools/gdig/file_net_log.h b/net/tools/gdig/file_net_log.h
index 1ad78f1..cb80380 100644
--- a/net/tools/gdig/file_net_log.h
+++ b/net/tools/gdig/file_net_log.h
@@ -7,6 +7,7 @@
 
 #include <string>
 
+#include "base/atomic_sequence_num.h"
 #include "base/basictypes.h"
 #include "base/synchronization/lock.h"
 #include "base/time.h"
@@ -14,18 +15,27 @@
 
 namespace net {
 
-// FileNetLogObserver is a simple implementation of NetLog::ThreadSafeObserver
-// that prints out all the events received into the stream passed
-// to the constructor.
-class FileNetLogObserver : public NetLog::ThreadSafeObserver {
+// FileNetLog is a simple implementation of NetLog that prints out all
+// the events received into the stream passed to the constructor.
+class FileNetLog : public NetLog {
  public:
-  explicit FileNetLogObserver(FILE* destination);
-  virtual ~FileNetLogObserver();
+  explicit FileNetLog(FILE* destination, LogLevel level);
+  virtual ~FileNetLog();
 
-  // NetLog::ThreadSafeObserver implementation:
+ private:
+  // NetLog implementation:
   virtual void OnAddEntry(const net::NetLog::Entry& entry) 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;
+
+  base::AtomicSequenceNumber sequence_number_;
+  const NetLog::LogLevel log_level_;
 
- private:
   FILE* const destination_;
   base::Lock lock_;
 
diff --git a/net/tools/gdig/gdig.cc b/net/tools/gdig/gdig.cc
index 7cbb9a4..1640408 100644
--- a/net/tools/gdig/gdig.cc
+++ b/net/tools/gdig/gdig.cc
@@ -182,7 +182,6 @@ bool LoadReplayLog(const base::FilePath& file_path, ReplayLog* replay_log) {
 class GDig {
  public:
   GDig();
-  ~GDig();
 
   enum Result {
     RESULT_NO_RESOLVE = -3,
@@ -220,8 +219,7 @@ class GDig {
 
   base::CancelableClosure timeout_closure_;
   scoped_ptr<DnsConfigService> dns_config_service_;
-  scoped_ptr<FileNetLogObserver> log_observer_;
-  scoped_ptr<NetLog> log_;
+  scoped_ptr<FileNetLog> log_;
   scoped_ptr<HostResolver> resolver_;
 };
 
@@ -234,11 +232,6 @@ GDig::GDig()
       active_resolves_(0) {
 }
 
-GDig::~GDig() {
-  if (log_)
-    log_->RemoveThreadSafeObserver(log_observer_.get());
-}
-
 GDig::Result GDig::Main(int argc, const char* argv[]) {
   if (!ParseCommandLine(argc, argv)) {
       fprintf(stderr,
@@ -306,9 +299,7 @@ bool GDig::ParseCommandLine(int argc, const char* argv[]) {
         return false;
       }
     }
-    log_.reset(new NetLog);
-    log_observer_.reset(new FileNetLogObserver(stderr));
-    log_->AddThreadSafeObserver(log_observer_.get(), level);
+    log_.reset(new FileNetLog(stderr, level));
   }
 
   print_config_ = parsed_command_line.HasSwitch("print_config");
diff --git a/net/tools/get_server_time/get_server_time.cc b/net/tools/get_server_time/get_server_time.cc
index 1fca24e..df9e3fc 100644
--- a/net/tools/get_server_time/get_server_time.cc
+++ b/net/tools/get_server_time/get_server_time.cc
@@ -103,18 +103,14 @@ class QuitDelegate : public net::URLFetcherDelegate {
   DISALLOW_COPY_AND_ASSIGN(QuitDelegate);
 };
 
-// NetLog::ThreadSafeObserver implementation that simply prints events
-// to the logs.
-class PrintingLogObserver : public net::NetLog::ThreadSafeObserver {
+// NetLog implementation that simply prints events to the logs.
+class PrintingLog : public net::NetLog {
  public:
-  PrintingLogObserver() {}
+  PrintingLog() : next_id_(1) {}
 
-  virtual ~PrintingLogObserver() {
-    // This is guaranteed to be safe as this program is single threaded.
-    net_log()->RemoveThreadSafeObserver(this);
-  }
+  virtual ~PrintingLog() {}
 
-  // NetLog::ThreadSafeObserver implementation:
+  // NetLog implementation:
   virtual void OnAddEntry(const net::NetLog::Entry& entry) OVERRIDE {
     // The log level of the entry is unknown, so just assume it maps
     // to VLOG(1).
@@ -138,13 +134,43 @@ class PrintingLogObserver : public net::NetLog::ThreadSafeObserver {
             << event_type << ": " << event_phase << params_str;
   }
 
+  virtual uint32 NextID() OVERRIDE {
+    return next_id_++;
+  }
+
+  virtual LogLevel GetLogLevel() const OVERRIDE {
+    const int vlog_level = logging::GetVlogLevel(__FILE__);
+    if (vlog_level <= 0) {
+      return LOG_BASIC;
+    }
+    if (vlog_level == 1) {
+      return LOG_ALL_BUT_BYTES;
+    }
+    return LOG_ALL;
+  }
+
+  virtual void AddThreadSafeObserver(ThreadSafeObserver* observer,
+                                     LogLevel log_level) OVERRIDE {
+    NOTIMPLEMENTED();
+  }
+
+  virtual void SetObserverLogLevel(ThreadSafeObserver* observer,
+                                   LogLevel log_level) OVERRIDE {
+    NOTIMPLEMENTED();
+  }
+
+  virtual void RemoveThreadSafeObserver(ThreadSafeObserver* observer) OVERRIDE {
+    NOTIMPLEMENTED();
+  }
+
  private:
-  DISALLOW_COPY_AND_ASSIGN(PrintingLogObserver);
+  uint32 next_id_;
+
+  DISALLOW_COPY_AND_ASSIGN(PrintingLog);
 };
 
 // Builds a URLRequestContext assuming there's only a single loop.
-scoped_ptr<net::URLRequestContext>
-BuildURLRequestContext(net::NetLog* net_log) {
+scoped_ptr<net::URLRequestContext> BuildURLRequestContext() {
   net::URLRequestContextBuilder builder;
 #if defined(OS_LINUX)
   // On Linux, use a fixed ProxyConfigService, since the default one
@@ -155,7 +181,7 @@ BuildURLRequestContext(net::NetLog* net_log) {
       new net::ProxyConfigServiceFixed(net::ProxyConfig()));
 #endif
   scoped_ptr<net::URLRequestContext> context(builder.Build());
-  context->set_net_log(net_log);
+  context->set_net_log(new PrintingLog());
   return context.Pass();
 }
 
@@ -163,10 +189,9 @@ class SingleThreadRequestContextGetter : public net::URLRequestContextGetter {
  public:
   // Since there's only a single thread, there's no need to worry
   // about when |context_| gets created.
-  SingleThreadRequestContextGetter(
-      net::NetLog* net_log,
+  explicit SingleThreadRequestContextGetter(
       const scoped_refptr<base::SingleThreadTaskRunner>& main_task_runner)
-      : context_(BuildURLRequestContext(net_log)),
+      : context_(BuildURLRequestContext()),
         main_task_runner_(main_task_runner) {}
 
   virtual net::URLRequestContext* GetURLRequestContext() OVERRIDE {
@@ -256,16 +281,8 @@ int main(int argc, char* argv[]) {
   // which causes the DNS resolution to abort.  It's simpler to just
   // not instantiate one, since only a single request is sent anyway.
 
-  // The declaration order for net_log and printing_log_observer is
-  // important. The destructor of PrintingLogObserver removes itself
-  // from net_log, so net_log must be available for entire lifetime of
-  // printing_log_observer.
-  net::NetLog net_log;
-  PrintingLogObserver printing_log_observer;
-  net_log.AddThreadSafeObserver(&printing_log_observer, net::NetLog::LOG_ALL);
   scoped_refptr<SingleThreadRequestContextGetter> context_getter(
-      new SingleThreadRequestContextGetter(&net_log,
-                                           main_loop.message_loop_proxy()));
+      new SingleThreadRequestContextGetter(main_loop.message_loop_proxy()));
 
   QuitDelegate delegate;
   scoped_ptr<net::URLFetcher> fetcher(
diff --git a/remoting/host/vlog_net_log.cc b/remoting/host/vlog_net_log.cc
index 2e2e436..05e9a35 100644
--- a/remoting/host/vlog_net_log.cc
+++ b/remoting/host/vlog_net_log.cc
@@ -13,25 +13,13 @@
 
 namespace remoting {
 
-class VlogNetLog::Observer : public net::NetLog::ThreadSafeObserver {
- public:
-  Observer();
-  virtual ~Observer();
-
-  // NetLog::ThreadSafeObserver overrides:
-  virtual void OnAddEntry(const net::NetLog::Entry& entry) OVERRIDE;
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(Observer);
-};
-
-VlogNetLog::Observer::Observer() {
+VlogNetLog::VlogNetLog() : id_(0) {
 }
 
-VlogNetLog::Observer::~Observer() {
+VlogNetLog::~VlogNetLog() {
 }
 
-void VlogNetLog::Observer::OnAddEntry(const net::NetLog::Entry& entry) {
+void VlogNetLog::OnAddEntry(const NetLog::Entry& entry) {
   if (VLOG_IS_ON(4)) {
     scoped_ptr<Value> value(entry.ToValue());
     std::string json;
@@ -40,13 +28,27 @@ void VlogNetLog::Observer::OnAddEntry(const net::NetLog::Entry& entry) {
   }
 }
 
-VlogNetLog::VlogNetLog()
-    : observer_(new Observer()) {
-  AddThreadSafeObserver(observer_.get(), LOG_ALL_BUT_BYTES);
+uint32 VlogNetLog::NextID() {
+  // TODO(mmenke):  Make this threadsafe and start with 1 instead of 0.
+  return id_++;
 }
 
-VlogNetLog::~VlogNetLog() {
-  RemoveThreadSafeObserver(observer_.get());
+net::NetLog::LogLevel VlogNetLog::GetLogLevel() const {
+  return LOG_ALL_BUT_BYTES;
+}
+
+void VlogNetLog::AddThreadSafeObserver(ThreadSafeObserver* observer,
+                                      net::NetLog::LogLevel log_level) {
+  NOTIMPLEMENTED();
+}
+
+void VlogNetLog::SetObserverLogLevel(ThreadSafeObserver* observer,
+                                    net::NetLog::LogLevel log_level) {
+  NOTIMPLEMENTED();
+}
+
+void VlogNetLog::RemoveThreadSafeObserver(ThreadSafeObserver* observer) {
+  NOTIMPLEMENTED();
 }
 
 }  // namespace remoting
diff --git a/remoting/host/vlog_net_log.h b/remoting/host/vlog_net_log.h
index 393ab1c..d056a3a 100644
--- a/remoting/host/vlog_net_log.h
+++ b/remoting/host/vlog_net_log.h
@@ -6,7 +6,6 @@
 #define REMOTING_HOST_VLOG_NET_LOG_H_
 
 #include "base/memory/scoped_handle.h"
-#include "base/memory/scoped_ptr.h"
 #include "net/base/net_log.h"
 
 namespace remoting {
@@ -20,9 +19,18 @@ class VlogNetLog : public net::NetLog {
   VlogNetLog();
   virtual ~VlogNetLog();
 
+  // NetLog overrides:
+  virtual void OnAddEntry(const NetLog::Entry& entry) 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;
+
  private:
-  class Observer;
-  scoped_ptr<Observer> observer_;
+  uint32 id_;
 
   DISALLOW_COPY_AND_ASSIGN(VlogNetLog);
 };