Refactor NetLog::LogLevel --> NetLogCaptureMode.

net/log/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/log/net_log.h"
 
 #include "base/bind.h"
 #include "base/debug/alias.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "net/base/net_errors.h"
 
 namespace net {
 
 namespace {
 
-// Returns parameters for logging data transferred events. Includes number of
-// bytes transferred and, if the log level indicates bytes should be logged and
-// |byte_count| > 0, the bytes themselves.  The bytes are hex-encoded, since
-// base::StringValue only supports UTF-8.
+// Returns parameters for logging data transferred events. At a minum includes
+// the number of bytes transferred. If the capture mode allows logging byte
+// contents and |byte_count| > 0, then will include the actual bytes. The
+// bytes are hex-encoded, since base::StringValue only supports UTF-8.
 base::Value* BytesTransferredCallback(int byte_count,
                                       const char* bytes,
-                                      NetLog::LogLevel log_level) {
+                                      NetLogCaptureMode capture_mode) {
   base::DictionaryValue* dict = new base::DictionaryValue();
   dict->SetInteger("byte_count", byte_count);
-  if (NetLog::IsLoggingBytes(log_level) && byte_count > 0)
+  if (capture_mode.include_socket_bytes() && byte_count > 0)
     dict->SetString("hex_encoded_bytes", base::HexEncode(bytes, byte_count));
   return dict;
 }
 
-base::Value* SourceEventParametersCallback(const NetLog::Source source,
-                                           NetLog::LogLevel /* log_level */) {
+base::Value* SourceEventParametersCallback(
+    const NetLog::Source source,
+    NetLogCaptureMode /* capture_mode */) {
   if (!source.IsValid())
     return NULL;
   base::DictionaryValue* event_params = new base::DictionaryValue();
   source.AddToEventParameters(event_params);
   return event_params;
 }
 
 base::Value* NetLogIntegerCallback(const char* name,
                                    int value,
-                                   NetLog::LogLevel /* log_level */) {
+                                   NetLogCaptureMode /* capture_mode */) {
   base::DictionaryValue* event_params = new base::DictionaryValue();
   event_params->SetInteger(name, value);
   return event_params;
 }
 
 base::Value* NetLogInt64Callback(const char* name,
                                  int64 value,
-                                 NetLog::LogLevel /* log_level */) {
+                                 NetLogCaptureMode /* capture_mode */) {
   base::DictionaryValue* event_params = new base::DictionaryValue();
   event_params->SetString(name, base::Int64ToString(value));
   return event_params;
 }
 
 base::Value* NetLogStringCallback(const char* name,
                                   const std::string* value,
-                                  NetLog::LogLevel /* log_level */) {
+                                  NetLogCaptureMode /* capture_mode */) {
   base::DictionaryValue* event_params = new base::DictionaryValue();
   event_params->SetString(name, *value);
   return event_params;
 }
 
 base::Value* NetLogString16Callback(const char* name,
                                     const base::string16* value,
-                                    NetLog::LogLevel /* log_level */) {
+                                    NetLogCaptureMode /* capture_mode */) {
   base::DictionaryValue* event_params = new base::DictionaryValue();
   event_params->SetString(name, *value);
   return event_params;
 }
 
 }  // namespace
 
 // LoadTimingInfo requires this be 0.
 const uint32 NetLog::Source::kInvalidId = 0;
 
@@ skipping 50 matching lines @@
   source_dict->SetInteger("id", data_->source.id);
   source_dict->SetInteger("type", static_cast<int>(data_->source.type));
   entry_dict->Set("source", source_dict);
 
   // Set the event info.
   entry_dict->SetInteger("type", static_cast<int>(data_->type));
   entry_dict->SetInteger("phase", static_cast<int>(data_->phase));
 
   // Set the event-specific parameters.
   if (data_->parameters_callback) {
-    base::Value* value = data_->parameters_callback->Run(log_level_);
+    base::Value* value = data_->parameters_callback->Run(capture_mode_);
     if (value)
       entry_dict->Set("params", value);
   }
 
   return entry_dict;
 }
 
 base::Value* NetLog::Entry::ParametersToValue() const {
   if (data_->parameters_callback)
-    return data_->parameters_callback->Run(log_level_);
+    return data_->parameters_callback->Run(capture_mode_);
   return NULL;
 }
 
 NetLog::EntryData::EntryData(EventType type,
                              Source source,
                              EventPhase phase,
                              base::TimeTicks time,
                              const ParametersCallback* parameters_callback)
     : type(type),
       source(source),
       phase(phase),
       time(time),
       parameters_callback(parameters_callback) {
 }
 
 NetLog::EntryData::~EntryData() {
 }
 
-NetLog::Entry::Entry(const EntryData* data, LogLevel log_level)
-    : data_(data), log_level_(log_level) {
+NetLog::Entry::Entry(const EntryData* data, NetLogCaptureMode capture_mode)
+    : data_(data), capture_mode_(capture_mode) {
 }
 
 NetLog::Entry::~Entry() {
 }
 
-NetLog::ThreadSafeObserver::ThreadSafeObserver()
-    : log_level_(LOG_NONE), net_log_(NULL) {
+NetLog::ThreadSafeObserver::ThreadSafeObserver() : net_log_(NULL) {
 }
 
 NetLog::ThreadSafeObserver::~ThreadSafeObserver() {
   // Make sure we aren't watching a NetLog on destruction.  Because the NetLog
   // may pass events to each observer on multiple threads, we cannot safely
   // stop watching a NetLog automatically from a parent class.
   DCHECK(!net_log_);
 }
 
-NetLog::LogLevel NetLog::ThreadSafeObserver::log_level() const {
+NetLogCaptureMode NetLog::ThreadSafeObserver::capture_mode() const {
   DCHECK(net_log_);
-  return log_level_;
+  return capture_mode_;
 }
 
 NetLog* NetLog::ThreadSafeObserver::net_log() const {
   return net_log_;
 }
 
 void NetLog::ThreadSafeObserver::OnAddEntryData(const EntryData& entry_data) {
-  OnAddEntry(Entry(&entry_data, log_level()));
+  OnAddEntry(Entry(&entry_data, capture_mode()));
 }
 
-NetLog::NetLog() : last_id_(0), effective_log_level_(LOG_NONE) {
+NetLog::NetLog()
+    : last_id_(0),
+      effective_capture_mode_int32_(
+          NetLogCaptureMode::None().ToInternalValue()) {
 }
 
 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);
 }
 
-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);
+NetLogCaptureMode NetLog::GetCaptureMode() const {
+  base::subtle::Atomic32 capture_mode =
+      base::subtle::NoBarrier_Load(&effective_capture_mode_int32_);
+  return NetLogCaptureMode::FromInternalValue(capture_mode);
 }
 
 void NetLog::DeprecatedAddObserver(net::NetLog::ThreadSafeObserver* observer,
-                                   LogLevel log_level) {
-  DCHECK_NE(LOG_NONE, log_level);
+                                   NetLogCaptureMode capture_mode) {
+  DCHECK(capture_mode.enabled());
+
   base::AutoLock lock(lock_);
 
   DCHECK(!observer->net_log_);
-  DCHECK_EQ(LOG_NONE, observer->log_level_);
+  DCHECK(!observer->capture_mode_.enabled());
   observers_.AddObserver(observer);
   observer->net_log_ = this;
-  observer->log_level_ = log_level;
-  UpdateLogLevel();
+  observer->capture_mode_ = capture_mode;
+  UpdateCaptureMode();
 }
 
-void NetLog::SetObserverLogLevel(net::NetLog::ThreadSafeObserver* observer,
-                                 LogLevel log_level) {
-  DCHECK_NE(LOG_NONE, log_level);
+void NetLog::SetObserverCaptureMode(net::NetLog::ThreadSafeObserver* observer,
+                                    NetLogCaptureMode capture_mode) {
+  DCHECK(capture_mode.enabled());
   base::AutoLock lock(lock_);
 
   DCHECK(observers_.HasObserver(observer));
   DCHECK_EQ(this, observer->net_log_);
-  DCHECK_NE(LOG_NONE, observer->log_level_);
-  observer->log_level_ = log_level;
-  UpdateLogLevel();
+  DCHECK(observer->capture_mode_.enabled());
+  observer->capture_mode_ = capture_mode;
+  UpdateCaptureMode();
 }
 
 void NetLog::DeprecatedRemoveObserver(
     net::NetLog::ThreadSafeObserver* observer) {
   base::AutoLock lock(lock_);
 
   DCHECK(observers_.HasObserver(observer));
   DCHECK_EQ(this, observer->net_log_);
-  DCHECK_NE(LOG_NONE, observer->log_level_);
+  DCHECK(observer->capture_mode_.enabled());
   observers_.RemoveObserver(observer);
   observer->net_log_ = NULL;
-  observer->log_level_ = LOG_NONE;
-  UpdateLogLevel();
+  observer->capture_mode_ = NetLogCaptureMode();
+  UpdateCaptureMode();
 }
 
-void NetLog::UpdateLogLevel() {
+void NetLog::UpdateCaptureMode() {
   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 = LOG_NONE;
+  // Accumulate the capture mode of all the observers to find the maximum level.
+  NetLogCaptureMode new_capture_mode = NetLogCaptureMode::None();
   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());
+    new_capture_mode =
+        NetLogCaptureMode::Max(new_capture_mode, observer->capture_mode());
   }
-  base::subtle::NoBarrier_Store(&effective_log_level_, new_effective_log_level);
+  base::subtle::NoBarrier_Store(&effective_capture_mode_int32_,
+                                new_capture_mode.ToInternalValue());
 }
 
 // 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) {
@@ skipping 49 matching lines @@
     case PHASE_END:
       return "PHASE_END";
     case PHASE_NONE:
       return "PHASE_NONE";
   }
   NOTREACHED();
   return NULL;
 }
 
 // static
