Refactor net::NetLog to provide implementation of observer pattern, not just the interface.

net/base/capturing_net_log.h

 // 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.
 
 #ifndef NET_BASE_CAPTURING_NET_LOG_H_
 #define NET_BASE_CAPTURING_NET_LOG_H_
 
 #include <string>
 #include <vector>
 
 #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"
 #include "base/time.h"
 #include "net/base/net_log.h"
 
 namespace base {
 class DictionaryValue;
 }
 
 namespace net {
 
-// 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 {
+// CapturingNetLogObserver 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 CapturingNetLogObserver : public NetLog::ThreadSafeObserver {
  public:
   struct CapturedEntry {
-    CapturedEntry(EventType type,
+    CapturedEntry(NetLog::EventType type,
                   const base::TimeTicks& time,
-                  Source source,
-                  EventPhase phase,
+                  NetLog::Source source,
+                  NetLog::EventPhase phase,
                   scoped_ptr<base::DictionaryValue> params);
     // Copy constructor needed to store in a std::vector because of the
     // scoped_ptr.
     CapturedEntry(const CapturedEntry& entry);
 
     ~CapturedEntry();
 
     // Equality operator needed to store in a std::vector because of the
     // scoped_ptr.
     CapturedEntry& operator=(const CapturedEntry& entry);
 
     // Attempt to retrieve an value of the specified type with the given name
     // from |params|.  Returns true on success, false on failure.  Does not
     // modify |value| on failure.
     bool GetStringValue(const std::string& name, std::string* value) const;
     bool GetIntegerValue(const std::string& name, int* value) const;
 
     // Same as GetIntegerValue, but returns the error code associated with a
     // log entry.
     bool GetNetErrorCode(int* value) const;
 
     // Returns the parameters as a JSON string, or empty string if there are no
     // parameters.
     std::string GetParamsJson() const;
 
-    EventType type;
+    NetLog::EventType type;
     base::TimeTicks time;
-    Source source;
-    EventPhase phase;
+    NetLog::Source source;
+    NetLog::EventPhase phase;
     scoped_ptr<base::DictionaryValue> params;
   };
 
   // Ordered set of entries that were logged.
   typedef std::vector<CapturedEntry> CapturedEntryList;
 
-  CapturingNetLog();
-  virtual ~CapturingNetLog();
+  CapturingNetLogObserver();
+  virtual ~CapturingNetLogObserver();
 
   // 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;
 
   // Returns number of entries in the log.
   size_t GetSize() const;
 
   void Clear();
 
-  void SetLogLevel(NetLog::LogLevel log_level);
+ private:
+  // NetLog::ThreadSafeObserver implementation:
+  virtual void OnAddEntry(const NetLog::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;
-
- private:
   // Needs to be "mutable" so can use it in GetEntries().
   mutable base::Lock lock_;
 
-  // Last assigned source ID.  Incremented to get the next one.
-  base::subtle::Atomic32 last_id_;
-
   CapturedEntryList captured_entries_;
 
-  NetLog::LogLevel log_level_;
+  DISALLOW_COPY_AND_ASSIGN(CapturingNetLogObserver);
+};
 
-  DISALLOW_COPY_AND_ASSIGN(CapturingNetLog);
+// CapturingNetLog is a NetLog which instantiates CapturingNetLogObserver.
+// This is provided for compatilbility with old unittests.

[mmenke, 2013/06/03 14:27:09]

I'd say this is more a convenience wrapper, like CapturingBoundNetLog, then a
compatibility shim.  If you have hundreds of tests, setting everything up with
one line is just more convenient than four lines lines (Create a NetLog, create
observer, add observer, remove observer).

The only advantages that using the Observer has are that it doesn't have to be
set up before network stack objects are created, and we can use more than one.

In fact, just to make life simpler, and have fewer extra ways to do things, I
think it would actually be simpler to make CapturingNetLogObserver a private
class, and just have consumers continue to use the CapturingNetLog.  What do you
think?

Could then also get rid of the typedef, which I don't think we want to keep
around, long term, so nice to get rid of it now.

[kouhei (in TOK), 2013/06/04 15:41:44]

As some unittests require accessing the observer directly, I will keep those
separate.
Done for the comments.

[mmenke, 2013/06/04 16:55:47]

The unit tests don't need to directly access them - switch them back to a
CapturingNetLog, and you'd save a couple lines, and break nothing.

My main complaint here is the two typedefs, which are rather unusual in Chrome
code - they're mostly used for templates, and I don't think I've ever seen a
public typedef like this without a template in the Chrome code base.  In
general, I don't like classes having two names.  Get rid of them, and I'm ready
to sign off on this CL, after a final once over.

[kouhei (in TOK), 2013/06/04 22:19:30]

Sorry I misunderstood the last comment. I mixed it up with the CountingObserver.
I think it should be fine now. The typedefs gone, CapturingNetLogObserver is now
a private class, and consumers continue to use the CapturingNetLog so no change
in NetLogTest.

+class CapturingNetLog : public NetLog {
+ public:
+  typedef CapturingNetLogObserver::CapturedEntry CapturedEntry;
+  typedef CapturingNetLogObserver::CapturedEntryList CapturedEntryList;
+
+  CapturingNetLog();
+  virtual ~CapturingNetLog();
+
+  void SetLogLevel(NetLog::LogLevel log_level);
+
+  CapturingNetLogObserver& observer() { return capturing_net_log_observer_; }
+  const CapturingNetLogObserver& observer() const {
+    return capturing_net_log_observer_;
+  }
+
+  // below methods are forwarded to capturing_net_log_observer_

[mmenke, 2013/06/03 14:27:09]

Nit:  Capitalize + period.

[kouhei (in TOK), 2013/06/04 15:41:44]

Done.

+  void GetEntries(CapturingNetLogObserver::CapturedEntryList* entry_list) const;
+  size_t GetSize() const;
+
+ private:
+  CapturingNetLogObserver capturing_net_log_observer_;
 };
 
 // Helper class that exposes a similar API as BoundNetLog, but uses a
-// CapturingNetLog rather than the more generic NetLog.
+// CapturingNetLogObserver rather than the more generic NetLog.
 //
 // CapturingBoundNetLog can easily be converted to a BoundNetLog using the
 // bound() method.
 class CapturingBoundNetLog {
  public:
   CapturingBoundNetLog();
   ~CapturingBoundNetLog();
 
   // The returned BoundNetLog is only valid while |this| is alive.
-  BoundNetLog bound() const { return net_log_; }
+  BoundNetLog bound() const { return bound_net_log_; }
 
   // Fills |entry_list| with all entries in the log.
-  void GetEntries(CapturingNetLog::CapturedEntryList* entry_list) const;
+  void GetEntries(CapturingNetLogObserver::CapturedEntryList* entry_list) const;
 
   // Fills |entry_list| with all entries in the log from the specified Source.
   void GetEntriesForSource(
       NetLog::Source source,
-      CapturingNetLog::CapturedEntryList* entry_list) const;
+      CapturingNetLogObserver::CapturedEntryList* entry_list) const;
 
   // Returns number of entries in the log.
   size_t GetSize() const;
 
   void Clear();
 
-  // Sets the log level of the underlying CapturingNetLog.
+  // Sets the log level of the underlying CapturingNetLogObserver.
   void SetLogLevel(NetLog::LogLevel log_level);
 
  private:
-  CapturingNetLog capturing_net_log_;
-  const BoundNetLog net_log_;
+  CapturingNetLog net_log_;
+  const BoundNetLog bound_net_log_;
 
   DISALLOW_COPY_AND_ASSIGN(CapturingBoundNetLog);
 };
 
 }  // namespace net
 
 #endif  // NET_BASE_CAPTURING_NET_LOG_H_