Get rid of TestNetLog::CapturedEntry[List] typedefs.

net/proxy/proxy_resolver_v8_tracing_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.h"
 
 #include "base/files/file_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.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/captured_net_log_entry.h"
 #include "net/log/net_log.h"
 #include "net/log/net_log_unittest.h"
+#include "net/log/test_net_log.h"
 #include "net/proxy/proxy_info.h"
 #include "net/proxy/proxy_resolver_error_observer.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 namespace net {
 
 namespace {
 
 class ProxyResolverV8TracingTest : public testing::Test {
@@ skipping 112 matching lines @@
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(ERR_PAC_SCRIPT_FAILED, callback.WaitForResult());
 
   EXPECT_EQ(0u, host_resolver.num_resolve());
 
   EXPECT_EQ("Error: line 5: Uncaught TypeError: Cannot read property 'split' "
             "of null\n", error_observer->GetOutput());
 
   // Check the NetLogs -- there was 1 alert and 1 javascript error, and they
   // were output to both the global log, and per-request log.
-  TestNetLog::CapturedEntryList entries_list[2];
+  CapturedNetLogEntry::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 TestNetLog::CapturedEntryList& entries = entries_list[list_i];
+    const CapturedNetLogEntry::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_EQ("{\"message\":\"Prepare to DIE!\"}", entries[0].GetParamsJson());
     EXPECT_EQ("{\"line_number\":5,\"message\":\"Uncaught TypeError: Cannot "
@@ skipping 28 matching lines @@
   // Iteration3 runs in blocking mode and completes
   EXPECT_EQ("foo:3", proxy_info.proxy_server().ToURI());
 
   EXPECT_EQ(1u, host_resolver.num_resolve());
 
   // No errors.
   EXPECT_EQ("", error_observer->GetOutput());
 
   // Check the NetLogs -- the script generated 50 alerts, which were mirrored
   // to both the global and per-request logs.
-  TestNetLog::CapturedEntryList entries_list[2];
+  CapturedNetLogEntry::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 TestNetLog::CapturedEntryList& entries = entries_list[list_i];
+    const CapturedNetLogEntry::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));
     }
   }
 }
 
 // Verify that buffered alerts cannot grow unboundedly, even when the message is
@@ skipping 22 matching lines @@
 
   EXPECT_EQ("foo:3", proxy_info.proxy_server().ToURI());
 
   EXPECT_EQ(1u, host_resolver.num_resolve());
 
   // No errors.
   EXPECT_EQ("", error_observer->GetOutput());
 
   // Check the NetLogs -- the script generated 50 alerts, which were mirrored
   // to both the global and per-request logs.
-  TestNetLog::CapturedEntryList entries_list[2];
+  CapturedNetLogEntry::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 TestNetLog::CapturedEntryList& entries = entries_list[list_i];
+    const CapturedNetLogEntry::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));
     }
   }
 }
 
 // This test runs a PAC script that issues a sequence of DNS resolves. The test
@@ skipping 52 matching lines @@
     "166.155.144.44"  // dnsResolve('host1')
     ":99";
 
   EXPECT_EQ(kExpectedResult, proxy_info.proxy_server().ToURI());
 
   // No errors.
   EXPECT_EQ("", error_observer->GetOutput());
 
   // Check the NetLogs -- the script generated 1 alert, mirrored to both
   // the per-request and global logs.
-  TestNetLog::CapturedEntryList entries_list[2];
+  CapturedNetLogEntry::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 TestNetLog::CapturedEntryList& entries = entries_list[list_i];
+    const CapturedNetLogEntry::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_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
@@ skipping 83 matching lines @@
   EXPECT_EQ(3u, host_resolver.num_resolve());
 
   EXPECT_EQ("166.155.144.11-133.199.111.4:100",
             proxy_info.proxy_server().ToURI());
 
   // No errors.
   EXPECT_EQ("", error_observer->GetOutput());
 
   // Check the NetLogs -- the script generated 1 alert, mirrored to both
   // the per-request and global logs.
-  TestNetLog::CapturedEntryList entries_list[2];
+  CapturedNetLogEntry::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 TestNetLog::CapturedEntryList& entries = entries_list[list_i];
+    const CapturedNetLogEntry::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_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
@@ skipping 147 matching lines @@
 
   // Fetched host1 and host2 again, since the ones done during initialization
   // should not have been cached.
   EXPECT_EQ(4u, host_resolver.num_resolve());
 
   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());
-  TestNetLog::CapturedEntryList entries;
+  CapturedNetLogEntry::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));
 
@@ skipping 461 matching lines @@
                 proxy_uri.substr(0, proxy_uri.find(':') + 1));
     } else {
       NOTREACHED();
     }
   }
 }
 
 }  // namespace
 
 }  // namespace net