Remove ChromeNetLog depenency from content/browser/debugger

Revert r94208 (re-land r94196), add missing NET_API decl.

TBR=willchan@chromium.org
BUG=84078
TEST=everything compiles

Review URL: http://codereview.chromium.org/7477035

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

24 files changed, 267 insertions, 119 deletions

diff --git a/chrome/browser/chrome_content_browser_client.cc b/chrome/browser/chrome_content_browser_client.cc
index c77cd39..7ea7bbc 100644
--- a/chrome/browser/chrome_content_browser_client.cc
+++ b/chrome/browser/chrome_content_browser_client.cc
@@ -21,6 +21,7 @@
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_web_ui.h"
 #include "chrome/browser/google/google_util.h"
+#include "chrome/browser/net/chrome_net_log.h"
 #include "chrome/browser/notifications/desktop_notification_service.h"
 #include "chrome/browser/notifications/desktop_notification_service_factory.h"
 #include "chrome/browser/platform_util.h"
@@ -689,6 +690,10 @@ DevToolsManager* ChromeContentBrowserClient::GetDevToolsManager() {
   return g_browser_process->devtools_manager();
 }
 
+net::NetLog* ChromeContentBrowserClient::GetNetLog() {
+  return g_browser_process->net_log();
+}
+
 bool ChromeContentBrowserClient::IsFastShutdownPossible() {
   const CommandLine& browser_command_line = *CommandLine::ForCurrentProcess();
   return !browser_command_line.HasSwitch(switches::kChromeFrame);
diff --git a/chrome/browser/chrome_content_browser_client.h b/chrome/browser/chrome_content_browser_client.h
index cfbd2d9..6de30f3 100644
--- a/chrome/browser/chrome_content_browser_client.h
+++ b/chrome/browser/chrome_content_browser_client.h
@@ -94,6 +94,7 @@ class ChromeContentBrowserClient : public content::ContentBrowserClient {
   virtual ui::Clipboard* GetClipboard() OVERRIDE;
   virtual MHTMLGenerationManager* GetMHTMLGenerationManager() OVERRIDE;
   virtual DevToolsManager* GetDevToolsManager() OVERRIDE;
+  virtual net::NetLog* GetNetLog() OVERRIDE;
   virtual bool IsFastShutdownPossible() OVERRIDE;
   virtual WebPreferences GetWebkitPrefs(Profile* profile,
                                         bool is_web_ui) OVERRIDE;
diff --git a/chrome/browser/net/chrome_net_log.cc b/chrome/browser/net/chrome_net_log.cc
index 3c9625d..212dc46 100644
--- a/chrome/browser/net/chrome_net_log.cc
+++ b/chrome/browser/net/chrome_net_log.cc
@@ -16,32 +16,72 @@
 #include "chrome/browser/net/passive_log_collector.h"
 #include "chrome/common/chrome_switches.h"
 
-ChromeNetLog::ThreadSafeObserver::ThreadSafeObserver(LogLevel log_level)
+ChromeNetLog::ThreadSafeObserverImpl::ThreadSafeObserverImpl(LogLevel log_level)
     : net_log_(NULL),
-      log_level_(log_level) {
+      ALLOW_THIS_IN_INITIALIZER_LIST(internal_observer_(this, log_level)) {
 }
 
-ChromeNetLog::ThreadSafeObserver::~ThreadSafeObserver() {
+ChromeNetLog::ThreadSafeObserverImpl::~ThreadSafeObserverImpl() {
   DCHECK(!net_log_);
 }
 
-net::NetLog::LogLevel ChromeNetLog::ThreadSafeObserver::log_level() const {
-  return log_level_;
+void ChromeNetLog::ThreadSafeObserverImpl::AddAsObserver(
+    ChromeNetLog* net_log) {
+  DCHECK(!net_log_);
+  net_log_ = net_log;
+  net_log_->AddThreadSafeObserver(&internal_observer_);
 }
 
-void ChromeNetLog::ThreadSafeObserver::AssertNetLogLockAcquired() const {
-  if (net_log_)
-    net_log_->lock_.AssertAcquired();
+void ChromeNetLog::ThreadSafeObserverImpl::RemoveAsObserver() {
+  DCHECK(net_log_);
+  net_log_->RemoveThreadSafeObserver(&internal_observer_);
+  net_log_ = NULL;
 }
 
-void ChromeNetLog::ThreadSafeObserver::SetLogLevel(
+void ChromeNetLog::ThreadSafeObserverImpl::SetLogLevel(
     net::NetLog::LogLevel log_level) {
   DCHECK(net_log_);
   base::AutoLock lock(net_log_->lock_);
-  log_level_ = log_level;
+  internal_observer_.SetLogLevel(log_level);
   net_log_->UpdateLogLevel();
 }
 
+void ChromeNetLog::ThreadSafeObserverImpl::
+AddAsObserverAndGetAllPassivelyCapturedEvents(
+    ChromeNetLog* net_log,
+    EntryList* entries) {
+  DCHECK(!net_log_);
+  net_log_ = net_log;
+  net_log_->AddObserverAndGetAllPassivelyCapturedEvents(&internal_observer_,
+                                                        entries);
+}
+
+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::Entry::Entry(uint32 order,
                            net::NetLog::EventType type,
                            const base::TimeTicks& time,
@@ -79,21 +119,21 @@ ChromeNetLog::ChromeNetLog()
     }
   }
 
-  AddObserver(passive_collector_.get());
-  AddObserver(load_timing_observer_.get());
+  passive_collector_->AddAsObserver(this);
+  load_timing_observer_->AddAsObserver(this);
 
   if (command_line->HasSwitch(switches::kLogNetLog)) {
     net_log_logger_.reset(new NetLogLogger(
-            command_line->GetSwitchValuePath(switches::kLogNetLog)));
-    AddObserver(net_log_logger_.get());
+        command_line->GetSwitchValuePath(switches::kLogNetLog)));
+    net_log_logger_->AddAsObserver(this);
   }
 }
 
 ChromeNetLog::~ChromeNetLog() {
-  RemoveObserver(passive_collector_.get());
-  RemoveObserver(load_timing_observer_.get());
+  passive_collector_->RemoveAsObserver();
+  load_timing_observer_->RemoveAsObserver();
   if (net_log_logger_.get()) {
-    RemoveObserver(net_log_logger_.get());
+    net_log_logger_->RemoveAsObserver();
   }
 }
 
@@ -119,21 +159,21 @@ net::NetLog::LogLevel ChromeNetLog::GetLogLevel() const {
   return static_cast<net::NetLog::LogLevel>(log_level);
 }
 
-void ChromeNetLog::AddObserver(ThreadSafeObserver* observer) {
+void ChromeNetLog::AddThreadSafeObserver(
+    net::NetLog::ThreadSafeObserver* observer) {
   base::AutoLock lock(lock_);
   AddObserverWhileLockHeld(observer);
 }
 
-void ChromeNetLog::RemoveObserver(ThreadSafeObserver* observer) {
+void ChromeNetLog::RemoveThreadSafeObserver(
+    net::NetLog::ThreadSafeObserver* observer) {
   base::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) {
+    net::NetLog::ThreadSafeObserver* observer, EntryList* passive_entries) {
   base::AutoLock lock(lock_);
   AddObserverWhileLockHeld(observer);
   passive_collector_->GetAllCapturedEvents(passive_entries);
@@ -165,9 +205,8 @@ void ChromeNetLog::UpdateLogLevel() {
                                 new_effective_log_level);
 }
 
-void ChromeNetLog::AddObserverWhileLockHeld(ThreadSafeObserver* observer) {
-  DCHECK(!observer->net_log_);
-  observer->net_log_ = this;
+void ChromeNetLog::AddObserverWhileLockHeld(
+    net::NetLog::ThreadSafeObserver* observer) {
   observers_.AddObserver(observer);
   UpdateLogLevel();
 }
diff --git a/chrome/browser/net/chrome_net_log.h b/chrome/browser/net/chrome_net_log.h
index 909ca0a..a032c33 100644
--- a/chrome/browser/net/chrome_net_log.h
+++ b/chrome/browser/net/chrome_net_log.h
@@ -23,7 +23,7 @@ class PassiveLogCollector;
 // 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
+// ChromeNetLog::ThreadSafeObserverImpl 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
@@ -54,53 +54,73 @@ class ChromeNetLog : public net::NetLog {
 
   typedef std::vector<Entry> EntryList;
 
-  // Interface for observing the events logged by the network stack.
-  class ThreadSafeObserver {
+  // 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:
-    // Constructs an observer that wants to see network events, with
-    // 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 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();
-
-    // 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.
+    explicit ThreadSafeObserverImpl(LogLevel log_level);
+    virtual ~ThreadSafeObserverImpl();
+
     virtual void OnAddEntry(EventType type,
                             const base::TimeTicks& time,
                             const Source& source,
                             EventPhase phase,
                             EventParameters* params) = 0;
-    LogLevel log_level() const;
 
-   protected:
-    void AssertNetLogLockAcquired() const;
+    // 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();
 
-    // 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_;
+    void AddAsObserverAndGetAllPassivelyCapturedEvents(
+        ChromeNetLog *net_log,
+        EntryList* passive_entries);
+
+   protected:
+    void AssertNetLogLockAcquired() const;
 
    private:
-    friend class ChromeNetLog;
-    LogLevel log_level_;
-    DISALLOW_COPY_AND_ASSIGN(ThreadSafeObserver);
+    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();
@@ -111,19 +131,9 @@ class ChromeNetLog : public net::NetLog {
                         const base::TimeTicks& time,
                         const Source& source,
                         EventPhase phase,
-                        EventParameters* params);
-  virtual uint32 NextID();
-  virtual LogLevel GetLogLevel() const;
-
-  void AddObserver(ThreadSafeObserver* observer);
-  void RemoveObserver(ThreadSafeObserver* observer);
-
-  // 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);
+                        EventParameters* params) OVERRIDE;
+  virtual uint32 NextID() OVERRIDE;
+  virtual LogLevel GetLogLevel() const OVERRIDE;
 
   void GetAllPassivelyCapturedEvents(EntryList* passive_entries);
 
@@ -136,6 +146,18 @@ class ChromeNetLog : public net::NetLog {
  private:
   void AddObserverWhileLockHeld(ThreadSafeObserver* observer);
 
+  // NetLog implementation
+  virtual void AddThreadSafeObserver(ThreadSafeObserver* observer) OVERRIDE;
+  virtual void RemoveThreadSafeObserver(ThreadSafeObserver* observer) OVERRIDE;
+
+  // 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);
+
+
   // Called whenever an observer is added or removed, or changes its log level.
   // Must have acquired |lock_| prior to calling.
   void UpdateLogLevel();
diff --git a/chrome/browser/net/load_timing_observer.cc b/chrome/browser/net/load_timing_observer.cc
index e891075..788394f 100644
--- a/chrome/browser/net/load_timing_observer.cc
+++ b/chrome/browser/net/load_timing_observer.cc
@@ -1,4 +1,4 @@
-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// Copyright (c) 2011 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.
 
@@ -62,7 +62,7 @@ LoadTimingObserver::HTTPStreamJobRecord::HTTPStreamJobRecord()
 }
 
 LoadTimingObserver::LoadTimingObserver()
-    : ThreadSafeObserver(net::NetLog::LOG_BASIC),
+    : ThreadSafeObserverImpl(net::NetLog::LOG_BASIC),
       last_connect_job_id_(net::NetLog::Source::kInvalidId) {
 }
 
diff --git a/chrome/browser/net/load_timing_observer.h b/chrome/browser/net/load_timing_observer.h
index c1f8cd4..7f7f49e 100644
--- a/chrome/browser/net/load_timing_observer.h
+++ b/chrome/browser/net/load_timing_observer.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// Copyright (c) 2011 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.
 
@@ -24,7 +24,7 @@ struct ResourceResponse;
 //
 // 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 {
+class LoadTimingObserver : public ChromeNetLog::ThreadSafeObserverImpl {
  public:
   struct URLRequestRecord {
     URLRequestRecord();
diff --git a/chrome/browser/net/net_log_logger.cc b/chrome/browser/net/net_log_logger.cc
index 6c79278..fac5c82 100644
--- a/chrome/browser/net/net_log_logger.cc
+++ b/chrome/browser/net/net_log_logger.cc
@@ -14,7 +14,7 @@
 #include "chrome/browser/ui/webui/net_internals_ui.h"
 
 NetLogLogger::NetLogLogger(const FilePath &log_path)
-    : ThreadSafeObserver(net::NetLog::LOG_ALL_BUT_BYTES) {
+    : ThreadSafeObserverImpl(net::NetLog::LOG_ALL_BUT_BYTES) {
   if (!log_path.empty()) {
     base::ThreadRestrictions::ScopedAllowIO allow_io;
     file_.Set(file_util::OpenFile(log_path, "w"));
diff --git a/chrome/browser/net/net_log_logger.h b/chrome/browser/net/net_log_logger.h
index 1ad1244..f04fcc8 100644
--- a/chrome/browser/net/net_log_logger.h
+++ b/chrome/browser/net/net_log_logger.h
@@ -21,7 +21,7 @@ class FilePath;
 //
 // Relies on ChromeNetLog only calling an Observer once at a time for
 // thread-safety.
-class NetLogLogger : public ChromeNetLog::ThreadSafeObserver {
+class NetLogLogger : public ChromeNetLog::ThreadSafeObserverImpl {
  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
diff --git a/chrome/browser/net/passive_log_collector.cc b/chrome/browser/net/passive_log_collector.cc
index ca321dd..66950ad 100644
--- a/chrome/browser/net/passive_log_collector.cc
+++ b/chrome/browser/net/passive_log_collector.cc
@@ -50,7 +50,7 @@ PassiveLogCollector::SourceInfo::~SourceInfo() {}
 //----------------------------------------------------------------------------
 
 PassiveLogCollector::PassiveLogCollector()
-    : ThreadSafeObserver(net::NetLog::LOG_BASIC),
+    : ThreadSafeObserverImpl(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)),
diff --git a/chrome/browser/net/passive_log_collector.h b/chrome/browser/net/passive_log_collector.h
index 28598b2..ae85f56 100644
--- a/chrome/browser/net/passive_log_collector.h
+++ b/chrome/browser/net/passive_log_collector.h
@@ -36,7 +36,7 @@
 // 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 {
+class PassiveLogCollector : public ChromeNetLog::ThreadSafeObserverImpl {
  public:
   typedef std::vector<net::NetLog::Source> SourceDependencyList;
 
diff --git a/chrome/browser/ui/webui/media/media_internals_proxy.cc b/chrome/browser/ui/webui/media/media_internals_proxy.cc
index 2f2e46a..db3788d 100644
--- a/chrome/browser/ui/webui/media/media_internals_proxy.cc
+++ b/chrome/browser/ui/webui/media/media_internals_proxy.cc
@@ -23,7 +23,7 @@ static const char kSendConstantsFunction[] = "media.onReceiveConstants";
 static const char kSendNetworkEventsFunction[] = "media.onNetUpdate";
 
 MediaInternalsProxy::MediaInternalsProxy()
-    : ThreadSafeObserver(net::NetLog::LOG_ALL_BUT_BYTES) {
+    : ThreadSafeObserverImpl(net::NetLog::LOG_ALL_BUT_BYTES) {
   io_thread_ = g_browser_process->io_thread();
 }
 
@@ -118,13 +118,13 @@ void MediaInternalsProxy::ObserveMediaInternalsOnIOThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   io_thread_->globals()->media.media_internals->AddObserver(this);
   // TODO(scottfr): Get the passive log data as well.
-  io_thread_->net_log()->AddObserver(this);
+  AddAsObserver(io_thread_->net_log());
 }
 
 void MediaInternalsProxy::StopObservingMediaInternalsOnIOThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   io_thread_->globals()->media.media_internals->RemoveObserver(this);
-  io_thread_->net_log()->RemoveObserver(this);
+  RemoveAsObserver();
 }
 
 void MediaInternalsProxy::GetEverythingOnIOThread() {
diff --git a/chrome/browser/ui/webui/media/media_internals_proxy.h b/chrome/browser/ui/webui/media/media_internals_proxy.h
index 1915e94..229b4c3 100644
--- a/chrome/browser/ui/webui/media/media_internals_proxy.h
+++ b/chrome/browser/ui/webui/media/media_internals_proxy.h
@@ -26,7 +26,7 @@ class Value;
 class MediaInternalsProxy
     : public MediaInternalsObserver,
       public base::RefCountedThreadSafe<MediaInternalsProxy>,
-      public ChromeNetLog::ThreadSafeObserver {
+      public ChromeNetLog::ThreadSafeObserverImpl {
  public:
   MediaInternalsProxy();
 
@@ -47,7 +47,7 @@ class MediaInternalsProxy
                           const base::TimeTicks& time,
                           const net::NetLog::Source& source,
                           net::NetLog::EventPhase phase,
-                          net::NetLog::EventParameters* params);
+                          net::NetLog::EventParameters* params) OVERRIDE;
 
  private:
   friend class base::RefCountedThreadSafe<MediaInternalsProxy>;
diff --git a/chrome/browser/ui/webui/net_internals_ui.cc b/chrome/browser/ui/webui/net_internals_ui.cc
index bef57d6..154343c 100644
--- a/chrome/browser/ui/webui/net_internals_ui.cc
+++ b/chrome/browser/ui/webui/net_internals_ui.cc
@@ -275,7 +275,7 @@ class NetInternalsMessageHandler::IOThreadImpl
     : public base::RefCountedThreadSafe<
           NetInternalsMessageHandler::IOThreadImpl,
           BrowserThread::DeleteOnUIThread>,
-      public ChromeNetLog::ThreadSafeObserver,
+      public ChromeNetLog::ThreadSafeObserverImpl,
       public ConnectionTester::Delegate {
  public:
   // Type for methods that can be used as MessageHandler callbacks.
@@ -761,7 +761,7 @@ NetInternalsMessageHandler::IOThreadImpl::IOThreadImpl(
     const base::WeakPtr<NetInternalsMessageHandler>& handler,
     IOThread* io_thread,
     net::URLRequestContextGetter* context_getter)
-    : ThreadSafeObserver(net::NetLog::LOG_ALL_BUT_BYTES),
+    : ThreadSafeObserverImpl(net::NetLog::LOG_ALL_BUT_BYTES),
       handler_(handler),
       io_thread_(io_thread),
       context_getter_(context_getter),
@@ -784,8 +784,10 @@ NetInternalsMessageHandler::IOThreadImpl::CreateCallback(
 void NetInternalsMessageHandler::IOThreadImpl::Detach() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   // Unregister with network stack to observe events.
-  if (is_observing_log_)
-    io_thread_->net_log()->RemoveObserver(this);
+  if (is_observing_log_) {
+    is_observing_log_ = false;
+    RemoveAsObserver();
+  }
 
   // Cancel any in-progress connection tests.
   connection_tester_.reset();
@@ -824,8 +826,8 @@ void NetInternalsMessageHandler::IOThreadImpl::OnRendererReady(
   // Register with network stack to observe events.
   is_observing_log_ = true;
   ChromeNetLog::EntryList entries;
-  io_thread_->net_log()->AddObserverAndGetAllPassivelyCapturedEvents(this,
-                                                                     &entries);
+  AddAsObserverAndGetAllPassivelyCapturedEvents(io_thread_->net_log(),
+                                                &entries);
   SendPassiveLogEntries(entries);
 }
 
diff --git a/content/browser/content_browser_client.h b/content/browser/content_browser_client.h
index 5478c7d..a04cee0 100644
--- a/content/browser/content_browser_client.h
+++ b/content/browser/content_browser_client.h
@@ -42,6 +42,7 @@ class CryptoModuleBlockingPasswordDelegate;
 namespace net {
 class CookieList;
 class CookieOptions;
+class NetLog;
 class URLRequest;
 class URLRequestContext;
 class X509Certificate;
@@ -235,6 +236,7 @@ class ContentBrowserClient {
   virtual ui::Clipboard* GetClipboard() = 0;
   virtual MHTMLGenerationManager* GetMHTMLGenerationManager() = 0;
   virtual DevToolsManager* GetDevToolsManager() = 0;
+  virtual net::NetLog* GetNetLog() = 0;
 
   // Returns true if fast shutdown is possible.
   virtual bool IsFastShutdownPossible() = 0;
diff --git a/content/browser/debugger/DEPS b/content/browser/debugger/DEPS
index 558fbbd..db358e1 100644
--- a/content/browser/debugger/DEPS
+++ b/content/browser/debugger/DEPS
@@ -9,15 +9,11 @@ include_rules = [
 
   # devtools_manager.cc, http://codereview.chromium.org/7310029/
   "+chrome/browser/browser_process.h",
-  "+chrome/browser/net/chrome_net_log.h",
-  
-  # devtools_net_log_observer.cc
-  "+chrome/browser/io_thread.h",
 
   # worker_devtools_manager_io.cc
   "+chrome/browser/debugger/devtools_window.h",
   "+chrome/browser/profiles/profile_manager.h",
-  
+
   # devtools_http_protocol_handler.cc
   "+ui/base/resource/resource_bundle.h",
   "+chrome/browser/ui/webui/devtools_ui.h",
diff --git a/content/browser/debugger/devtools_manager.cc b/content/browser/debugger/devtools_manager.cc
index bc8d4f9..c79aee7 100644
--- a/content/browser/debugger/devtools_manager.cc
+++ b/content/browser/debugger/devtools_manager.cc
@@ -247,8 +247,7 @@ void DevToolsManager::BindClientHost(
     BrowserThread::PostTask(
         BrowserThread::IO,
         FROM_HERE,
-        NewRunnableFunction(&DevToolsNetLogObserver::Attach,
-                            g_browser_process->io_thread()));
+        NewRunnableFunction(&DevToolsNetLogObserver::Attach));
   }
   inspected_rvh_to_client_host_[inspected_rvh] = client_host;
   client_host_to_inspected_rvh_[client_host] = inspected_rvh;
diff --git a/content/browser/debugger/devtools_netlog_observer.cc b/content/browser/debugger/devtools_netlog_observer.cc
index 919c53c..9e278b0 100644
--- a/content/browser/debugger/devtools_netlog_observer.cc
+++ b/content/browser/debugger/devtools_netlog_observer.cc
@@ -7,7 +7,8 @@
 #include "base/string_tokenizer.h"
 #include "base/string_util.h"
 #include "base/values.h"
-#include "chrome/browser/io_thread.h"
+#include "content/browser/browser_thread.h"
+#include "content/browser/content_browser_client.h"
 #include "content/common/resource_response.h"
 #include "net/base/load_flags.h"
 #include "net/http/http_net_log_params.h"
@@ -21,14 +22,14 @@ const size_t kMaxNumEntries = 1000;
 
 DevToolsNetLogObserver* DevToolsNetLogObserver::instance_ = NULL;
 
-DevToolsNetLogObserver::DevToolsNetLogObserver(ChromeNetLog* chrome_net_log)
-    : ChromeNetLog::ThreadSafeObserver(net::NetLog::LOG_ALL_BUT_BYTES),
-      chrome_net_log_(chrome_net_log) {
-  chrome_net_log_->AddObserver(this);
+DevToolsNetLogObserver::DevToolsNetLogObserver(net::NetLog* net_log)
+    : net::NetLog::ThreadSafeObserver(net::NetLog::LOG_ALL_BUT_BYTES),
+      net_log_(net_log) {
+  net_log_->AddThreadSafeObserver(this);
 }
 
 DevToolsNetLogObserver::~DevToolsNetLogObserver() {
-  chrome_net_log_->RemoveObserver(this);
+  net_log_->RemoveThreadSafeObserver(this);
 }
 
 DevToolsNetLogObserver::ResourceInfo*
@@ -235,11 +236,11 @@ void DevToolsNetLogObserver::OnAddSocketEntry(
   }
 }
 
-void DevToolsNetLogObserver::Attach(IOThread* io_thread) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+void DevToolsNetLogObserver::Attach() {
   DCHECK(!instance_);
 
-  instance_ = new DevToolsNetLogObserver(io_thread->net_log());
+  instance_ = new DevToolsNetLogObserver(
+      content::GetContentClient()->browser()->GetNetLog());
 }
 
 void DevToolsNetLogObserver::Detach() {
diff --git a/content/browser/debugger/devtools_netlog_observer.h b/content/browser/debugger/devtools_netlog_observer.h
index 75b3314..3fe2765 100644
--- a/content/browser/debugger/devtools_netlog_observer.h
+++ b/content/browser/debugger/devtools_netlog_observer.h
@@ -8,14 +8,13 @@
 
 #include "base/hash_tables.h"
 #include "base/memory/ref_counted.h"
-#include "chrome/browser/net/chrome_net_log.h"
+#include "net/base/net_log.h"
 #include "webkit/glue/resource_loader_bridge.h"
 
 namespace net {
 class URLRequest;
 }  // namespace net
 
-class IOThread;
 struct ResourceResponse;
 
 // DevToolsNetLogObserver watches the NetLog event stream and collects the
@@ -25,16 +24,16 @@ struct ResourceResponse;
 // As DevToolsNetLogObserver shares live data with objects that live on the
 // IO Thread, it must also reside on the IO Thread.  Only OnAddEntry can be
 // called from other threads.
-class DevToolsNetLogObserver: public ChromeNetLog::ThreadSafeObserver {
+class DevToolsNetLogObserver : public net::NetLog::ThreadSafeObserver {
   typedef webkit_glue::ResourceDevToolsInfo ResourceInfo;
 
  public:
-  // ThreadSafeObserver implementation:
+  // net::NetLog::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);
+                          net::NetLog::EventParameters* params) OVERRIDE;
 
   void OnAddURLRequestEntry(net::NetLog::EventType type,
                             const base::TimeTicks& time,
@@ -54,7 +53,7 @@ class DevToolsNetLogObserver: public ChromeNetLog::ThreadSafeObserver {
                         net::NetLog::EventPhase phase,
                         net::NetLog::EventParameters* params);
 
-  static void Attach(IOThread* thread);
+  static void Attach();
   static void Detach();
 
   // Must be called on the IO thread. May return NULL if no observers
@@ -66,12 +65,12 @@ class DevToolsNetLogObserver: public ChromeNetLog::ThreadSafeObserver {
  private:
   static DevToolsNetLogObserver* instance_;
 
-  explicit DevToolsNetLogObserver(ChromeNetLog* chrome_net_log);
+  explicit DevToolsNetLogObserver(net::NetLog* net_log);
   virtual ~DevToolsNetLogObserver();
 
   ResourceInfo* GetResourceInfo(uint32 id);
 
-  ChromeNetLog* chrome_net_log_;
+  net::NetLog* net_log_;
   typedef base::hash_map<uint32, scoped_refptr<ResourceInfo> > RequestToInfoMap;
   typedef base::hash_map<uint32, int> RequestToEncodedDataLengthMap;
   typedef base::hash_map<uint32, uint32> HTTPStreamJobToSocketMap;
diff --git a/content/browser/mock_content_browser_client.cc b/content/browser/mock_content_browser_client.cc
index 6ad3abf..9d5c3e5 100644
--- a/content/browser/mock_content_browser_client.cc
+++ b/content/browser/mock_content_browser_client.cc
@@ -188,6 +188,10 @@ DevToolsManager* MockContentBrowserClient::GetDevToolsManager() {
   return NULL;
 }
 
+net::NetLog* MockContentBrowserClient::GetNetLog() {
+  return NULL;
+}
+
 bool MockContentBrowserClient::IsFastShutdownPossible() {
   return true;
 }
diff --git a/content/browser/mock_content_browser_client.h b/content/browser/mock_content_browser_client.h
index ff00fec..157f9d3 100644
--- a/content/browser/mock_content_browser_client.h
+++ b/content/browser/mock_content_browser_client.h
@@ -94,6 +94,7 @@ class MockContentBrowserClient : public ContentBrowserClient {
   virtual ui::Clipboard* GetClipboard() OVERRIDE;
   virtual MHTMLGenerationManager* GetMHTMLGenerationManager() OVERRIDE;
   virtual DevToolsManager* GetDevToolsManager() OVERRIDE;
+  virtual net::NetLog* GetNetLog() OVERRIDE;
   virtual bool IsFastShutdownPossible() OVERRIDE;
   virtual WebPreferences GetWebkitPrefs(Profile* profile,
                                         bool is_web_ui) OVERRIDE;
diff --git a/net/base/capturing_net_log.cc b/net/base/capturing_net_log.cc
index 2daa73a..ecdbc15 100644
--- a/net/base/capturing_net_log.cc
+++ b/net/base/capturing_net_log.cc
@@ -1,9 +1,11 @@
-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// Copyright (c) 2011 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 "net/base/capturing_net_log.h"
 
+#include "base/logging.h"
+
 namespace net {
 
 CapturingNetLog::Entry::Entry(EventType type,
@@ -60,6 +62,16 @@ NetLog::LogLevel CapturingNetLog::GetLogLevel() const {
   return log_level_;
 }
 
+void CapturingNetLog::AddThreadSafeObserver(
+    NetLog::ThreadSafeObserver* observer) {
+  NOTREACHED() << "Not currently used by net unit tests.";
+}
+
+void CapturingNetLog::RemoveThreadSafeObserver(
+    NetLog::ThreadSafeObserver* observer) {
+  NOTREACHED() << "Not currently used by net unit tests.";
+}
+
 CapturingBoundNetLog::CapturingBoundNetLog(const NetLog::Source& source,
                                            CapturingNetLog* net_log)
     : source_(source), capturing_net_log_(net_log) {
diff --git a/net/base/capturing_net_log.h b/net/base/capturing_net_log.h
index 9185f48..f60f6ed 100644
--- a/net/base/capturing_net_log.h
+++ b/net/base/capturing_net_log.h
@@ -10,6 +10,7 @@
 
 #include "base/atomicops.h"
 #include "base/basictypes.h"
+#include "base/compiler_specific.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/synchronization/lock.h"
@@ -60,9 +61,11 @@ class NET_API CapturingNetLog : public NetLog {
                         const base::TimeTicks& time,
                         const Source& source,
                         EventPhase phase,
-                        EventParameters* extra_parameters);
-  virtual uint32 NextID();
-  virtual LogLevel GetLogLevel() const;
+                        EventParameters* extra_parameters) OVERRIDE;
+  virtual uint32 NextID() OVERRIDE;
+  virtual LogLevel GetLogLevel() const OVERRIDE;
+  virtual void AddThreadSafeObserver(ThreadSafeObserver* observer) OVERRIDE;
+  virtual void RemoveThreadSafeObserver(ThreadSafeObserver* observer) OVERRIDE;
 
  private:
   // Needs to be "mutable" so can use it in GetEntries().
@@ -115,4 +118,3 @@ class NET_TEST CapturingBoundNetLog {
 }  // namespace net
 
 #endif  // NET_BASE_CAPTURING_NET_LOG_H_
-
diff --git a/net/base/net_log.cc b/net/base/net_log.cc
index 110c8a4..6509801 100644
--- a/net/base/net_log.cc
+++ b/net/base/net_log.cc
@@ -56,6 +56,17 @@ Value* NetLog::Source::ToValue() const {
   return dict;
 }
 
+NetLog::ThreadSafeObserver::ThreadSafeObserver(LogLevel log_level)
+    : log_level_(log_level) {
+}
+
+NetLog::ThreadSafeObserver::~ThreadSafeObserver() {
+}
+
+NetLog::LogLevel NetLog::ThreadSafeObserver::log_level() const {
+  return log_level_;
+}
+
 // static
 std::string NetLog::TickCountToString(const base::TimeTicks& time) {
   int64 delta_time = (time - base::TimeTicks()).InMilliseconds();
diff --git a/net/base/net_log.h b/net/base/net_log.h
index 39fa915..97efb27 100644
--- a/net/base/net_log.h
+++ b/net/base/net_log.h
@@ -104,6 +104,50 @@ class NET_API NetLog {
     LOG_BASIC,
   };
 
+  // An observer, that must ensure its own thread safety, for events
+  // being added to a NetLog.
+  class NET_API ThreadSafeObserver {
+   public:
+    // Constructs an observer that wants to see network events, with
+    // the specified minimum event granularity.  A ThreadSafeObserver can only
+    // observe a single NetLog 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.
+    //
+    // 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();
+
+    // Returns the minimum log level for events this observer wants to
+    // receive.
+    LogLevel log_level() const;
+
+    // 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 NetLog or
+    // NetLog::Observer 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;
+
+   protected:
+    // Subclasses should only ever modify this if they somehow
+    // collaborate with concrete implementations of NetLog to enable
+    // modification.
+    LogLevel log_level_;
+
+   private:
+    DISALLOW_COPY_AND_ASSIGN(ThreadSafeObserver);
+  };
+
   NetLog() {}
   virtual ~NetLog() {}
 
@@ -130,6 +174,14 @@ class NET_API NetLog {
   // and saving expensive log entries.
   virtual LogLevel GetLogLevel() const = 0;
 
+  // Adds an observer. Each observer may be added only once and must
+  // be removed via |RemoveObserver()| before this object goes out of
+  // scope.
+  virtual void AddThreadSafeObserver(ThreadSafeObserver* observer) = 0;
+
+  // Removes an 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.
   static std::string TickCountToString(const base::TimeTicks& time);