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_level_(NetLogCaptureMode::NONE) {

[eroman, 2015/04/09 01:11:27]

Is it legal to initialize an atomic int in this manner, or must it be set using
NoBarrier_Store ?
Guess I will look into that tomorrow...

[mmenke, 2015/04/09 15:47:11]

It won't lead to bugs (Since we can only pass the NetLog to other threads with a
post message, or have other threads read the NetLog with a mutex or similar,
both of which include memory barriers, and can only be done strictly after
NetLog construction).  Whether it's legal or not, I couldn't tell you.  Ask a
lawyer?

 }
 
 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_level =
+      base::subtle::NoBarrier_Load(&effective_capture_mode_level_);
+  return NetLogCaptureMode(
+      static_cast<NetLogCaptureMode::Level>(capture_mode_level));
 }
 
 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;
   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.AddMode(observer->capture_mode());
   }
-  base::subtle::NoBarrier_Store(&effective_log_level_, new_effective_log_level);
+  base::subtle::NoBarrier_Store(&effective_capture_mode_level_,
+                                new_capture_mode.level());

[mmenke, 2015/04/09 15:47:11]

Should we really be storing the raw level here?  Seems like we should instead
have our own NetLogCaptureMode.  Suppose doing that safely does get hairy, but I
thought nothing should be using raw log levels?

[eroman, 2015/04/16 22:51:09]

I have made an allowance for NetLog (by friending it), and renamed these to
ToInternalValue() and FromInternalValue().

We could remove the dependency alltogether by having NetLog define its own
mapping to an integer, however that seemed less future proof. What do you think
of the current compromise?

 }
 
 // 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