net: rename BoundNetLog to NetLogWithSource

net/dns/host_resolver_impl.h

 // 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.
 
 #ifndef NET_DNS_HOST_RESOLVER_IMPL_H_
 #define NET_DNS_HOST_RESOLVER_IMPL_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <map>
 #include <memory>
 
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/strings/string_piece.h"
 #include "base/threading/non_thread_safe.h"
 #include "base/time/time.h"
 #include "base/timer/timer.h"
 #include "net/base/net_export.h"
 #include "net/base/network_change_notifier.h"
 #include "net/dns/host_cache.h"
 #include "net/dns/host_resolver.h"
 #include "net/dns/host_resolver_proc.h"
 
 namespace net {
 
 class AddressList;
-class BoundNetLog;
+class NetLogWithSource;
 class DnsClient;
 class IPAddress;
 class NetLog;
 
 // For each hostname that is requested, HostResolver creates a
 // HostResolverImpl::Job. When this job gets dispatched it creates a ProcTask
 // which runs the given HostResolverProc on a worker thread (a WorkerPool
 // thread, in production code.) If requests for that same host are made during
 // the job's lifetime, they are attached to the existing job rather than
 // creating a new one. This avoids doing parallel resolves for the same host.
@@ skipping 91 matching lines @@
   // not pre-configured with a valid DnsConfig, a new config is fetched from
   // NetworkChangeNotifier.
   void SetDnsClient(std::unique_ptr<DnsClient> dns_client);
 
   // HostResolver methods:
   int Resolve(const RequestInfo& info,
               RequestPriority priority,
               AddressList* addresses,
               const CompletionCallback& callback,
               std::unique_ptr<Request>* out_req,
-              const BoundNetLog& source_net_log) override;
+              const NetLogWithSource& source_net_log) override;
   int ResolveFromCache(const RequestInfo& info,
                        AddressList* addresses,
-                       const BoundNetLog& source_net_log) override;
+                       const NetLogWithSource& source_net_log) override;
   void SetDnsClientEnabled(bool enabled) override;
   HostCache* GetHostCache() override;
   std::unique_ptr<base::Value> GetDnsConfigAsValue() const override;
 
   // Like |ResolveFromCache()|, but can return a stale result if the
   // implementation supports it. Fills in |*stale_info| if a response is
   // returned to indicate how stale (or not) it is.
   int ResolveStaleFromCache(const RequestInfo& info,
                             AddressList* addresses,
                             HostCache::EntryStaleness* stale_info,
-                            const BoundNetLog& source_net_log);
+                            const NetLogWithSource& source_net_log);
 
   void InitializePersistence(
       const PersistCallback& persist_callback,
       std::unique_ptr<const base::Value> old_data) override;
 
   void set_proc_params_for_test(const ProcTaskParams& proc_params) {
     proc_params_ = proc_params;
   }
 
  protected:
@@ skipping 31 matching lines @@
   // entry's staleness (if an entry is returned).
   //
   // If |allow_stale| is false, then stale cache entries will not be returned,
   // and |stale_info| must be null.
   int ResolveHelper(const Key& key,
                     const RequestInfo& info,
                     const IPAddress* ip_address,
                     AddressList* addresses,
                     bool allow_stale,
                     HostCache::EntryStaleness* stale_info,
-                    const BoundNetLog& request_net_log);
+                    const NetLogWithSource& request_net_log);
 
   // Tries to resolve |key| as an IP, returns true and sets |net_error| if
   // succeeds, returns false otherwise.
   bool ResolveAsIP(const Key& key,
                    const RequestInfo& info,
                    const IPAddress* ip_address,
                    int* net_error,
                    AddressList* addresses);
 
   // If |key| is not found in cache returns false, otherwise returns
@@ skipping 23 matching lines @@
   // |addresses| with the loopback IP. Otherwise returns false.
   bool ServeLocalhost(const Key& key,
                       const RequestInfo& info,
                       AddressList* addresses);
 
   // Returns the (hostname, address_family) key to use for |info|, choosing an
   // "effective" address family by inheriting the resolver's default address
   // family when the request leaves it unspecified.
   Key GetEffectiveKeyForRequest(const RequestInfo& info,
                                 const IPAddress* ip_address,
-                                const BoundNetLog& net_log);
+                                const NetLogWithSource& net_log);
 
   // Probes IPv6 support and returns true if IPv6 support is enabled.
   // Results are cached, i.e. when called repeatedly this method returns result
   // from the first probe for some time before probing again.
-  virtual bool IsIPv6Reachable(const BoundNetLog& net_log);
+  virtual bool IsIPv6Reachable(const NetLogWithSource& net_log);
 
   // Asynchronously checks if only loopback IPs are available.
   virtual void RunLoopbackProbeJob();
 
   // Records the result in cache if cache is present.
   void CacheResult(const Key& key,
                    const HostCache::Entry& entry,
                    base::TimeDelta ttl);
 
   // Removes |job| from |jobs_|, only if it exists.
@@ skipping 123 matching lines @@
 // This function is only exposed so it can be unit-tested.
 // TODO(tfarina): It would be better to change the tests so this function
 // gets exercised indirectly through HostResolverImpl.
 NET_EXPORT_PRIVATE bool ResolveLocalHostname(base::StringPiece host,
                                              uint16_t port,
                                              AddressList* address_list);
 
 }  // namespace net
 
 #endif  // NET_DNS_HOST_RESOLVER_IMPL_H_