net: rename BoundNetLog to NetLogWithSource

net/proxy/proxy_resolver_v8_tracing_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.h"
 
 #include <string>
 #include <utility>
 
 #include "base/files/file_util.h"
@@ skipping 96 matching lines @@
     void Alert(const base::string16& message) override {
       DCHECK(thread_checker_.CalledOnValidThread());
       bindings_->Alert(message);
     }
 
     void OnError(int line_number, const base::string16& error) override {
       DCHECK(thread_checker_.CalledOnValidThread());
       bindings_->OnError(line_number, error);
     }
 
-    BoundNetLog GetBoundNetLog() override {
+    NetLogWithSource GetNetLogWithSource() override {
       DCHECK(thread_checker_.CalledOnValidThread());
-      return BoundNetLog();
+      return NetLogWithSource();
     }
 
     HostResolver* GetHostResolver() override {
       DCHECK(thread_checker_.CalledOnValidThread());
       return bindings_->host_resolver();
     }
 
    private:
     MockBindings* bindings_;
     base::ThreadChecker thread_checker_;
@@ skipping 549 matching lines @@
 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;
   }
 
@@ skipping 312 matching lines @@
                 proxy_uri.substr(0, proxy_uri.find(':') + 1));
     } else {
       NOTREACHED();
     }
   }
 }
 
 }  // namespace
 
 }  // namespace net