-bool NetLog::IsLoggingBytes(LogLevel log_level) {
-  return log_level == NetLog::LOG_ALL;
-}
-
-// static
-bool NetLog::IsLogging(LogLevel log_level) {
-  return log_level < NetLog::LOG_NONE;
-}
-
-// static
 NetLog::ParametersCallback NetLog::IntegerCallback(const char* name,
                                                    int value) {
   return base::Bind(&NetLogIntegerCallback, name, value);
 }
 
 // static
 NetLog::ParametersCallback NetLog::Int64Callback(const char* name,
                                                  int64 value) {
   return base::Bind(&NetLogInt64Callback, name, value);
 }
 
 // static
 NetLog::ParametersCallback NetLog::StringCallback(const char* name,
                                                   const std::string* value) {
   DCHECK(value);
   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::AddEntry(EventType type,
                       const Source& source,
                       EventPhase phase,
                       const NetLog::ParametersCallback* parameters_callback) {
-  if (GetLogLevel() == LOG_NONE)
+  if (!GetCaptureMode().enabled())
     return;
   EntryData entry_data(type, source, phase, base::TimeTicks::Now(),
                        parameters_callback);
 
   // Notify all of the log observers.
   base::AutoLock lock(lock_);
   FOR_EACH_OBSERVER(ThreadSafeObserver, observers_, OnAddEntryData(entry_data));
 }
 
 BoundNetLog::~BoundNetLog() {
@@ skipping 69 matching lines @@
     EndEvent(event_type, NetLog::IntegerCallback("net_error", net_error));
   }
 }
 
 void BoundNetLog::AddByteTransferEvent(NetLog::EventType event_type,
                                        int byte_count,
                                        const char* bytes) const {
   AddEvent(event_type, base::Bind(BytesTransferredCallback, byte_count, bytes));
 }
 
-NetLog::LogLevel BoundNetLog::GetLogLevel() const {
+NetLogCaptureMode BoundNetLog::GetCaptureMode() const {
   CrashIfInvalid();
 
   if (net_log_)
-    return net_log_->GetLogLevel();
-  return NetLog::LOG_NONE;
-}
-
-bool BoundNetLog::IsLoggingBytes() const {
-  return NetLog::IsLoggingBytes(GetLogLevel());
-}
-
-bool BoundNetLog::IsLogging() const {
-  return NetLog::IsLogging(GetLogLevel());
+    return net_log_->GetCaptureMode();
+  return NetLogCaptureMode();
 }
 
 // static
 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);
 }
 
 void BoundNetLog::CrashIfInvalid() const {
   Liveness liveness = liveness_;
 
   if (liveness == ALIVE)
     return;
 
   base::debug::Alias(&liveness);
   CHECK_EQ(ALIVE, liveness);
 }
 
 }  // namespace net