Generalize the net module's LoadLog facility from a passive container, to an event stream (NetLog).

net/proxy/single_threaded_proxy_resolver_unittest.cc

 // Copyright (c) 2009 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 "base/waitable_event.h"
 #include "googleurl/src/gurl.h"
-#include "net/base/load_log.h"
-#include "net/base/load_log_unittest.h"
+#include "net/base/net_log.h"
+#include "net/base/net_log_unittest.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
 #include "net/proxy/proxy_info.h"
 #include "net/proxy/single_threaded_proxy_resolver.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 namespace {
 
 // A synchronous mock ProxyResolver implementation, which can be used in
 // conjunction with SingleThreadedProxyResolver.
 //       - returns a single-item proxy list with the query's host.
 class MockProxyResolver : public ProxyResolver {
  public:
   MockProxyResolver()
       : ProxyResolver(true /*expects_pac_bytes*/),
         wrong_loop_(MessageLoop::current()),
         request_count_(0),
         purge_count_(0),
         resolve_latency_ms_(0) {}
 
   // ProxyResolver implementation:
   virtual int GetProxyForURL(const GURL& query_url,
                              ProxyInfo* results,
                              CompletionCallback* callback,
                              RequestHandle* request,
-                             LoadLog* load_log) {
+                             const BoundNetLog& net_log) {
     if (resolve_latency_ms_)
       PlatformThread::Sleep(resolve_latency_ms_);
 
     CheckIsOnWorkerThread();
 
     EXPECT_TRUE(callback == NULL);
     EXPECT_TRUE(request == NULL);
 
-    // Write something into |load_log| (doesn't really have any meaning.)
-    LoadLog::BeginEvent(load_log, LoadLog::TYPE_PROXY_RESOLVER_V8_DNS_RESOLVE);
+    // Write something into |net_log| (doesn't really have any meaning.)
+    net_log.BeginEvent(NetLog::TYPE_PROXY_RESOLVER_V8_DNS_RESOLVE);
 
     results->UseNamedProxy(query_url.host());
 
     // Return a success code which represents the request's order.
     return request_count_++;
   }
 
   virtual void CancelRequest(RequestHandle request) {
     NOTREACHED();
   }
@@ skipping 61 matching lines @@
   }
 
   void WaitUntilBlocked() {
     blocked_.Wait();
   }
 
   virtual int GetProxyForURL(const GURL& query_url,
                              ProxyInfo* results,
                              CompletionCallback* callback,
                              RequestHandle* request,
-                             LoadLog* load_log) {
+                             const BoundNetLog& net_log) {
     if (should_block_) {
       blocked_.Signal();
       unblocked_.Wait();
     }
 
     return MockProxyResolver::GetProxyForURL(
-        query_url, results, callback, request, load_log);
+        query_url, results, callback, request, net_log);
   }
 
  private:
   bool should_block_;
   base::WaitableEvent unblocked_;
   base::WaitableEvent blocked_;
 };
 
 TEST(SingleThreadedProxyResolverTest, Basic) {
   MockProxyResolver* mock = new MockProxyResolver;
   SingleThreadedProxyResolver resolver(mock);
 
   int rv;
 
   EXPECT_TRUE(resolver.expects_pac_bytes());
 
   // Call SetPacScriptByData() -- verify that it reaches the synchronous
   // resolver.
   TestCompletionCallback set_script_callback;
   rv = resolver.SetPacScriptByData("pac script bytes", &set_script_callback);
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, set_script_callback.WaitForResult());
   EXPECT_EQ("pac script bytes", mock->last_pac_bytes());
 
   // Start request 0.
   TestCompletionCallback callback0;
-  scoped_refptr<LoadLog> log0(new LoadLog(LoadLog::kUnbounded));
+  CapturingBoundNetLog log0(CapturingNetLog::kUnbounded);
   ProxyInfo results0;
   rv = resolver.GetProxyForURL(
-      GURL("http://request0"), &results0, &callback0, NULL, log0);
+      GURL("http://request0"), &results0, &callback0, 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|.
-  EXPECT_EQ(1u, log0->entries().size());
+  EXPECT_EQ(1u, log0.entries().size());
 
   // Start 3 more requests (request1 to request3).
 
   TestCompletionCallback callback1;
   ProxyInfo results1;
   rv = resolver.GetProxyForURL(
       GURL("http://request1"), &results1, &callback1, NULL, NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   TestCompletionCallback callback2;
@@ skipping 29 matching lines @@
   resolver.PurgeMemory();
   // There is no way to get a callback directly when PurgeMemory() completes, so
   // we queue up a dummy request after the PurgeMemory() call and wait until it
   // finishes to ensure PurgeMemory() has had a chance to run.
   TestCompletionCallback dummy_callback;
   rv = resolver.SetPacScriptByData("dummy", &dummy_callback);
   EXPECT_EQ(OK, dummy_callback.WaitForResult());
   EXPECT_EQ(1, mock->purge_count());
 }
 
-// Tests that the LoadLog is updated to include the time the request was waiting
+// Tests that the NetLog is updated to include the time the request was waiting
 // to be scheduled to a thread.
