Rename NetLogLogger and CapturingNetLog

net/proxy/multi_threaded_proxy_resolver_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/multi_threaded_proxy_resolver.h"
 
 #include "base/message_loop/message_loop.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
@@ skipping 176 matching lines @@
   rv = resolver.SetPacScript(
       ProxyResolverScriptData::FromUTF8("pac script bytes"),
       set_script_callback.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, set_script_callback.WaitForResult());
   EXPECT_EQ(ASCIIToUTF16("pac script bytes"),
             mock->last_script_data()->utf16());
 
   // Start request 0.
   TestCompletionCallback callback0;
-  CapturingBoundNetLog log0;
+  BoundTestNetLog log0;
   ProxyInfo results0;
   rv = resolver.GetProxyForURL(GURL("http://request0"), &results0,
                                callback0.callback(), NULL, log0.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Wait for request 0 to finish.
   rv = callback0.WaitForResult();
   EXPECT_EQ(0, rv);
   EXPECT_EQ("PROXY request0:80", results0.ToPacString());
 
   // The mock proxy resolver should have written 1 log entry. And
   // on completion, this should have been copied into |log0|.
   // We also have 1 log entry that was emitted by the
   // MultiThreadedProxyResolver.
-  CapturingNetLog::CapturedEntryList entries0;
+  TestNetLog::CapturedEntryList entries0;
   log0.GetEntries(&entries0);
 
   ASSERT_EQ(2u, entries0.size());
   EXPECT_EQ(NetLog::TYPE_SUBMITTED_TO_RESOLVER_THREAD, entries0[0].type);
 
   // Start 3 more requests (request1 to request3).
 
   TestCompletionCallback callback1;
   ProxyInfo results1;
   rv = resolver.GetProxyForURL(GURL("http://request1"), &results1,
@@ skipping 45 matching lines @@
                              init_callback.callback());
   EXPECT_EQ(OK, init_callback.WaitForResult());
 
   // Block the proxy resolver, so no request can complete.
   mock->Block();
 
   // Start request 0.
   ProxyResolver::RequestHandle request0;
   TestCompletionCallback callback0;
   ProxyInfo results0;
-  CapturingBoundNetLog log0;
+  BoundTestNetLog log0;
   rv = resolver.GetProxyForURL(GURL("http://request0"), &results0,
                                callback0.callback(), &request0, log0.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Start 2 more requests (request1 and request2).
 
   TestCompletionCallback callback1;
   ProxyInfo results1;
-  CapturingBoundNetLog log1;
+  BoundTestNetLog log1;
   rv = resolver.GetProxyForURL(GURL("http://request1"), &results1,
                                callback1.callback(), NULL, log1.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   ProxyResolver::RequestHandle request2;
   TestCompletionCallback callback2;
   ProxyInfo results2;
-  CapturingBoundNetLog log2;
+  BoundTestNetLog log2;
   rv = resolver.GetProxyForURL(GURL("http://request2"), &results2,
                                callback2.callback(), &request2, log2.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Unblock the worker thread so the requests can continue running.
   mock->WaitUntilBlocked();
   mock->Unblock();
 
   // Check that request 0 completed as expected.
   // The NetLog has 1 entry that came from the MultiThreadedProxyResolver, and
   // 1 entry from the mock proxy resolver.
   EXPECT_EQ(0, callback0.WaitForResult());
   EXPECT_EQ("PROXY request0:80", results0.ToPacString());
 
-  CapturingNetLog::CapturedEntryList entries0;
+  TestNetLog::CapturedEntryList entries0;
   log0.GetEntries(&entries0);
 
   ASSERT_EQ(2u, entries0.size());
   EXPECT_EQ(NetLog::TYPE_SUBMITTED_TO_RESOLVER_THREAD,
             entries0[0].type);
 
   // Check that request 1 completed as expected.
   EXPECT_EQ(1, callback1.WaitForResult());
   EXPECT_EQ("PROXY request1:80", results1.ToPacString());
 
-  CapturingNetLog::CapturedEntryList entries1;
+  TestNetLog::CapturedEntryList entries1;
   log1.GetEntries(&entries1);
 
   ASSERT_EQ(4u, entries1.size());
   EXPECT_TRUE(LogContainsBeginEvent(
       entries1, 0,
       NetLog::TYPE_WAITING_FOR_PROXY_RESOLVER_THREAD));
   EXPECT_TRUE(LogContainsEndEvent(
       entries1, 1,
       NetLog::TYPE_WAITING_FOR_PROXY_RESOLVER_THREAD));
 
   // Check that request 2 completed as expected.
   EXPECT_EQ(2, callback2.WaitForResult());
   EXPECT_EQ("PROXY request2:80", results2.ToPacString());
 
-  CapturingNetLog::CapturedEntryList entries2;
+  TestNetLog::CapturedEntryList entries2;
   log2.GetEntries(&entries2);
 
   ASSERT_EQ(4u, entries2.size());
   EXPECT_TRUE(LogContainsBeginEvent(
       entries2, 0,
       NetLog::TYPE_WAITING_FOR_PROXY_RESOLVER_THREAD));
   EXPECT_TRUE(LogContainsEndEvent(
       entries2, 1,
       NetLog::TYPE_WAITING_FOR_PROXY_RESOLVER_THREAD));
 }
@@ skipping 347 matching lines @@
   // All in all, the first thread should have seen just 1 request. And the
   // second thread 3 requests.
   ASSERT_EQ(2u, factory->resolvers().size());
   EXPECT_EQ(1, factory->resolvers()[0]->request_count());
   EXPECT_EQ(3, factory->resolvers()[1]->request_count());
 }
 
 }  // namespace
 
 }  // namespace net