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

net/base/net_log.cc

 // 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 "net/base/net_log.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/string_number_conversions.h"
 #include "base/time.h"
@@ skipping 169 matching lines @@
 
 NetLog::LogLevel NetLog::ThreadSafeObserver::log_level() const {
   DCHECK(net_log_);
   return log_level_;
 }
 
 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()),
            net::NetLog::PHASE_NONE,
            NULL);
 }
 
 void NetLog::AddGlobalEntry(
     EventType type,
     const NetLog::ParametersCallback& parameters_callback) {
   AddEntry(type,
            Source(net::NetLog::SOURCE_NONE, NextID()),
            net::NetLog::PHASE_NONE,
            &parameters_callback);
 }
 
+uint32 NetLog::NextID() {
+  return base::subtle::NoBarrier_AtomicIncrement(&last_id_, 1);
+}
+
+void NetLog::SetBaseLogLevel(LogLevel log_level) {
+  base_log_level_ = log_level;

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

Should have the lock for this, unfortunately.  May be simpler to just make the
constructor always take it in.  Or get the lock here in a small code block.  I'm
fine, either way.

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

Done.

+
+  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_);
+
+  observers_.AddObserver(observer);
+  OnAddObserver(observer, log_level);
+  UpdateLogLevel();
+}
+
+void NetLog::SetObserverLogLevel(
+    net::NetLog::ThreadSafeObserver* observer,
+    LogLevel log_level) {
+  base::AutoLock lock(lock_);
+
+  DCHECK(observers_.HasObserver(observer));
+  OnSetObserverLogLevel(observer, log_level);
+  UpdateLogLevel();
+}
+
+void NetLog::RemoveThreadSafeObserver(
+    net::NetLog::ThreadSafeObserver* observer) {
+  base::AutoLock lock(lock_);
+
+  DCHECK(observers_.HasObserver(observer));
+  observers_.RemoveObserver(observer);
+  OnRemoveObserver(observer);
+  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();
   return base::Int64ToString(delta_time);
 }
 
 // static
 const char* NetLog::EventTypeToString(EventType event) {
   switch (event) {
 #define EVENT_TYPE(label) case TYPE_ ## label: return #label;
@@ skipping 78 matching lines @@
   return base::Bind(&NetLogStringCallback, name, value);
 }
 
 // static
 NetLog::ParametersCallback NetLog::StringCallback(const char* name,
                                                   const base::string16* value) {
   DCHECK(value);
   return base::Bind(&NetLogString16Callback, name, value);
 }
 
 void NetLog::OnAddObserver(ThreadSafeObserver* observer, LogLevel log_level) {

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

These OnBlah functions used to be needed for communication between ChromeNetLog
and NetLog.  Now that's no longer needed, so think we should just inline them,
to keep things simple.

   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,
                       const NetLog::ParametersCallback* parameters_callback) {
   LogLevel log_level = GetLogLevel();
   if (log_level == LOG_NONE)
     return;
   Entry entry(type, source, phase, base::TimeTicks::Now(),
               parameters_callback, log_level);
-  OnAddEntry(entry);
+
+  // Notify all of the log observers.
+  base::AutoLock lock(lock_);
+  FOR_EACH_OBSERVER(ThreadSafeObserver, observers_, OnAddEntry(entry));
 }
 
 void BoundNetLog::AddEntry(NetLog::EventType type,
                            NetLog::EventPhase phase) const {
   if (!net_log_)
     return;
   net_log_->AddEntry(type, source_, phase, NULL);
 }
 
 void BoundNetLog::AddEntry(
@@ skipping 79 matching lines @@
 BoundNetLog BoundNetLog::Make(NetLog* net_log,
                               NetLog::SourceType source_type) {
   if (!net_log)
     return BoundNetLog();
 
   NetLog::Source source(source_type, net_log->NextID());
   return BoundNetLog(source, net_log);
 }
 
 }  // namespace net