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

net/proxy/proxy_service_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/proxy/proxy_service.h"
 
 #include <cstdarg>
 #include <string>
 #include <vector>
 
 #include "base/format_macros.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "net/base/net_errors.h"
 #include "net/base/proxy_delegate.h"
 #include "net/base/test_completion_callback.h"
 #include "net/log/net_log.h"
+#include "net/log/net_log_event_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"
 #include "net/proxy/dhcp_proxy_script_fetcher.h"
 #include "net/proxy/mock_proxy_resolver.h"
 #include "net/proxy/mock_proxy_script_fetcher.h"
 #include "net/proxy/proxy_config_service.h"
 #include "net/proxy/proxy_resolver.h"
 #include "net/proxy/proxy_script_fetcher.h"
 #include "net/test/gtest_util.h"
@@ skipping 346 matching lines @@
 
   EXPECT_TRUE(info.is_direct());
   EXPECT_TRUE(info.proxy_resolve_start_time().is_null());
   EXPECT_TRUE(info.proxy_resolve_end_time().is_null());
 
   // Check the NetLog was filled correctly.
   TestNetLogEntry::List entries;
   log.GetEntries(&entries);
 
   EXPECT_EQ(3u, entries.size());
-  EXPECT_TRUE(LogContainsBeginEvent(
-      entries, 0, NetLog::TYPE_PROXY_SERVICE));
+  EXPECT_TRUE(
+      LogContainsBeginEvent(entries, 0, NetLogEventType::PROXY_SERVICE));
   EXPECT_TRUE(LogContainsEvent(
-      entries, 1, NetLog::TYPE_PROXY_SERVICE_RESOLVED_PROXY_LIST,
-      NetLog::PHASE_NONE));
-  EXPECT_TRUE(LogContainsEndEvent(
-      entries, 2, NetLog::TYPE_PROXY_SERVICE));
+      entries, 1, NetLogEventType::PROXY_SERVICE_RESOLVED_PROXY_LIST,
+      NetLogEventPhase::NONE));
+  EXPECT_TRUE(LogContainsEndEvent(entries, 2, NetLogEventType::PROXY_SERVICE));
 }
 
 TEST_F(ProxyServiceTest, OnResolveProxyCallbackAddProxy) {
   ProxyConfig config;
   config.proxy_rules().ParseFromString("foopy1:8080");
   config.set_auto_detect(false);
   config.proxy_rules().bypass_rules.ParseFromString("*.org");
 
   ProxyService service(base::WrapUnique(new MockProxyConfigService(config)),
                        nullptr, nullptr);
@@ skipping 130 matching lines @@
 
   EXPECT_FALSE(info.proxy_resolve_start_time().is_null());
   EXPECT_FALSE(info.proxy_resolve_end_time().is_null());
   EXPECT_LE(info.proxy_resolve_start_time(), info.proxy_resolve_end_time());
 
   // Check the NetLog was filled correctly.
   TestNetLogEntry::List entries;
   log.GetEntries(&entries);
 
   EXPECT_EQ(5u, entries.size());
+  EXPECT_TRUE(
+      LogContainsBeginEvent(entries, 0, NetLogEventType::PROXY_SERVICE));
   EXPECT_TRUE(LogContainsBeginEvent(
-      entries, 0, NetLog::TYPE_PROXY_SERVICE));
-  EXPECT_TRUE(LogContainsBeginEvent(
-      entries, 1, NetLog::TYPE_PROXY_SERVICE_WAITING_FOR_INIT_PAC));
+      entries, 1, NetLogEventType::PROXY_SERVICE_WAITING_FOR_INIT_PAC));
   EXPECT_TRUE(LogContainsEndEvent(
-      entries, 2, NetLog::TYPE_PROXY_SERVICE_WAITING_FOR_INIT_PAC));
-  EXPECT_TRUE(LogContainsEndEvent(
-      entries, 4, NetLog::TYPE_PROXY_SERVICE));
+      entries, 2, NetLogEventType::PROXY_SERVICE_WAITING_FOR_INIT_PAC));
+  EXPECT_TRUE(LogContainsEndEvent(entries, 4, NetLogEventType::PROXY_SERVICE));
 }
 
 // Test that the proxy resolver does not see the URL's username/password
 // or its reference section.
 TEST_F(ProxyServiceTest, PAC_NoIdentityOrHash) {
   MockProxyConfigService* config_service =
       new MockProxyConfigService("http://foopy/proxy.pac");
 
   MockAsyncProxyResolver resolver;
   MockAsyncProxyResolverFactory* factory =
@@ skipping 1674 matching lines @@
   EXPECT_TRUE(resolver.cancelled_requests().empty());
 
   EXPECT_FALSE(callback1.have_result());  // Cancelled.
   EXPECT_FALSE(callback2.have_result());  // Cancelled.
 
   TestNetLogEntry::List entries1;
   log1.GetEntries(&entries1);
 
   // Check the NetLog for request 1 (which was cancelled) got filled properly.
   EXPECT_EQ(4u, entries1.size());
+  EXPECT_TRUE(
+      LogContainsBeginEvent(entries1, 0, NetLogEventType::PROXY_SERVICE));
   EXPECT_TRUE(LogContainsBeginEvent(
-      entries1, 0, NetLog::TYPE_PROXY_SERVICE));
-  EXPECT_TRUE(LogContainsBeginEvent(
-      entries1, 1, NetLog::TYPE_PROXY_SERVICE_WAITING_FOR_INIT_PAC));
-  // Note that TYPE_PROXY_SERVICE_WAITING_FOR_INIT_PAC is never completed before
+      entries1, 1, NetLogEventType::PROXY_SERVICE_WAITING_FOR_INIT_PAC));
+  // Note that PROXY_SERVICE_WAITING_FOR_INIT_PAC is never completed before
   // the cancellation occured.