-TEST(SingleThreadedProxyResolverTest, UpdatesLoadLogWithThreadWait) {
+TEST(SingleThreadedProxyResolverTest, UpdatesNetLogWithThreadWait) {
   BlockableProxyResolver* mock = new BlockableProxyResolver;
   SingleThreadedProxyResolver resolver(mock);
 
   int rv;
 
   // Block the proxy resolver, so no request can complete.
   mock->Block();
 
   // Start request 0.
   ProxyResolver::RequestHandle request0;
   TestCompletionCallback callback0;
   ProxyInfo results0;
-  scoped_refptr<LoadLog> log0(new LoadLog(LoadLog::kUnbounded));
+  CapturingBoundNetLog log0(CapturingNetLog::kUnbounded);
   rv = resolver.GetProxyForURL(
-      GURL("http://request0"), &results0, &callback0, &request0, log0);
+      GURL("http://request0"), &results0, &callback0, &request0, log0.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Start 2 more requests (request1 and request2).
 
   TestCompletionCallback callback1;
   ProxyInfo results1;
-  scoped_refptr<LoadLog> log1(new LoadLog(LoadLog::kUnbounded));
+  CapturingBoundNetLog log1(CapturingNetLog::kUnbounded);
   rv = resolver.GetProxyForURL(
-      GURL("http://request1"), &results1, &callback1, NULL, log1);
+      GURL("http://request1"), &results1, &callback1, NULL, log1.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   ProxyResolver::RequestHandle request2;
   TestCompletionCallback callback2;
   ProxyInfo results2;
-  scoped_refptr<LoadLog> log2(new LoadLog(LoadLog::kUnbounded));
+  CapturingBoundNetLog log2(CapturingNetLog::kUnbounded);
   rv = resolver.GetProxyForURL(
-      GURL("http://request2"), &results2, &callback2, &request2, log2);
+      GURL("http://request2"), &results2, &callback2, &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 LoadLog only has 1 entry (that came from the mock proxy resolver.)
+  // The NetLog only has 1 entry (that came from the mock proxy resolver.)
   EXPECT_EQ(0, callback0.WaitForResult());
   EXPECT_EQ("PROXY request0:80", results0.ToPacString());
-  ASSERT_EQ(1u, log0->entries().size());
+  ASSERT_EQ(1u, log0.entries().size());
 
   // Check that request 1 completed as expected.
   EXPECT_EQ(1, callback1.WaitForResult());
   EXPECT_EQ("PROXY request1:80", results1.ToPacString());
-  ASSERT_EQ(3u, log1->entries().size());
+  ASSERT_EQ(3u, log1.entries().size());
   EXPECT_TRUE(LogContainsBeginEvent(
-      *log1, 0, LoadLog::TYPE_WAITING_FOR_SINGLE_PROXY_RESOLVER_THREAD));
+      log1.entries(), 0,
+      NetLog::TYPE_WAITING_FOR_SINGLE_PROXY_RESOLVER_THREAD));
   EXPECT_TRUE(LogContainsEndEvent(
-      *log1, 1, LoadLog::TYPE_WAITING_FOR_SINGLE_PROXY_RESOLVER_THREAD));
+      log1.entries(), 1,
+      NetLog::TYPE_WAITING_FOR_SINGLE_PROXY_RESOLVER_THREAD));
 
   // Check that request 2 completed as expected.
   EXPECT_EQ(2, callback2.WaitForResult());
   EXPECT_EQ("PROXY request2:80", results2.ToPacString());
-  ASSERT_EQ(3u, log2->entries().size());
+  ASSERT_EQ(3u, log2.entries().size());
   EXPECT_TRUE(LogContainsBeginEvent(
-      *log2, 0, LoadLog::TYPE_WAITING_FOR_SINGLE_PROXY_RESOLVER_THREAD));
+      log2.entries(), 0,
+      NetLog::TYPE_WAITING_FOR_SINGLE_PROXY_RESOLVER_THREAD));
   EXPECT_TRUE(LogContainsEndEvent(
-      *log2, 1, LoadLog::TYPE_WAITING_FOR_SINGLE_PROXY_RESOLVER_THREAD));
+      log2.entries(), 1,
+      NetLog::TYPE_WAITING_FOR_SINGLE_PROXY_RESOLVER_THREAD));
 }
 
 // Cancel a request which is in progress, and then cancel a request which
 // is pending.
 TEST(SingleThreadedProxyResolverTest, CancelRequest) {
   BlockableProxyResolver* mock = new BlockableProxyResolver;
   SingleThreadedProxyResolver resolver(mock);
 
   int rv;
 
@@ skipping 162 matching lines @@
   rv = callback1.WaitForResult();
   EXPECT_EQ(1, rv);
   EXPECT_EQ("PROXY request1:80", results1.ToPacString());
 
   // The SetPacScript callback should never have been completed.
   EXPECT_FALSE(set_pac_script_callback.have_result());
 }
 
 }  // namespace
 }  // namespace net