Extracted NetLog class's inner enum types into their own enum classes and

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 <utility>
 
 #include "base/bind.h"
 #include "base/debug/alias.h"
@@ skipping 92 matching lines @@
       new base::DictionaryValue());
   event_params->SetString(name, *value);
   return std::move(event_params);
 }
 
 }  // namespace
 
 // LoadTimingInfo requires this be 0.
 const uint32_t NetLog::Source::kInvalidId = 0;
 
-NetLog::Source::Source() : type(SOURCE_NONE), id(kInvalidId) {
-}
+NetLog::Source::Source() : type(NetLogSourceType::NONE), id(kInvalidId) {}
 
-NetLog::Source::Source(SourceType type, uint32_t id) : type(type), id(id) {}
+NetLog::Source::Source(NetLogSourceType type, uint32_t id)
+    : type(type), id(id) {}
 
 bool NetLog::Source::IsValid() const {
   return id != kInvalidId;
 }
 
 void NetLog::Source::AddToEventParameters(
     base::DictionaryValue* event_params) const {
   std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
   dict->SetInteger("type", static_cast<int>(type));
   dict->SetInteger("id", static_cast<int>(id));
   event_params->Set("source_dependency", std::move(dict));
 }
 
 NetLog::ParametersCallback NetLog::Source::ToEventParametersCallback() const {
   return base::Bind(&SourceEventParametersCallback, *this);
 }
 
 // static
 bool NetLog::Source::FromEventParameters(base::Value* event_params,
                                          Source* source) {
   base::DictionaryValue* dict = NULL;
   base::DictionaryValue* source_dict = NULL;
   int source_id = -1;
-  int source_type = NetLog::SOURCE_COUNT;
+  int source_type = static_cast<int>(NetLogSourceType::COUNT);
   if (!event_params || !event_params->GetAsDictionary(&dict) ||
       !dict->GetDictionary("source_dependency", &source_dict) ||
       !source_dict->GetInteger("id", &source_id) ||
       !source_dict->GetInteger("type", &source_type)) {
     *source = Source();
     return false;
   }
 
   DCHECK_GE(source_id, 0);
-  DCHECK_LT(source_type, NetLog::SOURCE_COUNT);
-  *source = Source(static_cast<SourceType>(source_type), source_id);
+  DCHECK_LT(source_type, static_cast<int>(NetLogSourceType::COUNT));
+  *source = Source(static_cast<NetLogSourceType>(source_type), source_id);
   return true;
 }
 
 std::unique_ptr<base::Value> NetLog::Entry::ToValue() const {
   std::unique_ptr<base::DictionaryValue> entry_dict(
       new base::DictionaryValue());
 
   entry_dict->SetString("time", TickCountToString(data_->time));
 
   // Set the entry source.
@@ skipping 17 matching lines @@
 
   return std::move(entry_dict);
 }
 
 std::unique_ptr<base::Value> NetLog::Entry::ParametersToValue() const {
   if (data_->parameters_callback)
     return data_->parameters_callback->Run(capture_mode_);
   return nullptr;
 }
 