-  EXPECT_TRUE(LogContainsEvent(
-      entries1, 2, NetLog::TYPE_CANCELLED, NetLog::PHASE_NONE));
-  EXPECT_TRUE(LogContainsEndEvent(
-      entries1, 3, NetLog::TYPE_PROXY_SERVICE));
+  EXPECT_TRUE(LogContainsEvent(entries1, 2, NetLogEventType::CANCELLED,
+                               NetLogEventPhase::NONE));
+  EXPECT_TRUE(LogContainsEndEvent(entries1, 3, NetLogEventType::PROXY_SERVICE));
 }
 
 // Test that if auto-detect fails, we fall-back to the custom pac.
 TEST_F(ProxyServiceTest, FallbackFromAutodetectToCustomPac) {
   const GURL url1("http://request1");
   const GURL url2("http://request2");
   ProxyConfig config;
   config.set_auto_detect(true);
   config.set_pac_url(GURL("http://foopy/proxy.pac"));
   config.proxy_rules().ParseFromString("http=foopy:80");  // Won't be used.
@@ skipping 522 matching lines @@
   EXPECT_THAT(callback2.WaitForResult(), IsOk());
   EXPECT_EQ("request2:80", info2.proxy_server().ToURI());
 
   // Check that the expected events were output to the log stream. In particular
   // PROXY_CONFIG_CHANGED should have only been emitted once (for the initial
   // setup), and NOT a second time when the IP address changed.
   TestNetLogEntry::List entries;
   log.GetEntries(&entries);
 
   EXPECT_TRUE(LogContainsEntryWithType(entries, 0,
-                                       NetLog::TYPE_PROXY_CONFIG_CHANGED));
+                                       NetLogEventType::PROXY_CONFIG_CHANGED));
   ASSERT_EQ(9u, entries.size());
   for (size_t i = 1; i < entries.size(); ++i)
-    EXPECT_NE(NetLog::TYPE_PROXY_CONFIG_CHANGED, entries[i].type);
+    EXPECT_NE(NetLogEventType::PROXY_CONFIG_CHANGED, entries[i].type);
 }
 
 // This test verifies that the PAC script specified by the settings is
 // periodically polled for changes. Specifically, if the initial fetch fails due
 // to a network error, we will eventually re-configure the service to use the
 // script once it becomes available.
 TEST_F(ProxyServiceTest, PACScriptRefetchAfterFailure) {
   // Change the retry policy to wait a mere 1 ms before retrying, so the test
   // runs quickly.
   ImmediatePollPolicy poll_policy;
@@ skipping 852 matching lines @@
         GURL(test.sanitized_url_unstripped),
         helper.SanitizeUrl(raw_url, ProxyService::SanitizeUrlPolicy::UNSAFE));
 
     EXPECT_EQ(
         GURL(test.sanitized_url),
         helper.SanitizeUrl(raw_url, ProxyService::SanitizeUrlPolicy::SAFE));
   }
 }
 
 }  // namespace net