net: rename BoundNetLog to NetLogWithSource

net/proxy/proxy_resolver_perftest.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 <utility>
 
 #include "base/base_paths.h"
 #include "base/compiler_specific.h"
 #include "base/files/file_util.h"
 #include "base/macros.h"
@@ skipping 115 matching lines @@
     } else {
       resolver = LoadPacScriptAndCreateResolver(script_name);
     }
     ASSERT_TRUE(resolver);
 
     // Do a query to warm things up. In the case of internal-fetch proxy
     // resolvers, the first resolve will be slow since it has to download
     // the PAC script.
     {
       ProxyInfo proxy_info;
-      int result =
-          resolver->GetProxyForURL(GURL("http://www.warmup.com"), &proxy_info,
-                                   CompletionCallback(), NULL, BoundNetLog());
+      int result = resolver->GetProxyForURL(GURL("http://www.warmup.com"),
+                                            &proxy_info, CompletionCallback(),
+                                            NULL, NetLogWithSource());
       ASSERT_THAT(result, IsOk());
     }
 
     // Start the perf timer.
     std::string perf_test_name = resolver_name_ + "_" + script_name;
     base::PerfTimeLogger timer(perf_test_name.c_str());
 
     for (int i = 0; i < kNumIterations; ++i) {
       // Round-robin between URLs to resolve.
       const PacQuery& query = queries[i % queries_len];
 
       // Resolve.
       ProxyInfo proxy_info;
-      int result =
-          resolver->GetProxyForURL(GURL(query.query_url), &proxy_info,
-                                   CompletionCallback(), NULL, BoundNetLog());
+      int result = resolver->GetProxyForURL(GURL(query.query_url), &proxy_info,
+                                            CompletionCallback(), NULL,
+                                            NetLogWithSource());
 
       // Check that the result was correct. Note that ToPacString() and
       // ASSERT_EQ() are fast, so they won't skew the results.
       ASSERT_THAT(result, IsOk());
       ASSERT_EQ(query.expected_result, proxy_info.ToPacString());
     }
 
     // Print how long the test ran for.
     timer.Done();
   }
@@ skipping 67 matching lines @@
 class ProxyResolverV8Wrapper : public ProxyResolver {
  public:
   ProxyResolverV8Wrapper(std::unique_ptr<ProxyResolverV8> resolver,
                          std::unique_ptr<MockJSBindings> bindings)
       : resolver_(std::move(resolver)), bindings_(std::move(bindings)) {}
 
   int GetProxyForURL(const GURL& url,
                      ProxyInfo* results,
                      const CompletionCallback& /*callback*/,
                      RequestHandle* /*request*/,
-                     const BoundNetLog& net_log) override {
+                     const NetLogWithSource& net_log) override {
     return resolver_->GetProxyForURL(url, results, bindings_.get());
   }
 
   void CancelRequest(RequestHandle request) override { NOTREACHED(); }
 
   LoadState GetLoadState(RequestHandle request) const override {
     NOTREACHED();
     return LOAD_STATE_IDLE;
   }
 
@@ skipping 30 matching lines @@
 TEST(ProxyResolverPerfTest, ProxyResolverV8) {
   base::MessageLoop message_loop;
   ProxyResolverV8Factory factory;
   PacPerfSuiteRunner runner(&factory, "ProxyResolverV8");
   runner.RunAllTests();
 }
 
 }  // namespace
 
 }  // namespace net