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

net/proxy/proxy_resolver_v8_tracing_wrapper_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/proxy/proxy_resolver_v8_tracing_wrapper.h"
 
 #include <string>
 
 #include "base/files/file_util.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
 #include "base/run_loop.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/platform_thread.h"
 #include "base/values.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
 #include "net/dns/host_cache.h"
 #include "net/dns/mock_host_resolver.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/proxy_info.h"
 #include "net/proxy/proxy_resolver_error_observer.h"
 #include "net/test/event_waiter.h"
 #include "net/test/gtest_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
@@ skipping 146 matching lines @@
 
   // Check the NetLogs -- there was 1 alert and 1 javascript error, and they
   // were output to both the global log, and per-request log.
   TestNetLogEntry::List entries_list[2];
   log.GetEntries(&entries_list[0]);
   request_log.GetEntries(&entries_list[1]);
 
   for (size_t list_i = 0; list_i < arraysize(entries_list); list_i++) {
     const TestNetLogEntry::List& entries = entries_list[list_i];
     EXPECT_EQ(2u, entries.size());
-    EXPECT_TRUE(LogContainsEvent(entries, 0, NetLog::TYPE_PAC_JAVASCRIPT_ALERT,
-                                 NetLog::PHASE_NONE));
-    EXPECT_TRUE(LogContainsEvent(entries, 1, NetLog::TYPE_PAC_JAVASCRIPT_ERROR,
-                                 NetLog::PHASE_NONE));
+    EXPECT_TRUE(LogContainsEvent(entries, 0,
+                                 NetLogEventType::PAC_JAVASCRIPT_ALERT,
+                                 NetLogEventPhase::NONE));
+    EXPECT_TRUE(LogContainsEvent(entries, 1,
+                                 NetLogEventType::PAC_JAVASCRIPT_ERROR,
+                                 NetLogEventPhase::NONE));
 
     EXPECT_EQ("{\"message\":\"Prepare to DIE!\"}", entries[0].GetParamsJson());
     EXPECT_EQ(
         "{\"line_number\":5,\"message\":\"Uncaught TypeError: Cannot "
         "read property 'split' of null\"}",
         entries[1].GetParamsJson());
   }
 }
 
 TEST_F(ProxyResolverV8TracingWrapperTest, TooManyAlerts) {
@@ skipping 29 matching lines @@
   // Check the NetLogs -- the script generated 50 alerts, which were mirrored
   // to both the global and per-request logs.
   TestNetLogEntry::List entries_list[2];
   log.GetEntries(&entries_list[0]);
   request_log.GetEntries(&entries_list[1]);
 
   for (size_t list_i = 0; list_i < arraysize(entries_list); list_i++) {
     const TestNetLogEntry::List& entries = entries_list[list_i];
     EXPECT_EQ(50u, entries.size());
     for (size_t i = 0; i < entries.size(); ++i) {
-      ASSERT_TRUE(LogContainsEvent(
-          entries, i, NetLog::TYPE_PAC_JAVASCRIPT_ALERT, NetLog::PHASE_NONE));
+      ASSERT_TRUE(LogContainsEvent(entries, i,
+                                   NetLogEventType::PAC_JAVASCRIPT_ALERT,
+                                   NetLogEventPhase::NONE));
     }
   }
 }
 
 // Verify that buffered alerts cannot grow unboundedly, even when the message is
 // empty string.
 TEST_F(ProxyResolverV8TracingWrapperTest, TooManyEmptyAlerts) {
   TestNetLog log;
   BoundTestNetLog request_log;
   MockCachingHostResolver host_resolver;
@@ skipping 23 matching lines @@
   // Check the NetLogs -- the script generated 50 alerts, which were mirrored
   // to both the global and per-request logs.
   TestNetLogEntry::List entries_list[2];
   log.GetEntries(&entries_list[0]);
   request_log.GetEntries(&entries_list[1]);
 
   for (size_t list_i = 0; list_i < arraysize(entries_list); list_i++) {
     const TestNetLogEntry::List& entries = entries_list[list_i];
     EXPECT_EQ(1000u, entries.size());
     for (size_t i = 0; i < entries.size(); ++i) {
-      ASSERT_TRUE(LogContainsEvent(
-          entries, i, NetLog::TYPE_PAC_JAVASCRIPT_ALERT, NetLog::PHASE_NONE));
+      ASSERT_TRUE(LogContainsEvent(entries, i,
+                                   NetLogEventType::PAC_JAVASCRIPT_ALERT,
+                                   NetLogEventPhase::NONE));
     }
   }
 }
 
 // This test runs a PAC script that issues a sequence of DNS resolves. The test
 // verifies the final result, and that the underlying DNS resolver received
 // the correct set of queries.
 TEST_F(ProxyResolverV8TracingWrapperTest, Dns) {
   TestNetLog log;
   BoundTestNetLog request_log;
@@ skipping 51 matching lines @@
 
   // Check the NetLogs -- the script generated 1 alert, mirrored to both
   // the per-request and global logs.
   TestNetLogEntry::List entries_list[2];
   log.GetEntries(&entries_list[0]);
   request_log.GetEntries(&entries_list[1]);
 
   for (size_t list_i = 0; list_i < arraysize(entries_list); list_i++) {
     const TestNetLogEntry::List& entries = entries_list[list_i];
     EXPECT_EQ(1u, entries.size());
-    EXPECT_TRUE(LogContainsEvent(entries, 0, NetLog::TYPE_PAC_JAVASCRIPT_ALERT,
-                                 NetLog::PHASE_NONE));
+    EXPECT_TRUE(LogContainsEvent(entries, 0,
+                                 NetLogEventType::PAC_JAVASCRIPT_ALERT,
+                                 NetLogEventPhase::NONE));
     EXPECT_EQ("{\"message\":\"iteration: 7\"}", entries[0].GetParamsJson());
   }
 }
 
 // This test runs a PAC script that does "myIpAddress()" followed by
 // "dnsResolve()". This requires 2 restarts. However once the HostResolver's
 // cache is warmed, subsequent calls should take 0 restarts.
 TEST_F(ProxyResolverV8TracingWrapperTest, DnsChecksCache) {
   TestNetLog log;
   BoundTestNetLog request_log;
@@ skipping 81 matching lines @@
 
   // Check the NetLogs -- the script generated 1 alert, mirrored to both
   // the per-request and global logs.
   TestNetLogEntry::List entries_list[2];
   log.GetEntries(&entries_list[0]);
   request_log.GetEntries(&entries_list[1]);
 
   for (size_t list_i = 0; list_i < arraysize(entries_list); list_i++) {
     const TestNetLogEntry::List& entries = entries_list[list_i];
     EXPECT_EQ(1u, entries.size());
-    EXPECT_TRUE(LogContainsEvent(entries, 0, NetLog::TYPE_PAC_JAVASCRIPT_ALERT,
-                                 NetLog::PHASE_NONE));
+    EXPECT_TRUE(LogContainsEvent(entries, 0,
+                                 NetLogEventType::PAC_JAVASCRIPT_ALERT,
+                                 NetLogEventPhase::NONE));
     EXPECT_EQ("{\"message\":\"iteration: 4\"}", entries[0].GetParamsJson());
   }
 }
 
 // This test runs a weird PAC script that was designed to defeat the DNS tracing
 // optimization. The proxy resolver should detect the inconsistency and
 // fall-back to synchronous mode execution.
 TEST_F(ProxyResolverV8TracingWrapperTest, FallBackToSynchronous2) {
   TestNetLog log;
   BoundTestNetLog request_log;
@@ skipping 152 matching lines @@
 
   EXPECT_EQ("91.13.12.1-91.13.12.2-145.88.13.3-137.89.8.45:99",
             proxy_info.proxy_server().ToURI());
 
   // Check the NetLogs -- the script generated 2 alerts during initialization.
   EXPECT_EQ(0u, request_log.GetSize());
   TestNetLogEntry::List entries;
   log.GetEntries(&entries);
 
   ASSERT_EQ(2u, entries.size());
-  EXPECT_TRUE(LogContainsEvent(entries, 0, NetLog::TYPE_PAC_JAVASCRIPT_ALERT,
-                               NetLog::PHASE_NONE));
-  EXPECT_TRUE(LogContainsEvent(entries, 1, NetLog::TYPE_PAC_JAVASCRIPT_ALERT,
-                               NetLog::PHASE_NONE));
+  EXPECT_TRUE(LogContainsEvent(entries, 0,
+                               NetLogEventType::PAC_JAVASCRIPT_ALERT,
+                               NetLogEventPhase::NONE));
+  EXPECT_TRUE(LogContainsEvent(entries, 1,
+                               NetLogEventType::PAC_JAVASCRIPT_ALERT,
+                               NetLogEventPhase::NONE));
 
   EXPECT_EQ("{\"message\":\"Watsup\"}", entries[0].GetParamsJson());
   EXPECT_EQ("{\"message\":\"Watsup2\"}", entries[1].GetParamsJson());
 }
 
 // Tests a PAC script which does DNS resolves during initialization.
 TEST_F(ProxyResolverV8TracingWrapperTest, DnsDuringInit) {
   // Test with both both a host resolver that always completes asynchronously,
   // and then again with one that completes synchronously.
   DnsDuringInitHelper(false);
@@ skipping 492 matching lines @@
                 proxy_uri.substr(0, proxy_uri.find(':') + 1));
     } else {
       NOTREACHED();
     }
   }
 }
 
 }  // namespace
 
 }  // namespace net