Rename NetLogLogger and CapturingNetLog

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 <vector>
 
 #include "base/format_macros.h"
 #include "base/logging.h"
@@ skipping 231 matching lines @@
 TEST_F(ProxyServiceTest, Direct) {
   MockAsyncProxyResolver resolver;
   ProxyService service(
       new MockProxyConfigService(ProxyConfig::CreateDirect()),
       make_scoped_ptr(new ForwardingProxyResolverFactory(&resolver)), NULL);
 
   GURL url("http://www.google.com/");
 
   ProxyInfo info;
   TestCompletionCallback callback;
-  CapturingBoundNetLog log;
+  BoundTestNetLog log;
   int rv = service.ResolveProxy(
       url, net::LOAD_NORMAL, &info, callback.callback(), NULL, NULL,
       log.bound());
   EXPECT_EQ(OK, rv);
   EXPECT_TRUE(resolver.pending_requests().empty());
 
   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.
-  CapturingNetLog::CapturedEntryList entries;
+  TestNetLog::CapturedEntryList entries;
   log.GetEntries(&entries);
 
   EXPECT_EQ(3u, entries.size());
   EXPECT_TRUE(LogContainsBeginEvent(
       entries, 0, NetLog::TYPE_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));
 }
 
 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(new MockProxyConfigService(config), nullptr, NULL);
 
   GURL url("http://www.google.com/");
   GURL bypass_url("http://internet.org");
 
   ProxyInfo info;
   TestCompletionCallback callback;
