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

net/dns/host_resolver_impl_unittest.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/dns/host_resolver_impl.h"
 
 #include <algorithm>
 #include <memory>
 #include <string>
 #include <tuple>
@@ skipping 14 matching lines @@
 #include "base/synchronization/lock.h"
 #include "base/test/test_timeouts.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "net/base/address_list.h"
 #include "net/base/ip_address.h"
 #include "net/base/net_errors.h"
 #include "net/dns/dns_client.h"
 #include "net/dns/dns_test_util.h"
 #include "net/dns/mock_host_resolver.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/test/gtest_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using net::test::IsError;
 using net::test::IsOk;
 
 namespace net {
 
@@ skipping 1483 matching lines @@
   EXPECT_THAT(request->WaitForResult(), IsOk());
 }
 
 TEST_F(HostResolverImplTest, IsIPv6Reachable) {
   // The real HostResolverImpl is needed since TestHostResolverImpl will
   // bypass the IPv6 reachability tests.
   resolver_.reset(new HostResolverImpl(DefaultOptions(), nullptr));
 
   // Verify that two consecutive calls return the same value.
   TestNetLog net_log;
-  BoundNetLog bound_net_log = BoundNetLog::Make(&net_log, NetLog::SOURCE_NONE);
+  BoundNetLog bound_net_log =
+      BoundNetLog::Make(&net_log, NetLogSourceType::NONE);
   bool result1 = IsIPv6Reachable(bound_net_log);
   bool result2 = IsIPv6Reachable(bound_net_log);
   EXPECT_EQ(result1, result2);
 
   // Filter reachability check events and verify that there are two of them.
   TestNetLogEntry::List event_list;
   net_log.GetEntries(&event_list);
   TestNetLogEntry::List probe_event_list;
   for (const auto& event : event_list) {
-    if (event.type == NetLog::TYPE_HOST_RESOLVER_IMPL_IPV6_REACHABILITY_CHECK) {
+    if (event.type ==
+        NetLogEventType::HOST_RESOLVER_IMPL_IPV6_REACHABILITY_CHECK) {
       probe_event_list.push_back(event);
     }
   }
   ASSERT_EQ(2U, probe_event_list.size());
 
   // Verify that the first request was not cached and the second one was.
   bool cached;
   EXPECT_TRUE(probe_event_list[0].GetBooleanValue("cached", &cached));
   EXPECT_FALSE(cached);
   EXPECT_TRUE(probe_event_list[1].GetBooleanValue("cached", &cached));
@@ skipping 892 matching lines @@
   EXPECT_EQ(1, count2);
 
   // Make another request to make sure both callbacks were cleared.
   req = CreateRequest("just.testing", 80);
   EXPECT_THAT(req->Resolve(), IsOk());
   EXPECT_EQ(2, count1);
   EXPECT_EQ(1, count2);
 }
 
 }  // namespace net