net: rename BoundNetLog to NetLogWithSource

net/proxy/proxy_resolver_v8_tracing_wrapper_unittest.cc

 // Copyright (c) 2013 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_resolver_v8_tracing_wrapper.h"
 
 #include <string>
 
 #include "base/files/file_util.h"
 #include "base/memory/ptr_util.h"
@@ skipping 670 matching lines @@
   std::unique_ptr<ProxyResolver> resolver = CreateResolver(
       nullptr, &host_resolver, base::WrapUnique(error_observer), "dns.js");
 
   const size_t kNumRequests = 5;
   ProxyInfo proxy_info[kNumRequests];
   ProxyResolver::RequestHandle request[kNumRequests];
 
   for (size_t i = 0; i < kNumRequests; ++i) {
     int rv = resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info[i],
                                       base::Bind(&CrashCallback), &request[i],
-                                      BoundNetLog());
+                                      NetLogWithSource());
     EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   }
 
   for (size_t i = 0; i < kNumRequests; ++i) {
     resolver->CancelRequest(request[i]);
   }
 }
 
 // Note the execution order for this test can vary. Since multiple
 // threads are involved, the cancellation may be received a different
 // times.
 TEST_F(ProxyResolverV8TracingWrapperTest, CancelSome) {
   MockCachingHostResolver host_resolver;
   MockErrorObserver* error_observer = new MockErrorObserver;
 
   host_resolver.rules()->AddSimulatedFailure("*");
 
   std::unique_ptr<ProxyResolver> resolver = CreateResolver(
       nullptr, &host_resolver, base::WrapUnique(error_observer), "dns.js");
 
   ProxyInfo proxy_info1;
   ProxyInfo proxy_info2;
   ProxyResolver::RequestHandle request1;
   ProxyResolver::RequestHandle request2;
   TestCompletionCallback callback;
 
   int rv = resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info1,
                                     base::Bind(&CrashCallback), &request1,
-                                    BoundNetLog());
+                                    NetLogWithSource());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   rv = resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info2,
-                                callback.callback(), &request2, BoundNetLog());
+                                callback.callback(), &request2,
+                                NetLogWithSource());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   resolver->CancelRequest(request1);
 
   EXPECT_THAT(callback.WaitForResult(), IsOk());
 }
 
 // Cancel a request after it has finished running on the worker thread, and has
 // posted a task the completion task back to origin thread.
 TEST_F(ProxyResolverV8TracingWrapperTest, CancelWhilePendingCompletionTask) {
   MockCachingHostResolver host_resolver;
   MockErrorObserver* error_observer = new MockErrorObserver;
 
   host_resolver.rules()->AddSimulatedFailure("*");
 
   std::unique_ptr<ProxyResolver> resolver = CreateResolver(
       nullptr, &host_resolver, base::WrapUnique(error_observer), "error.js");
 
   ProxyInfo proxy_info1;
   ProxyInfo proxy_info2;
   ProxyResolver::RequestHandle request1;
   ProxyResolver::RequestHandle request2;
   TestCompletionCallback callback;
 
   int rv = resolver->GetProxyForURL(GURL("http://throw-an-error/"),
                                     &proxy_info1, base::Bind(&CrashCallback),
-                                    &request1, BoundNetLog());
+                                    &request1, NetLogWithSource());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   // Wait until the first request has finished running on the worker thread.
   // Cancel the first request, while it has a pending completion task on
   // the origin thread.
   error_observer->RunOnError(base::Bind(&ProxyResolver::CancelRequest,
                                         base::Unretained(resolver.get()),
                                         request1));
 
   // Start another request, to make sure it is able to complete.
   rv = resolver->GetProxyForURL(GURL("http://i-have-no-idea-what-im-doing/"),
                                 &proxy_info2, callback.callback(), &request2,
-                                BoundNetLog());
+                                NetLogWithSource());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   EXPECT_THAT(callback.WaitForResult(), IsOk());
 
   EXPECT_EQ("i-approve-this-message:42", proxy_info2.proxy_server().ToURI());
 }
 
 // This implementation of HostResolver allows blocking until a resolve request
 // has been received. The resolve requests it receives will never be completed.
 class BlockableHostResolver : public HostResolver {
  public:
   BlockableHostResolver()
       : num_cancelled_requests_(0), waiting_for_resolve_(false) {}
 
   int Resolve(const RequestInfo& info,
               RequestPriority priority,
               AddressList* addresses,
               const CompletionCallback& callback,
               std::unique_ptr<Request>* out_req,
-              const BoundNetLog& net_log) override {
+              const NetLogWithSource& net_log) override {
     EXPECT_FALSE(callback.is_null());
     EXPECT_TRUE(out_req);
 
     if (!action_.is_null())
       action_.Run();
 
     // Indicate to the caller that a request was received.
     EXPECT_TRUE(waiting_for_resolve_);
     base::MessageLoop::current()->QuitWhenIdle();
 
     // This line is intentionally after action_.Run(), since one of the
     // tests does a cancellation inside of Resolve(), and it is more
     // interesting if *out_req hasn't been written yet at that point.
     out_req->reset(new RequestImpl(this));
 
     // Return ERR_IO_PENDING as this request will NEVER be completed.
     // Expectation is for the caller to later cancel the request.
     return ERR_IO_PENDING;
   }
 
   int ResolveFromCache(const RequestInfo& info,
                        AddressList* addresses,
-                       const BoundNetLog& net_log) override {
+                       const NetLogWithSource& net_log) override {
     NOTREACHED();
     return ERR_DNS_CACHE_MISS;
   }
 
   void IncreaseNumOfCancelledRequests() { num_cancelled_requests_++; }
 
   void SetAction(const base::Callback<void(void)>& action) { action_ = action; }
 
   // Waits until Resolve() has been called.
   void WaitUntilRequestIsReceived() {
@@ skipping 38 matching lines @@
   std::unique_ptr<ProxyResolver> resolver = CreateResolver(
       nullptr, &host_resolver, base::WrapUnique(error_observer), "dns.js");
 
   ProxyInfo proxy_info1;
   ProxyInfo proxy_info2;
   ProxyResolver::RequestHandle request1;
   ProxyResolver::RequestHandle request2;
 
   int rv = resolver->GetProxyForURL(GURL("http://foo/req1"), &proxy_info1,
                                     base::Bind(&CrashCallback), &request1,
-                                    BoundNetLog());
+                                    NetLogWithSource());
 
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   host_resolver.WaitUntilRequestIsReceived();
 
   rv = resolver->GetProxyForURL(GURL("http://foo/req2"), &proxy_info2,
                                 base::Bind(&CrashCallback), &request2,
-                                BoundNetLog());
+                                NetLogWithSource());
 
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   host_resolver.WaitUntilRequestIsReceived();
 
   resolver->CancelRequest(request1);
   resolver->CancelRequest(request2);
 
   EXPECT_EQ(2, host_resolver.num_cancelled_requests());
 
