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

net/log/net_log_unittest.cc

 // Copyright (c) 2013 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/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/simple_thread.h"
 #include "base/values.h"
 #include "net/base/net_errors.h"
+#include "net/log/net_log_event_type.h"
+#include "net/log/net_log_source_type.h"
 #include "net/log/test_net_log.h"
 #include "net/log/test_net_log_entry.h"
 #include "net/log/test_net_log_util.h"
 
 namespace net {
 
 namespace {
 
 const int kThreads = 10;
 const int kEvents = 100;
@@ skipping 25 matching lines @@
   dict->Set("capture_mode", CaptureModeToValue(capture_mode));
   return std::move(dict);
 }
 
 TEST(NetLogTest, Basic) {
   TestNetLog net_log;
   TestNetLogEntry::List entries;
   net_log.GetEntries(&entries);
   EXPECT_EQ(0u, entries.size());
 
-  net_log.AddGlobalEntry(NetLog::TYPE_CANCELLED);
+  net_log.AddGlobalEntry(NetLogEventType::CANCELLED);
 
   net_log.GetEntries(&entries);
   ASSERT_EQ(1u, entries.size());
-  EXPECT_EQ(NetLog::TYPE_CANCELLED, entries[0].type);
-  EXPECT_EQ(NetLog::SOURCE_NONE, entries[0].source.type);
+  EXPECT_EQ(NetLogEventType::CANCELLED, entries[0].type);
+  EXPECT_EQ(NetLogSourceType::NONE, entries[0].source.type);
   EXPECT_NE(NetLog::Source::kInvalidId, entries[0].source.id);
-  EXPECT_EQ(NetLog::PHASE_NONE, entries[0].phase);
+  EXPECT_EQ(NetLogEventPhase::NONE, entries[0].phase);
   EXPECT_GE(base::TimeTicks::Now(), entries[0].time);
   EXPECT_FALSE(entries[0].params);
 }
 
 // Check that the correct CaptureMode is sent to NetLog Value callbacks.
 TEST(NetLogTest, CaptureModes) {
   NetLogCaptureMode kModes[] = {
       NetLogCaptureMode::Default(),
       NetLogCaptureMode::IncludeCookiesAndCredentials(),
       NetLogCaptureMode::IncludeSocketBytes(),
   };
 
   TestNetLog net_log;
 
   for (NetLogCaptureMode mode : kModes) {
     net_log.SetCaptureMode(mode);
     EXPECT_EQ(mode, net_log.GetObserver()->capture_mode());
 
-    net_log.AddGlobalEntry(NetLog::TYPE_SOCKET_ALIVE,
+    net_log.AddGlobalEntry(NetLogEventType::SOCKET_ALIVE,
                            base::Bind(NetCaptureModeCallback));
 
     TestNetLogEntry::List entries;
     net_log.GetEntries(&entries);
 
     ASSERT_EQ(1u, entries.size());
-    EXPECT_EQ(NetLog::TYPE_SOCKET_ALIVE, entries[0].type);
-    EXPECT_EQ(NetLog::SOURCE_NONE, entries[0].source.type);
+    EXPECT_EQ(NetLogEventType::SOCKET_ALIVE, entries[0].type);
+    EXPECT_EQ(NetLogSourceType::NONE, entries[0].source.type);
     EXPECT_NE(NetLog::Source::kInvalidId, entries[0].source.id);
-    EXPECT_EQ(NetLog::PHASE_NONE, entries[0].phase);
+    EXPECT_EQ(NetLogEventPhase::NONE, entries[0].phase);
     EXPECT_GE(base::TimeTicks::Now(), entries[0].time);
 
     int logged_capture_mode;
     ASSERT_TRUE(
         entries[0].GetIntegerValue("capture_mode", &logged_capture_mode));
     EXPECT_EQ(CaptureModeToInt(mode), logged_capture_mode);
 
     net_log.Clear();
   }
 }
@@ skipping 34 matching lines @@
   size_t GetNumValues() const { return values_.size(); }
   base::DictionaryValue* GetValue(size_t index) const {
     return values_[index].get();
   }
 
  private:
   std::vector<std::unique_ptr<base::DictionaryValue>> values_;
 };
 
 void AddEvent(NetLog* net_log) {
-  net_log->AddGlobalEntry(NetLog::TYPE_CANCELLED,
+  net_log->AddGlobalEntry(NetLogEventType::CANCELLED,
                           base::Bind(CaptureModeToValue));
 }
 
 // A thread that waits until an event has been signalled before calling
 // RunTestThread.
 class NetLogTestThread : public base::SimpleThread {
  public:
   NetLogTestThread()
       : base::SimpleThread("NetLogTest"), net_log_(NULL), start_event_(NULL) {}
 
@@ skipping 233 matching lines @@
   NetLog net_log;
 
   // Run a bunch of threads to completion, each of which will repeatedly add
   // and remove an observer, and set its logging level.
   RunTestThreads<AddRemoveObserverTestThread>(&net_log);
 }
 
 }  // namespace
 
 }  // namespace net