Rename NetLogLogger and CapturingNetLog

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"
@@ skipping 78 matching lines @@
   }
 
  private:
   base::Lock lock_;
   std::string output;
 
   base::WaitableEvent event_;
 };
 
 TEST_F(ProxyResolverV8TracingTest, Simple) {
-  CapturingNetLog log;
-  CapturingBoundNetLog request_log;
+  TestNetLog log;
+  BoundTestNetLog request_log;
   MockCachingHostResolver host_resolver;
   MockErrorObserver* error_observer = new MockErrorObserver;
   ProxyResolverV8Tracing resolver(&host_resolver, error_observer, &log);
 
   InitResolver(&resolver, "simple.js");
 
   TestCompletionCallback callback;
   ProxyInfo proxy_info;
 
   int rv = resolver.GetProxyForURL(
       GURL("http://foo/"), &proxy_info, callback.callback(),
       NULL, request_log.bound());
 
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback.WaitForResult());
 
   EXPECT_EQ("foo:99", proxy_info.proxy_server().ToURI());
 
   EXPECT_EQ(0u, host_resolver.num_resolve());
 
   // There were no errors.
   EXPECT_EQ("", error_observer->GetOutput());
 
   // Check the NetLogs -- nothing was logged.
   EXPECT_EQ(0u, log.GetSize());
   EXPECT_EQ(0u, request_log.GetSize());
 }
 
 TEST_F(ProxyResolverV8TracingTest, JavascriptError) {
-  CapturingNetLog log;
-  CapturingBoundNetLog request_log;
+  TestNetLog log;
+  BoundTestNetLog request_log;
   MockCachingHostResolver host_resolver;
   MockErrorObserver* error_observer = new MockErrorObserver;
   ProxyResolverV8Tracing resolver(&host_resolver, error_observer, &log);
 
   InitResolver(&resolver, "error.js");
 
   TestCompletionCallback callback;
   ProxyInfo proxy_info;
 
   int rv = resolver.GetProxyForURL(
       GURL("http://throw-an-error/"), &proxy_info, callback.callback(), NULL,
       request_log.bound());
 
   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.
-  CapturingNetLog::CapturedEntryList entries_list[2];
+  TestNetLog::CapturedEntryList 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 CapturingNetLog::CapturedEntryList& entries = entries_list[list_i];
+    const TestNetLog::CapturedEntryList& 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 "
               "read property 'split' of null\"}", entries[1].GetParamsJson());
   }
 }
 
 TEST_F(ProxyResolverV8TracingTest, TooManyAlerts) {
-  CapturingNetLog log;
-  CapturingBoundNetLog request_log;
+  TestNetLog log;
+  BoundTestNetLog request_log;
   MockCachingHostResolver host_resolver;
   MockErrorObserver* error_observer = new MockErrorObserver;
   ProxyResolverV8Tracing resolver(&host_resolver, error_observer, &log);
 
   InitResolver(&resolver, "too_many_alerts.js");
 
   TestCompletionCallback callback;
   ProxyInfo proxy_info;
 
   int rv = resolver.GetProxyForURL(
@@ skipping 11 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.
-  CapturingNetLog::CapturedEntryList entries_list[2];
+  TestNetLog::CapturedEntryList 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 CapturingNetLog::CapturedEntryList& entries = entries_list[list_i];
+    const TestNetLog::CapturedEntryList& 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
 // empty string.
 TEST_F(ProxyResolverV8TracingTest, TooManyEmptyAlerts) {
-  CapturingNetLog log;
-  CapturingBoundNetLog request_log;
+  TestNetLog log;
+  BoundTestNetLog request_log;
   MockCachingHostResolver host_resolver;
   MockErrorObserver* error_observer = new MockErrorObserver;
   ProxyResolverV8Tracing resolver(&host_resolver, error_observer, &log);
 
   InitResolver(&resolver, "too_many_empty_alerts.js");
 
   TestCompletionCallback callback;
   ProxyInfo proxy_info;
 
   int rv = resolver.GetProxyForURL(
       GURL("http://foo/"),
       &proxy_info,
       callback.callback(),
       NULL,
       request_log.bound());
 
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback.WaitForResult());
 
   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.
-  CapturingNetLog::CapturedEntryList entries_list[2];
+  TestNetLog::CapturedEntryList 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 CapturingNetLog::CapturedEntryList& entries = entries_list[list_i];
+    const TestNetLog::CapturedEntryList& 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
 // verifies the final result, and that the underlying DNS resolver received
 // the correct set of queries.
 TEST_F(ProxyResolverV8TracingTest, Dns) {
-  CapturingNetLog log;
-  CapturingBoundNetLog request_log;
+  TestNetLog log;
+  BoundTestNetLog request_log;
   MockCachingHostResolver host_resolver;
   MockErrorObserver* error_observer = new MockErrorObserver;
   ProxyResolverV8Tracing resolver(&host_resolver, error_observer, &log);
 
   host_resolver.rules()->AddRuleForAddressFamily(
       "host1", ADDRESS_FAMILY_IPV4, "166.155.144.44");
   host_resolver.rules()
       ->AddIPLiteralRule("host1", "::1,192.168.1.1", std::string());
   host_resolver.rules()->AddSimulatedFailure("host2");
   host_resolver.rules()->AddRule("host3", "166.155.144.33");
@@ skipping 37 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.
-  CapturingNetLog::CapturedEntryList entries_list[2];
+  TestNetLog::CapturedEntryList 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 CapturingNetLog::CapturedEntryList& entries = entries_list[list_i];
+    const TestNetLog::CapturedEntryList& 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
 // cache is warmed, subsequent calls should take 0 restarts.
 TEST_F(ProxyResolverV8TracingTest, DnsChecksCache) {
-  CapturingNetLog log;
-  CapturingBoundNetLog request_log;
+  TestNetLog log;
+  BoundTestNetLog request_log;
   MockCachingHostResolver host_resolver;
   MockErrorObserver* error_observer = new MockErrorObserver;
   ProxyResolverV8Tracing resolver(&host_resolver, error_observer, &log);
 
   host_resolver.rules()->AddRule("foopy", "166.155.144.11");
   host_resolver.rules()->AddRule("*", "122.133.144.155");
 
   InitResolver(&resolver, "simple_dns.js");
 
   TestCompletionCallback callback1;
@@ skipping 35 matching lines @@
   EXPECT_EQ("", error_observer->GetOutput());
 
   EXPECT_EQ(0u, log.GetSize());
   EXPECT_EQ(0u, request_log.GetSize());
 }
 
 // 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(ProxyResolverV8TracingTest, FallBackToSynchronous1) {
-  CapturingNetLog log;
-  CapturingBoundNetLog request_log;
+  TestNetLog log;
+  BoundTestNetLog request_log;
   MockCachingHostResolver host_resolver;
   MockErrorObserver* error_observer = new MockErrorObserver;
   ProxyResolverV8Tracing resolver(&host_resolver, error_observer, &log);
 
   host_resolver.rules()->AddRule("host1", "166.155.144.11");
   host_resolver.rules()->AddRule("crazy4", "133.199.111.4");
   host_resolver.rules()->AddRule("*", "122.133.144.155");
 
   InitResolver(&resolver, "global_sideffects1.js");
 
@@ skipping 12 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.
-  CapturingNetLog::CapturedEntryList entries_list[2];
+  TestNetLog::CapturedEntryList 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 CapturingNetLog::CapturedEntryList& entries = entries_list[list_i];
+    const TestNetLog::CapturedEntryList& 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
 // fall-back to synchronous mode execution.
 TEST_F(ProxyResolverV8TracingTest, FallBackToSynchronous2) {
-  CapturingNetLog log;
-  CapturingBoundNetLog request_log;
+  TestNetLog log;
+  BoundTestNetLog request_log;
   MockCachingHostResolver host_resolver;
   MockErrorObserver* error_observer = new MockErrorObserver;
   ProxyResolverV8Tracing resolver(&host_resolver, error_observer, &log);
 
   host_resolver.rules()->AddRule("host1", "166.155.144.11");
   host_resolver.rules()->AddRule("host2", "166.155.144.22");
   host_resolver.rules()->AddRule("host3", "166.155.144.33");
   host_resolver.rules()->AddRule("host4", "166.155.144.44");
   host_resolver.rules()->AddRule("*", "122.133.144.155");
 
@@ skipping 18 matching lines @@
   // Check the NetLogs -- nothing was logged.
   EXPECT_EQ(0u, log.GetSize());
   EXPECT_EQ(0u, request_log.GetSize());
 }
 
 // This test runs a weird PAC script that yields a never ending sequence
 // of DNS resolves when restarting. Running it will hit the maximum
 // DNS resolves per request limit (20) after which every DNS resolve will
 // fail.
 TEST_F(ProxyResolverV8TracingTest, InfiniteDNSSequence) {
-  CapturingNetLog log;
-  CapturingBoundNetLog request_log;
+  TestNetLog log;
+  BoundTestNetLog request_log;
   MockCachingHostResolver host_resolver;
   MockErrorObserver* error_observer = new MockErrorObserver;
   ProxyResolverV8Tracing resolver(&host_resolver, error_observer, &log);
 
   host_resolver.rules()->AddRule("host*", "166.155.144.11");
   host_resolver.rules()->AddRule("*", "122.133.144.155");
 
   InitResolver(&resolver, "global_sideffects3.js");
 
   TestCompletionCallback callback;
@@ skipping 21 matching lines @@
   // Check the NetLogs -- 1 alert was logged.
   EXPECT_EQ(1u, log.GetSize());
   EXPECT_EQ(1u, request_log.GetSize());
 }
 
 // This test runs a weird PAC script that yields a never ending sequence
 // of DNS resolves when restarting. Running it will hit the maximum
 // DNS resolves per request limit (20) after which every DNS resolve will
 // fail.
 TEST_F(ProxyResolverV8TracingTest, InfiniteDNSSequence2) {
-  CapturingNetLog log;
-  CapturingBoundNetLog request_log;
+  TestNetLog log;
+  BoundTestNetLog request_log;
   MockCachingHostResolver host_resolver;
   MockErrorObserver* error_observer = new MockErrorObserver;
   ProxyResolverV8Tracing resolver(&host_resolver, error_observer, &log);
 
   host_resolver.rules()->AddRule("host*", "166.155.144.11");
   host_resolver.rules()->AddRule("*", "122.133.144.155");
 
   InitResolver(&resolver, "global_sideffects4.js");
 
   TestCompletionCallback callback;
@@ skipping 11 matching lines @@
 
   // No errors.
   EXPECT_EQ("", error_observer->GetOutput());
 
   // Check the NetLogs -- 1 alert was logged.
   EXPECT_EQ(1u, log.GetSize());
   EXPECT_EQ(1u, request_log.GetSize());
 }
 
 void DnsDuringInitHelper(bool synchronous_host_resolver) {
-  CapturingNetLog log;
-  CapturingBoundNetLog request_log;
+  TestNetLog log;
+  BoundTestNetLog request_log;
   MockCachingHostResolver host_resolver;
   host_resolver.set_synchronous_mode(synchronous_host_resolver);
   MockErrorObserver* error_observer = new MockErrorObserver;
   ProxyResolverV8Tracing resolver(&host_resolver, error_observer, &log);
 
   host_resolver.rules()->AddRule("host1", "91.13.12.1");
   host_resolver.rules()->AddRule("host2", "91.13.12.2");
 
   InitResolver(&resolver, "dns_during_init.js");
 
@@ skipping 17 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());
-  CapturingNetLog::CapturedEntryList entries;
+  TestNetLog::CapturedEntryList 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 314 matching lines @@
 
   host_resolver.WaitUntilRequestIsReceived();
 
   resolver.CancelSetPacScript();
   EXPECT_EQ(1, host_resolver.num_cancelled_requests());
 }
 
 // This tests that the execution of a PAC script is terminated when the DNS
 // dependencies are missing. If the test fails, then it will hang.
 TEST_F(ProxyResolverV8TracingTest, Terminate) {
-  CapturingNetLog log;
-  CapturingBoundNetLog request_log;
+  TestNetLog log;
+  BoundTestNetLog request_log;
   MockCachingHostResolver host_resolver;
   MockErrorObserver* error_observer = new MockErrorObserver;
   ProxyResolverV8Tracing resolver(&host_resolver, error_observer, &log);
 
   host_resolver.rules()->AddRule("host1", "182.111.0.222");
   host_resolver.rules()->AddRule("host2", "111.33.44.55");
 
   InitResolver(&resolver, "terminate.js");
 
   TestCompletionCallback callback;
@@ skipping 125 matching lines @@
                 proxy_uri.substr(0, proxy_uri.find(':') + 1));
     } else {
       NOTREACHED();
     }
   }
 }
 
 }  // namespace
 
 }  // namespace net