8 files changed, 79 insertions, 140 deletions

diff --git a/chrome/browser/net/chrome_net_log.cc b/chrome/browser/net/chrome_net_log.cc
index 212dc46..3c9625d 100644
--- a/chrome/browser/net/chrome_net_log.cc
+++ b/chrome/browser/net/chrome_net_log.cc
@@ -16,70 +16,30 @@
 #include "chrome/browser/net/passive_log_collector.h"
 #include "chrome/common/chrome_switches.h"
 
-ChromeNetLog::ThreadSafeObserverImpl::ThreadSafeObserverImpl(LogLevel log_level)
+ChromeNetLog::ThreadSafeObserver::ThreadSafeObserver(LogLevel log_level)
     : net_log_(NULL),
-      ALLOW_THIS_IN_INITIALIZER_LIST(internal_observer_(this, log_level)) {
+      log_level_(log_level) {
 }
 
-ChromeNetLog::ThreadSafeObserverImpl::~ThreadSafeObserverImpl() {
+ChromeNetLog::ThreadSafeObserver::~ThreadSafeObserver() {
   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();
+net::NetLog::LogLevel ChromeNetLog::ThreadSafeObserver::log_level() const {
+  return log_level_;
 }
 
-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 {
+void ChromeNetLog::ThreadSafeObserver::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(
+void ChromeNetLog::ThreadSafeObserver::SetLogLevel(
     net::NetLog::LogLevel log_level) {
+  DCHECK(net_log_);
+  base::AutoLock lock(net_log_->lock_);
   log_level_ = log_level;
+  net_log_->UpdateLogLevel();
 }
 
 ChromeNetLog::Entry::Entry(uint32 order,
@@ -119,21 +79,21 @@ ChromeNetLog::ChromeNetLog()
     }
   }
 
-  passive_collector_->AddAsObserver(this);
-  load_timing_observer_->AddAsObserver(this);
+  AddObserver(passive_collector_.get());
+  AddObserver(load_timing_observer_.get());
 
   if (command_line->HasSwitch(switches::kLogNetLog)) {
     net_log_logger_.reset(new NetLogLogger(
-        command_line->GetSwitchValuePath(switches::kLogNetLog)));
-    net_log_logger_->AddAsObserver(this);
+            command_line->GetSwitchValuePath(switches::kLogNetLog)));
+    AddObserver(net_log_logger_.get());
   }
 }
 
 ChromeNetLog::~ChromeNetLog() {
-  passive_collector_->RemoveAsObserver();
-  load_timing_observer_->RemoveAsObserver();
+  RemoveObserver(passive_collector_.get());
+  RemoveObserver(load_timing_observer_.get());
   if (net_log_logger_.get()) {
-    net_log_logger_->RemoveAsObserver();
+    RemoveObserver(net_log_logger_.get());
   }
 }
 
@@ -159,21 +119,21 @@ net::NetLog::LogLevel ChromeNetLog::GetLogLevel() const {
   return static_cast<net::NetLog::LogLevel>(log_level);
 }
 
-void ChromeNetLog::AddThreadSafeObserver(
-    net::NetLog::ThreadSafeObserver* observer) {
+void ChromeNetLog::AddObserver(ThreadSafeObserver* observer) {
   base::AutoLock lock(lock_);
   AddObserverWhileLockHeld(observer);
 }
 
-void ChromeNetLog::RemoveThreadSafeObserver(
-    net::NetLog::ThreadSafeObserver* observer) {
+void ChromeNetLog::RemoveObserver(ThreadSafeObserver* observer) {
   base::AutoLock lock(lock_);
+  DCHECK_EQ(observer->net_log_, this);
+  observer->net_log_ = NULL;
   observers_.RemoveObserver(observer);
   UpdateLogLevel();
 }
 
 void ChromeNetLog::AddObserverAndGetAllPassivelyCapturedEvents(
-    net::NetLog::ThreadSafeObserver* observer, EntryList* passive_entries) {
+    ThreadSafeObserver* observer, EntryList* passive_entries) {
   base::AutoLock lock(lock_);
   AddObserverWhileLockHeld(observer);
   passive_collector_->GetAllCapturedEvents(passive_entries);
@@ -205,8 +165,9 @@ void ChromeNetLog::UpdateLogLevel() {
                                 new_effective_log_level);
 }
 
-void ChromeNetLog::AddObserverWhileLockHeld(
-    net::NetLog::ThreadSafeObserver* observer) {
+void ChromeNetLog::AddObserverWhileLockHeld(ThreadSafeObserver* observer) {
+  DCHECK(!observer->net_log_);
+  observer->net_log_ = this;
   observers_.AddObserver(observer);
   UpdateLogLevel();
 }
diff --git a/chrome/browser/net/chrome_net_log.h b/chrome/browser/net/chrome_net_log.h
index a032c33..909ca0a 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::ThreadSafeObserverImpl functions may be called by an observer's
+// ChromeNetLog::ThreadSafeObserver functions may be called by an observer's
 // OnAddEntry() method.  Doing so will result in a deadlock.
 //
 // By default, ChromeNetLog will attach the observer PassiveLogCollector which
@@ -54,73 +54,53 @@ class ChromeNetLog : public net::NetLog {
 
   typedef std::vector<Entry> EntryList;
 
-  // 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 {
+  // Interface for observing the events logged by the network stack.
+  class ThreadSafeObserver {
    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.
-    explicit ThreadSafeObserverImpl(LogLevel log_level);
-    virtual ~ThreadSafeObserverImpl();
-
+    //
+    // 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.
     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);
-
-    void AddAsObserverAndGetAllPassivelyCapturedEvents(
-        ChromeNetLog *net_log,
-        EntryList* passive_entries);
+    LogLevel log_level() const;
 
    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_;
+    // Can only be called when actively observing a ChromeNetLog.
+    void SetLogLevel(LogLevel log_level);
 
-    // The observer we register in AddAsObserver, that passes stuff
-    // through to us.
-    PassThroughObserver internal_observer_;
+    // ChromeNetLog currently being observed, if any.  Set by ChromeNetLog's
+    // AddObserver and RemoveObserver methods.
+    ChromeNetLog* net_log_;
 
-    DISALLOW_COPY_AND_ASSIGN(ThreadSafeObserverImpl);
+   private:
+    friend class ChromeNetLog;
+    LogLevel log_level_;
+    DISALLOW_COPY_AND_ASSIGN(ThreadSafeObserver);
   };
 
   ChromeNetLog();
@@ -131,9 +111,19 @@ class ChromeNetLog : public net::NetLog {
                         const base::TimeTicks& time,
                         const Source& source,
                         EventPhase phase,
-                        EventParameters* params) OVERRIDE;
-  virtual uint32 NextID() OVERRIDE;
-  virtual LogLevel GetLogLevel() const OVERRIDE;
+                        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);
 
   void GetAllPassivelyCapturedEvents(EntryList* passive_entries);
 
@@ -146,18 +136,6 @@ 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 788394f..e891075 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) 2010 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
@@ -62,7 +62,7 @@ LoadTimingObserver::HTTPStreamJobRecord::HTTPStreamJobRecord()
 }
 
 LoadTimingObserver::LoadTimingObserver()
-    : ThreadSafeObserverImpl(net::NetLog::LOG_BASIC),
+    : ThreadSafeObserver(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 7f7f49e..c1f8cd4 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) 2010 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
@@ -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::ThreadSafeObserverImpl {
+class LoadTimingObserver : public ChromeNetLog::ThreadSafeObserver {
  public:
   struct URLRequestRecord {
     URLRequestRecord();
diff --git a/chrome/browser/net/net_log_logger.cc b/chrome/browser/net/net_log_logger.cc
index fac5c82..6c79278 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)
-    : ThreadSafeObserverImpl(net::NetLog::LOG_ALL_BUT_BYTES) {
+    : ThreadSafeObserver(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 f04fcc8..1ad1244 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::ThreadSafeObserverImpl {
+class NetLogLogger : public ChromeNetLog::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
diff --git a/chrome/browser/net/passive_log_collector.cc b/chrome/browser/net/passive_log_collector.cc
index 66950ad..ca321dd 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()
-    : ThreadSafeObserverImpl(net::NetLog::LOG_BASIC),
+    : ThreadSafeObserver(net::NetLog::LOG_BASIC),
       ALLOW_THIS_IN_INITIALIZER_LIST(connect_job_tracker_(this)),
       ALLOW_THIS_IN_INITIALIZER_LIST(url_request_tracker_(this)),
       ALLOW_THIS_IN_INITIALIZER_LIST(socket_stream_tracker_(this)),
diff --git a/chrome/browser/net/passive_log_collector.h b/chrome/browser/net/passive_log_collector.h
index ae85f56..28598b2 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::ThreadSafeObserverImpl {
+class PassiveLogCollector : public ChromeNetLog::ThreadSafeObserver {
  public:
   typedef std::vector<net::NetLog::Source> SourceDependencyList;