-NetLog::EntryData::EntryData(EventType type,
+NetLog::EntryData::EntryData(NetLogEventType type,
                              Source source,
-                             EventPhase phase,
+                             NetLogEventPhase phase,
                              base::TimeTicks time,
                              const ParametersCallback* parameters_callback)
     : type(type),
       source(source),
       phase(phase),
       time(time),
-      parameters_callback(parameters_callback) {
-}
+      parameters_callback(parameters_callback) {}
 
 NetLog::EntryData::~EntryData() {
 }
 
 NetLog::Entry::Entry(const EntryData* data, NetLogCaptureMode capture_mode)
     : data_(data), capture_mode_(capture_mode) {
 }
 
 NetLog::Entry::~Entry() {
 }
@@ skipping 20 matching lines @@
 void NetLog::ThreadSafeObserver::OnAddEntryData(const EntryData& entry_data) {
   OnAddEntry(Entry(&entry_data, capture_mode()));
 }
 
 NetLog::NetLog() : last_id_(0), is_capturing_(0) {
 }
 
 NetLog::~NetLog() {
 }
 
-void NetLog::AddGlobalEntry(EventType type) {
-  AddEntry(type, Source(NetLog::SOURCE_NONE, NextID()), NetLog::PHASE_NONE,
-           NULL);
+void NetLog::AddGlobalEntry(NetLogEventType type) {
+  AddEntry(type, Source(NetLogSourceType::NONE, NextID()),
+           NetLogEventPhase::NONE, NULL);
 }
 
 void NetLog::AddGlobalEntry(
-    EventType type,
+    NetLogEventType type,
     const NetLog::ParametersCallback& parameters_callback) {
-  AddEntry(type, Source(NetLog::SOURCE_NONE, NextID()), NetLog::PHASE_NONE,
-           &parameters_callback);
+  AddEntry(type, Source(NetLogSourceType::NONE, NextID()),
+           NetLogEventPhase::NONE, &parameters_callback);
 }
 
 uint32_t NetLog::NextID() {
   return base::subtle::NoBarrier_AtomicIncrement(&last_id_, 1);
 }
 
 bool NetLog::IsCapturing() const {
   return base::subtle::NoBarrier_Load(&is_capturing_) != 0;
 }
 
@@ skipping 34 matching lines @@
                                 observers_.might_have_observers() ? 1 : 0);
 }
 
 // static
 std::string NetLog::TickCountToString(const base::TimeTicks& time) {
   int64_t delta_time = (time - base::TimeTicks()).InMilliseconds();
   return base::Int64ToString(delta_time);
 }
 
 // static