@@ skipping 20 matching lines @@
   MockErrorObserver* error_observer = new MockErrorObserver;
 
   std::unique_ptr<ProxyResolver> resolver = CreateResolver(
       nullptr, &host_resolver, base::WrapUnique(error_observer), "dns.js");
 
   ProxyInfo proxy_info;
   ProxyResolver::RequestHandle request;
 
   int rv = resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info,
                                     base::Bind(&CrashCallback), &request,
-                                    BoundNetLog());
+                                    NetLogWithSource());
 
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   host_resolver.SetAction(
       base::Bind(CancelRequestAndPause, resolver.get(), request));
 
   host_resolver.WaitUntilRequestIsReceived();
 }
 
 // Cancel the request while there is a pending DNS request, however before
 // the request is sent to the host resolver.
 TEST_F(ProxyResolverV8TracingWrapperTest, CancelWhileBlockedInNonBlockingDns2) {
   MockCachingHostResolver host_resolver;
   MockErrorObserver* error_observer = new MockErrorObserver;
 
   std::unique_ptr<ProxyResolver> resolver = CreateResolver(
       nullptr, &host_resolver, base::WrapUnique(error_observer), "dns.js");
 
   ProxyInfo proxy_info;
   ProxyResolver::RequestHandle request;
 
   int rv = resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info,
                                     base::Bind(&CrashCallback), &request,
-                                    BoundNetLog());
+                                    NetLogWithSource());
 
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   // Wait a bit, so the DNS task has hopefully been posted. The test will
   // work whatever the delay is here, but it is most useful if the delay
   // is large enough to allow a task to be posted back.
   base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(10));
   resolver->CancelRequest(request);
 
   EXPECT_EQ(0u, host_resolver.num_resolve());
@@ skipping 159 matching lines @@
   const size_t kNumResolvers = arraysize(resolver);
   const size_t kNumIterations = 20;
   const size_t kNumResults = kNumResolvers * kNumIterations;
   TestCompletionCallback callback[kNumResults];
   ProxyInfo proxy_info[kNumResults];
 
   for (size_t i = 0; i < kNumResults; ++i) {
     size_t resolver_i = i % kNumResolvers;
     int rv = resolver[resolver_i]->GetProxyForURL(
         GURL("http://foo/"), &proxy_info[i], callback[i].callback(), NULL,
-        BoundNetLog());
+        NetLogWithSource());
     EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   }
 
   // ------------------------
   // Verify all of the results.
   // ------------------------
 
   const char* kExpectedForDnsJs =
       "122.133.144.155-"  // myIpAddress()
       "null-"             // dnsResolve('')
@@ skipping 25 matching lines @@
                 proxy_uri.substr(0, proxy_uri.find(':') + 1));
     } else {
       NOTREACHED();
     }
   }
 }
 
 }  // namespace
 
 }  // namespace net