-  CapturingBoundNetLog log;
+  BoundTestNetLog log;
 
   // First, warm up the ProxyService.
   int rv = service.ResolveProxy(
       url, net::LOAD_NORMAL, &info, callback.callback(), NULL, NULL,
       log.bound());
   EXPECT_EQ(OK, rv);
 
   // Verify that network delegate is invoked.
   TestResolveProxyNetworkDelegate delegate;
   rv = service.ResolveProxy(
@@ skipping 38 matching lines @@
   config.set_auto_detect(false);
   config.proxy_rules().bypass_rules.ParseFromString("*.org");
 
   ProxyService service(new MockProxyConfigService(config), nullptr, NULL);
 
   GURL url("http://www.google.com/");
   GURL bypass_url("http://internet.org");
 
   ProxyInfo info;
   TestCompletionCallback callback;
-  CapturingBoundNetLog log;
+  BoundTestNetLog log;
 
   // First, warm up the ProxyService.
   int rv = service.ResolveProxy(
       url, net::LOAD_NORMAL, &info, callback.callback(), NULL, NULL,
       log.bound());
   EXPECT_EQ(OK, rv);
 
   TestResolveProxyNetworkDelegate delegate;
   delegate.set_remove_proxy(true);
 
@@ skipping 26 matching lines @@
 
   ProxyService service(
       config_service,
       make_scoped_ptr(new ForwardingProxyResolverFactory(&resolver)), NULL);
 
   GURL url("http://www.google.com/");
 
   ProxyInfo info;
   TestCompletionCallback callback;
   ProxyService::PacRequest* request;
-  CapturingBoundNetLog log;
+  BoundTestNetLog log;
 
   int rv = service.ResolveProxy(
       url, net::LOAD_NORMAL, &info, callback.callback(), &request, NULL,
       log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   EXPECT_EQ(LOAD_STATE_RESOLVING_PROXY_FOR_URL, service.GetLoadState(request));
 
   EXPECT_EQ(GURL("http://foopy/proxy.pac"),
             resolver.pending_set_pac_script_request()->script_data()->url());
   resolver.pending_set_pac_script_request()->CompleteNow(OK);
 
   ASSERT_EQ(1u, resolver.pending_requests().size());
   EXPECT_EQ(url, resolver.pending_requests()[0]->url());
 
   // Set the result in proxy resolver.
   resolver.pending_requests()[0]->results()->UseNamedProxy("foopy");
   resolver.pending_requests()[0]->CompleteNow(OK);
 
   EXPECT_EQ(OK, callback.WaitForResult());
   EXPECT_FALSE(info.is_direct());
   EXPECT_EQ("foopy:80", info.proxy_server().ToURI());
   EXPECT_TRUE(info.did_use_pac_script());
 
   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.
-  CapturingNetLog::CapturedEntryList entries;
+  TestNetLog::CapturedEntryList entries;
   log.GetEntries(&entries);
 
   EXPECT_EQ(5u, entries.size());
   EXPECT_TRUE(LogContainsBeginEvent(
       entries, 0, NetLog::TYPE_PROXY_SERVICE));
   EXPECT_TRUE(LogContainsBeginEvent(
       entries, 1, NetLog::TYPE_PROXY_SERVICE_WAITING_FOR_INIT_PAC));
   EXPECT_TRUE(LogContainsEndEvent(
       entries, 2, NetLog::TYPE_PROXY_SERVICE_WAITING_FOR_INIT_PAC));
   EXPECT_TRUE(LogContainsEndEvent(
@@ skipping 1469 matching lines @@
       make_scoped_ptr(new ForwardingProxyResolverFactory(&resolver)), NULL);
 
   MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
   service.SetProxyScriptFetchers(fetcher,
                                  new DoNothingDhcpProxyScriptFetcher());
 
   // Start 3 requests.
   ProxyInfo info1;
   TestCompletionCallback callback1;
   ProxyService::PacRequest* request1;
-  CapturingBoundNetLog log1;
+  BoundTestNetLog log1;
   int rv = service.ResolveProxy(GURL("http://request1"), net::LOAD_NORMAL,
                                 &info1, callback1.callback(), &request1, NULL,
                                 log1.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // The first request should have triggered download of PAC script.
   EXPECT_TRUE(fetcher->has_pending_request());
   EXPECT_EQ(GURL("http://foopy/proxy.pac"), fetcher->pending_request_url());
 
   ProxyInfo info2;
@@ skipping 36 matching lines @@
   resolver.pending_requests()[0]->CompleteNow(OK);
 
   EXPECT_EQ(OK, callback3.WaitForResult());
   EXPECT_EQ("request3:80", info3.proxy_server().ToURI());
 
   EXPECT_TRUE(resolver.cancelled_requests().empty());
 
   EXPECT_FALSE(callback1.have_result());  // Cancelled.
   EXPECT_FALSE(callback2.have_result());  // Cancelled.
 
-  CapturingNetLog::CapturedEntryList entries1;
+  TestNetLog::CapturedEntryList 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, 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
   // the cancellation occured.
@@ skipping 432 matching lines @@
 
   EXPECT_TRUE(info2.is_direct());
 }
 
 TEST_F(ProxyServiceTest, NetworkChangeTriggersPacRefetch) {
   MockProxyConfigService* config_service =
       new MockProxyConfigService("http://foopy/proxy.pac");
 
   MockAsyncProxyResolverExpectsBytes resolver;
 
-  CapturingNetLog log;
+  TestNetLog log;
 
   ProxyService service(
       config_service,
       make_scoped_ptr(new ForwardingProxyResolverFactory(&resolver)), &log);
 
   MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
   service.SetProxyScriptFetchers(fetcher,
                                  new DoNothingDhcpProxyScriptFetcher());
 
   // Disable the "wait after IP address changes" hack, so this unit-test can
@@ skipping 76 matching lines @@
   resolver.pending_requests()[0]->results()->UseNamedProxy("request2:80");
   resolver.pending_requests()[0]->CompleteNow(OK);
 
   // Wait for completion callback, and verify that the request ran as expected.
   EXPECT_EQ(OK, callback2.WaitForResult());
   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.
-  CapturingNetLog::CapturedEntryList entries;
+  TestNetLog::CapturedEntryList entries;
   log.GetEntries(&entries);
 
   EXPECT_TRUE(LogContainsEntryWithType(entries, 0,
                                        NetLog::TYPE_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);
 }
 
 // This test verifies that the PAC script specified by the settings is
@@ skipping 590 matching lines @@
   MockAsyncProxyResolver resolver;
 
   ProxyService service(
       config_service,
       make_scoped_ptr(new ForwardingProxyResolverFactory(&resolver)), NULL);
 
   GURL url("http://www.google.com/");
 
   ProxyInfo info;
   info.UseDirect();
-  CapturingBoundNetLog log;
+  BoundTestNetLog log;
 
   bool synchronous_success = service.TryResolveProxySynchronously(
       url, net::LOAD_NORMAL, &info, NULL, log.bound());
   EXPECT_FALSE(synchronous_success);
 
   // No request should have been queued.
   EXPECT_EQ(0u, resolver.pending_requests().size());
 
   // |info| should not have been modified.
   EXPECT_TRUE(info.is_direct());
 }
 
 // Test that synchronous results are returned correctly if a fixed proxy
 // configuration is active.
 TEST_F(ProxyServiceTest, SynchronousWithFixedConfiguration) {
   ProxyConfig config;
   config.proxy_rules().ParseFromString("foopy1:8080");
   config.set_auto_detect(false);
 
   MockAsyncProxyResolver resolver;
 
   ProxyService service(
       new MockProxyConfigService(config),
       make_scoped_ptr(new ForwardingProxyResolverFactory(&resolver)), NULL);
 
   GURL url("http://www.google.com/");
 
   ProxyInfo info;
-  CapturingBoundNetLog log;
+  BoundTestNetLog log;
 
   bool synchronous_success = service.TryResolveProxySynchronously(
       url, net::LOAD_NORMAL, &info, NULL, log.bound());
   EXPECT_TRUE(synchronous_success);
   EXPECT_FALSE(info.is_direct());
   EXPECT_EQ("foopy1", info.proxy_server().host_port_pair().host());
 
   // No request should have been queued.
   EXPECT_EQ(0u, resolver.pending_requests().size());
 }
 
 }  // namespace net