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

net/proxy/init_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 <vector>
 
 #include "net/base/net_errors.h"
-#include "net/base/load_log.h"
-#include "net/base/load_log_util.h"
-#include "net/base/load_log_unittest.h"
+#include "net/base/net_log.h"
+#include "net/base/net_log_unittest.h"
 #include "net/base/test_completion_callback.h"
 #include "net/proxy/init_proxy_resolver.h"
 #include "net/proxy/proxy_config.h"
 #include "net/proxy/proxy_resolver.h"
 #include "net/proxy/proxy_script_fetcher.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 namespace {
 
@@ skipping 92 matching lines @@
 class RuleBasedProxyResolver : public ProxyResolver {
  public:
   RuleBasedProxyResolver(const Rules* rules, bool expects_pac_bytes)
       : ProxyResolver(expects_pac_bytes), rules_(rules) {}
 
   // ProxyResolver implementation:
   virtual int GetProxyForURL(const GURL& /*url*/,
                              ProxyInfo* /*results*/,
                              CompletionCallback* /*callback*/,
                              RequestHandle* /*request_handle*/,
-                             LoadLog* /*load_log*/) {
+                             const BoundNetLog& /*net_log*/) {
     NOTREACHED();
     return ERR_UNEXPECTED;
   }
 
   virtual void CancelRequest(RequestHandle request_handle) {
     NOTREACHED();
   }
 
   virtual int SetPacScript(const GURL& pac_url,
                            const std::string& pac_bytes,
@@ skipping 31 matching lines @@
   Rules rules;
   RuleBasedProxyResolver resolver(&rules, true /*expects_pac_bytes*/);
   RuleBasedProxyScriptFetcher fetcher(&rules);
 
   ProxyConfig config;
   config.set_pac_url(GURL("http://custom/proxy.pac"));
 
   Rules::Rule rule = rules.AddSuccessRule("http://custom/proxy.pac");
 
   TestCompletionCallback callback;
-  scoped_refptr<LoadLog> log(new LoadLog(LoadLog::kUnbounded));
+  CapturingBoundNetLog log(CapturingNetLog::kUnbounded);
   InitProxyResolver init(&resolver, &fetcher);
-  EXPECT_EQ(OK, init.Init(config, &callback, log));
+  EXPECT_EQ(OK, init.Init(config, &callback, log.bound()));
   EXPECT_EQ(rule.bytes(), resolver.pac_bytes());
 
-  // Check the LoadLog was filled correctly.
-  EXPECT_EQ(9u, log->entries().size());
+  // Check the NetLog was filled correctly.
+  EXPECT_EQ(9u, log.entries().size());
   EXPECT_TRUE(LogContainsBeginEvent(
-      *log, 0, LoadLog::TYPE_INIT_PROXY_RESOLVER));
+      log.entries(), 0, NetLog::TYPE_INIT_PROXY_RESOLVER));
   EXPECT_TRUE(LogContainsBeginEvent(
-      *log, 1, LoadLog::TYPE_INIT_PROXY_RESOLVER_FETCH_PAC_SCRIPT));
+      log.entries(), 1, NetLog::TYPE_INIT_PROXY_RESOLVER_FETCH_PAC_SCRIPT));
   EXPECT_TRUE(LogContainsEndEvent(
-      *log, 4, LoadLog::TYPE_INIT_PROXY_RESOLVER_FETCH_PAC_SCRIPT));
+      log.entries(), 4, NetLog::TYPE_INIT_PROXY_RESOLVER_FETCH_PAC_SCRIPT));
   EXPECT_TRUE(LogContainsBeginEvent(
-      *log, 5, LoadLog::TYPE_INIT_PROXY_RESOLVER_SET_PAC_SCRIPT));
+      log.entries(), 5, NetLog::TYPE_INIT_PROXY_RESOLVER_SET_PAC_SCRIPT));
   EXPECT_TRUE(LogContainsEndEvent(
-      *log, 7, LoadLog::TYPE_INIT_PROXY_RESOLVER_SET_PAC_SCRIPT));
-  EXPECT_TRUE(LogContainsEndEvent(*log, 8, LoadLog::TYPE_INIT_PROXY_RESOLVER));
+      log.entries(), 7, NetLog::TYPE_INIT_PROXY_RESOLVER_SET_PAC_SCRIPT));
+  EXPECT_TRUE(LogContainsEndEvent(
+      log.entries(), 8, NetLog::TYPE_INIT_PROXY_RESOLVER));
 }
 
 // Fail downloading the custom PAC script.
 TEST(InitProxyResolverTest, CustomPacFails1) {
   Rules rules;
   RuleBasedProxyResolver resolver(&rules, true /*expects_pac_bytes*/);
   RuleBasedProxyScriptFetcher fetcher(&rules);
 
   ProxyConfig config;
   config.set_pac_url(GURL("http://custom/proxy.pac"));
 
   rules.AddFailDownloadRule("http://custom/proxy.pac");
 
   TestCompletionCallback callback;
-  scoped_refptr<LoadLog> log(new LoadLog(LoadLog::kUnbounded));
+  CapturingBoundNetLog log(CapturingNetLog::kUnbounded);
   InitProxyResolver init(&resolver, &fetcher);
-  EXPECT_EQ(kFailedDownloading, init.Init(config, &callback, log));
+  EXPECT_EQ(kFailedDownloading, init.Init(config, &callback, log.bound()));
   EXPECT_EQ("", resolver.pac_bytes());
 
-  // Check the LoadLog was filled correctly.
-  EXPECT_EQ(6u, log->entries().size());
+  // Check the NetLog was filled correctly.
+  EXPECT_EQ(6u, log.entries().size());
   EXPECT_TRUE(LogContainsBeginEvent(
-      *log, 0, LoadLog::TYPE_INIT_PROXY_RESOLVER));
+      log.entries(), 0, NetLog::TYPE_INIT_PROXY_RESOLVER));
   EXPECT_TRUE(LogContainsBeginEvent(
-      *log, 1, LoadLog::TYPE_INIT_PROXY_RESOLVER_FETCH_PAC_SCRIPT));
+      log.entries(), 1, NetLog::TYPE_INIT_PROXY_RESOLVER_FETCH_PAC_SCRIPT));
   EXPECT_TRUE(LogContainsEndEvent(
-      *log, 4, LoadLog::TYPE_INIT_PROXY_RESOLVER_FETCH_PAC_SCRIPT));
-  EXPECT_TRUE(LogContainsEndEvent(*log, 5, LoadLog::TYPE_INIT_PROXY_RESOLVER));
+      log.entries(), 4, NetLog::TYPE_INIT_PROXY_RESOLVER_FETCH_PAC_SCRIPT));
+  EXPECT_TRUE(LogContainsEndEvent(
+      log.entries(), 5, NetLog::TYPE_INIT_PROXY_RESOLVER));
 }
 
 // Fail parsing the custom PAC script.
 TEST(InitProxyResolverTest, CustomPacFails2) {
   Rules rules;
   RuleBasedProxyResolver resolver(&rules, true /*expects_pac_bytes*/);
   RuleBasedProxyScriptFetcher fetcher(&rules);
 
   ProxyConfig config;
   config.set_pac_url(GURL("http://custom/proxy.pac"));
@@ skipping 63 matching lines @@
   RuleBasedProxyScriptFetcher fetcher(&rules);
 
   ProxyConfig config;
   config.set_auto_detect(true);
   config.set_pac_url(GURL("http://custom/proxy.pac"));
 
   rules.AddFailParsingRule("http://wpad/wpad.dat");
   Rules::Rule rule = rules.AddSuccessRule("http://custom/proxy.pac");
 
   TestCompletionCallback callback;
-  scoped_refptr<LoadLog> log(new LoadLog(LoadLog::kUnbounded));
+  CapturingBoundNetLog log(CapturingNetLog::kUnbounded);
   InitProxyResolver init(&resolver, &fetcher);
-  EXPECT_EQ(OK, init.Init(config, &callback, log));
+  EXPECT_EQ(OK, init.Init(config, &callback, log.bound()));
   EXPECT_EQ(rule.bytes(), resolver.pac_bytes());
 
-  // Check the LoadLog was filled correctly.
+  // Check the NetLog was filled correctly.
   // (Note that the Fetch and Set states are repeated since both WPAD and custom
   // PAC scripts are tried).
-  EXPECT_EQ(17u, log->entries().size());
+  EXPECT_EQ(17u, log.entries().size());
   EXPECT_TRUE(LogContainsBeginEvent(
-      *log, 0, LoadLog::TYPE_INIT_PROXY_RESOLVER));
+      log.entries(), 0, NetLog::TYPE_INIT_PROXY_RESOLVER));
   EXPECT_TRUE(LogContainsBeginEvent(
-      *log, 1, LoadLog::TYPE_INIT_PROXY_RESOLVER_FETCH_PAC_SCRIPT));
+      log.entries(), 1, NetLog::TYPE_INIT_PROXY_RESOLVER_FETCH_PAC_SCRIPT));
   EXPECT_TRUE(LogContainsEndEvent(
-      *log, 4, LoadLog::TYPE_INIT_PROXY_RESOLVER_FETCH_PAC_SCRIPT));
+      log.entries(), 4, NetLog::TYPE_INIT_PROXY_RESOLVER_FETCH_PAC_SCRIPT));
   EXPECT_TRUE(LogContainsBeginEvent(
-      *log, 5, LoadLog::TYPE_INIT_PROXY_RESOLVER_SET_PAC_SCRIPT));
+      log.entries(), 5, NetLog::TYPE_INIT_PROXY_RESOLVER_SET_PAC_SCRIPT));
   EXPECT_TRUE(LogContainsEndEvent(
-      *log, 7, LoadLog::TYPE_INIT_PROXY_RESOLVER_SET_PAC_SCRIPT));
+      log.entries(), 7, NetLog::TYPE_INIT_PROXY_RESOLVER_SET_PAC_SCRIPT));
   EXPECT_TRUE(LogContainsBeginEvent(
-      *log, 9, LoadLog::TYPE_INIT_PROXY_RESOLVER_FETCH_PAC_SCRIPT));
+      log.entries(), 9, NetLog::TYPE_INIT_PROXY_RESOLVER_FETCH_PAC_SCRIPT));
   EXPECT_TRUE(LogContainsEndEvent(
-      *log, 12, LoadLog::TYPE_INIT_PROXY_RESOLVER_FETCH_PAC_SCRIPT));
+      log.entries(), 12, NetLog::TYPE_INIT_PROXY_RESOLVER_FETCH_PAC_SCRIPT));
   EXPECT_TRUE(LogContainsBeginEvent(
-      *log, 13, LoadLog::TYPE_INIT_PROXY_RESOLVER_SET_PAC_SCRIPT));
+      log.entries(), 13, NetLog::TYPE_INIT_PROXY_RESOLVER_SET_PAC_SCRIPT));
   EXPECT_TRUE(LogContainsEndEvent(
-      *log, 15, LoadLog::TYPE_INIT_PROXY_RESOLVER_SET_PAC_SCRIPT));
-  EXPECT_TRUE(LogContainsEndEvent(*log, 16, LoadLog::TYPE_INIT_PROXY_RESOLVER));
+      log.entries(), 15, NetLog::TYPE_INIT_PROXY_RESOLVER_SET_PAC_SCRIPT));
+  EXPECT_TRUE(LogContainsEndEvent(
+      log.entries(), 16, NetLog::TYPE_INIT_PROXY_RESOLVER));
 }
 
 // Fails at WPAD (downloading), and fails at custom PAC (downloading).
 TEST(InitProxyResolverTest, AutodetectFailCustomFails1) {
   Rules rules;
   RuleBasedProxyResolver resolver(&rules, true /*expects_pac_bytes*/);
   RuleBasedProxyScriptFetcher fetcher(&rules);
 
   ProxyConfig config;
   config.set_auto_detect(true);
@@ skipping 43 matching lines @@
   Rules::Rule rule = rules.AddSuccessRule("http://custom/proxy.pac");
 
   TestCompletionCallback callback;
   InitProxyResolver init(&resolver, &fetcher);
   EXPECT_EQ(OK, init.Init(config, &callback, NULL));
   EXPECT_EQ(rule.url, resolver.pac_url());
 }
 
 }  // namespace
 }  // namespace net