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

net/base/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_NET_LOG_H_
 #define NET_BASE_NET_LOG_H_
 
 #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"
 
 namespace base {
 class DictionaryValue;
 class Value;
 }
 
 namespace net {
 
@@ skipping 167 matching lines @@
    private:
     friend class NetLog;
 
     // Both of these values are only modified by the NetLog.
     LogLevel log_level_;
     NetLog* net_log_;
 
     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);
   void AddGlobalEntry(EventType type,
                       const NetLog::ParametersCallback& parameters_callback);
 
   // Returns a unique ID which can be used as a source ID.  All returned IDs
   // will be unique and greater than 0.
-  virtual uint32 NextID() = 0;
+  uint32 NextID();
+
+  // Set the lowest allowed log level, regardless of any Observers.
+  void SetBaseLogLevel(LogLevel log_level);

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

Suggest making this protected, to discourage external callers from mucking with
it.

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

Done.

 
   // Returns the logging level for this NetLog. This is used to avoid computing
   // and saving expensive log entries.
-  virtual LogLevel GetLogLevel() const = 0;
+  LogLevel GetLogLevel() const;
 
   // Adds an observer and sets its log level.  The observer must not be
   // watching any NetLog, including this one, when this is called.
   //
   // Typical observers should specify LOG_BASIC.
   //
   // Observers that need to see the full granularity of events can specify
   // LOG_ALL_BUT_BYTES. However, doing so will have performance consequences.
   //
   // NetLog implementations must call NetLog::OnAddObserver to update the
   // observer's internal state.
-  virtual void AddThreadSafeObserver(ThreadSafeObserver* observer,
-                                     LogLevel log_level) = 0;
+  void AddThreadSafeObserver(ThreadSafeObserver* observer, LogLevel log_level);
 
   // 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.
-  virtual void SetObserverLogLevel(ThreadSafeObserver* observer,
-                                   LogLevel log_level) = 0;
+  void SetObserverLogLevel(ThreadSafeObserver* observer, LogLevel log_level);
 
   // 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.
-  virtual void RemoveThreadSafeObserver(ThreadSafeObserver* observer) = 0;
+  void RemoveThreadSafeObserver(ThreadSafeObserver* observer);
 
   // 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);
 
   // Returns a C-String symbolic name for |event_type|.
   static const char* EventTypeToString(EventType event_type);
 
   // Returns a dictionary that maps event type symbolic names to their enum
   // values.  Caller takes ownership of the returned Value.
@@ skipping 34 matching lines @@
   // the life of the callback.  |value| may not be NULL.
   // Warning: |name| and |value| must remain valid for the life of the callback.
   static ParametersCallback StringCallback(const char* name,
                                            const std::string* value);
 
   // Same as above, but takes in a UTF16 string.
   static ParametersCallback StringCallback(const char* name,
                                            const base::string16* value);
 
  protected:
-  // 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.

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

This comment is no longer accurate, though I think we can just inline and get
rid of these functions, anyways.

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

Done.

   void OnAddObserver(ThreadSafeObserver* observer, LogLevel log_level);
   void OnSetObserverLogLevel(ThreadSafeObserver* observer,
                              LogLevel log_level);
   void OnRemoveObserver(ThreadSafeObserver* observer);
 
  private:
   friend class BoundNetLog;
 
   void AddEntry(EventType type,
                 const Source& source,
                 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 command line flags

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

Fix comment:  "but can be changed with SetLogLevel."

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

Done.

+  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);
 };
 
 // Helper that binds a Source to a NetLog, and exposes convenience methods to
 // output log messages without needing to pass in the source.
 class NET_EXPORT BoundNetLog {
  public:
   BoundNetLog() : net_log_(NULL) {}
 
   // Add a log entry to the NetLog for the bound source.
@@ skipping 55 matching lines @@
       : source_(source), net_log_(net_log) {
   }
 
   NetLog::Source source_;
   NetLog* net_log_;
 };
 
 }  // namespace net
 
 #endif  // NET_BASE_NET_LOG_H_