net: rename BoundNetLog to NetLogWithSource

components/cronet/stale_host_resolver.cc

 // Copyright 2016 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 "components/cronet/stale_host_resolver.h"
 
 #include "base/callback_helpers.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/stl_util.h"
@@ skipping 84 matching lines @@
   // asynchronously (unless destroyed first).
   //
   // |addresses| must remain valid until the Request completes (synchronously or
   // via |result_callback|) or is canceled by destroying the Request.
   int Start(net::HostResolverImpl* resolver,
             const RequestInfo& info,
             net::RequestPriority priority,
             net::AddressList* addresses,
             const net::CompletionCallback& result_callback,
             std::unique_ptr<net::HostResolver::Request>* out_req,
-            const net::BoundNetLog& net_log,
+            const net::NetLogWithSource& net_log,
             const StaleEntryUsableCallback& usable_callback,
             base::TimeDelta stale_delay);
 
   void ChangeRequestPriority(net::RequestPriority priority);
 
  private:
   class Handle : public net::HostResolver::Request {
    public:
     Handle(RequestImpl* request) : request_(request) {}
     ~Handle() override { request_->OnHandleDestroyed(); }
@@ skipping 72 matching lines @@
 
 StaleHostResolver::RequestImpl::~RequestImpl() {}
 
 int StaleHostResolver::RequestImpl::Start(
     net::HostResolverImpl* resolver,
     const RequestInfo& info,
     net::RequestPriority priority,
     net::AddressList* addresses,
     const net::CompletionCallback& result_callback,
     std::unique_ptr<net::HostResolver::Request>* out_req,
-    const net::BoundNetLog& net_log,
+    const net::NetLogWithSource& net_log,
     const StaleEntryUsableCallback& usable_callback,
     base::TimeDelta stale_delay) {
   DCHECK(resolver);
   DCHECK(addresses);
   DCHECK(!result_callback.is_null());
   DCHECK(out_req);
   DCHECK(!usable_callback.is_null());
 
   result_addresses_ = addresses;
 
@@ skipping 149 matching lines @@
   DCHECK_LE(0, stale_options.max_stale_uses);
 }
 
 StaleHostResolver::~StaleHostResolver() {}
 
 int StaleHostResolver::Resolve(const RequestInfo& info,
                                net::RequestPriority priority,
                                net::AddressList* addresses,
                                const net::CompletionCallback& callback,
                                std::unique_ptr<Request>* out_req,
-                               const net::BoundNetLog& net_log) {
+                               const net::NetLogWithSource& net_log) {
   StaleHostResolver::RequestImpl::StaleEntryUsableCallback usable_callback =
       base::Bind(&StaleEntryIsUsable, options_);
 
   RequestImpl* request = new RequestImpl();
   int rv =
       request->Start(inner_resolver_.get(), info, priority, addresses, callback,
                      out_req, net_log, usable_callback, options_.delay);
   if (rv != net::ERR_IO_PENDING)
     delete request;
 
   return rv;
 }
 
 int StaleHostResolver::ResolveFromCache(const RequestInfo& info,
                                         net::AddressList* addresses,
-                                        const net::BoundNetLog& net_log) {
+                                        const net::NetLogWithSource& net_log) {
   return inner_resolver_->ResolveFromCache(info, addresses, net_log);
 }
 
 void StaleHostResolver::SetDnsClientEnabled(bool enabled) {
   inner_resolver_->SetDnsClientEnabled(enabled);
 }
 
 net::HostCache* StaleHostResolver::GetHostCache() {
   return inner_resolver_->GetHostCache();
 }
 
 std::unique_ptr<base::Value> StaleHostResolver::GetDnsConfigAsValue() const {
   return inner_resolver_->GetDnsConfigAsValue();
 }
 
 }  // namespace net