-const char* NetLog::EventTypeToString(EventType event) {
+const char* NetLog::EventTypeToString(NetLogEventType event) {
   switch (event) {
-#define EVENT_TYPE(label) \
-  case TYPE_##label:      \
+#define EVENT_TYPE(label)      \
+  case NetLogEventType::label: \
     return #label;
 #include "net/log/net_log_event_type_list.h"
 #undef EVENT_TYPE
     default:
       NOTREACHED();
       return NULL;
   }
 }
 
 // static
 base::Value* NetLog::GetEventTypesAsValue() {
   std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
-  for (int i = 0; i < EVENT_COUNT; ++i) {
-    dict->SetInteger(EventTypeToString(static_cast<EventType>(i)), i);
+  for (int i = 0; i < static_cast<int>(NetLogEventType::COUNT); ++i) {
+    dict->SetInteger(EventTypeToString(static_cast<NetLogEventType>(i)), i);
   }
   return dict.release();
 }
 
 // static
-const char* NetLog::SourceTypeToString(SourceType source) {
+const char* NetLog::SourceTypeToString(NetLogSourceType source) {
   switch (source) {
-#define SOURCE_TYPE(label) \
-  case SOURCE_##label:     \
+#define SOURCE_TYPE(label)      \
+  case NetLogSourceType::label: \
     return #label;
 #include "net/log/net_log_source_type_list.h"
 #undef SOURCE_TYPE
     default:
       NOTREACHED();
       return NULL;
   }
 }
 
 // static
 base::Value* NetLog::GetSourceTypesAsValue() {
   std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
-  for (int i = 0; i < SOURCE_COUNT; ++i) {
-    dict->SetInteger(SourceTypeToString(static_cast<SourceType>(i)), i);
+  for (int i = 0; i < static_cast<int>(NetLogSourceType::COUNT); ++i) {
+    dict->SetInteger(SourceTypeToString(static_cast<NetLogSourceType>(i)), i);
   }
   return dict.release();
 }
 
 // static
-const char* NetLog::EventPhaseToString(EventPhase phase) {
+const char* NetLog::EventPhaseToString(NetLogEventPhase phase) {
   switch (phase) {
-    case PHASE_BEGIN:
+    case NetLogEventPhase::BEGIN:
       return "PHASE_BEGIN";
-    case PHASE_END:
+    case NetLogEventPhase::END:
       return "PHASE_END";
-    case PHASE_NONE:
+    case NetLogEventPhase::NONE:
       return "PHASE_NONE";
   }
   NOTREACHED();
   return NULL;
 }
 
 // static
 NetLog::ParametersCallback NetLog::BoolCallback(const char* name, bool value) {
   return base::Bind(&NetLogBoolCallback, name, value);
 }
@@ skipping 23 matching lines @@
   return base::Bind(&NetLogCharStringCallback, 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,
+void NetLog::AddEntry(NetLogEventType type,
                       const Source& source,
-                      EventPhase phase,
+                      NetLogEventPhase phase,
                       const NetLog::ParametersCallback* parameters_callback) {
   if (!IsCapturing())
     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() {
   liveness_ = DEAD;
 }
 
-void BoundNetLog::AddEntry(NetLog::EventType type,
-                           NetLog::EventPhase phase) const {
+void BoundNetLog::AddEntry(NetLogEventType type, NetLogEventPhase phase) const {
   CrashIfInvalid();
 
   if (!net_log_)
     return;
   net_log_->AddEntry(type, source_, phase, NULL);
 }
 
 void BoundNetLog::AddEntry(
-    NetLog::EventType type,
-    NetLog::EventPhase phase,
+    NetLogEventType type,
+    NetLogEventPhase phase,
     const NetLog::ParametersCallback& get_parameters) const {
   CrashIfInvalid();
 
   if (!net_log_)
     return;
   net_log_->AddEntry(type, source_, phase, &get_parameters);
 }
 
-void BoundNetLog::AddEvent(NetLog::EventType type) const {
-  AddEntry(type, NetLog::PHASE_NONE);
+void BoundNetLog::AddEvent(NetLogEventType type) const {
+  AddEntry(type, NetLogEventPhase::NONE);
 }
 
 void BoundNetLog::AddEvent(
-    NetLog::EventType type,
+    NetLogEventType type,
     const NetLog::ParametersCallback& get_parameters) const {
-  AddEntry(type, NetLog::PHASE_NONE, get_parameters);
+  AddEntry(type, NetLogEventPhase::NONE, get_parameters);
 }
 
-void BoundNetLog::BeginEvent(NetLog::EventType type) const {
-  AddEntry(type, NetLog::PHASE_BEGIN);
+void BoundNetLog::BeginEvent(NetLogEventType type) const {
+  AddEntry(type, NetLogEventPhase::BEGIN);
 }
 
 void BoundNetLog::BeginEvent(
-    NetLog::EventType type,
+    NetLogEventType type,
     const NetLog::ParametersCallback& get_parameters) const {
-  AddEntry(type, NetLog::PHASE_BEGIN, get_parameters);
+  AddEntry(type, NetLogEventPhase::BEGIN, get_parameters);
 }
 
-void BoundNetLog::EndEvent(NetLog::EventType type) const {
-  AddEntry(type, NetLog::PHASE_END);
+void BoundNetLog::EndEvent(NetLogEventType type) const {
+  AddEntry(type, NetLogEventPhase::END);
 }
 
 void BoundNetLog::EndEvent(
-    NetLog::EventType type,
+    NetLogEventType type,
     const NetLog::ParametersCallback& get_parameters) const {
-  AddEntry(type, NetLog::PHASE_END, get_parameters);
+  AddEntry(type, NetLogEventPhase::END, get_parameters);
 }
 
-void BoundNetLog::AddEventWithNetErrorCode(NetLog::EventType event_type,
+void BoundNetLog::AddEventWithNetErrorCode(NetLogEventType event_type,
                                            int net_error) const {
   DCHECK_NE(ERR_IO_PENDING, net_error);
   if (net_error >= 0) {
     AddEvent(event_type);
   } else {
     AddEvent(event_type, NetLog::IntCallback("net_error", net_error));
   }
 }
 
-void BoundNetLog::EndEventWithNetErrorCode(NetLog::EventType event_type,
+void BoundNetLog::EndEventWithNetErrorCode(NetLogEventType event_type,
                                            int net_error) const {
   DCHECK_NE(ERR_IO_PENDING, net_error);
   if (net_error >= 0) {
     EndEvent(event_type);
   } else {
     EndEvent(event_type, NetLog::IntCallback("net_error", net_error));
   }
 }
 
-void BoundNetLog::AddByteTransferEvent(NetLog::EventType event_type,
+void BoundNetLog::AddByteTransferEvent(NetLogEventType event_type,
                                        int byte_count,
                                        const char* bytes) const {
   AddEvent(event_type, base::Bind(BytesTransferredCallback, byte_count, bytes));
 }
 
 bool BoundNetLog::IsCapturing() const {
   CrashIfInvalid();
   return net_log_ && net_log_->IsCapturing();
 }
 
 // static
-BoundNetLog BoundNetLog::Make(NetLog* net_log, NetLog::SourceType source_type) {
+BoundNetLog BoundNetLog::Make(NetLog* net_log, NetLogSourceType 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