net: rename BoundNetLog to NetLogWithSource

net/dns/dns_transaction.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 "net/dns/dns_transaction.h"
 
 #include <deque>
 #include <memory>
 #include <string>
 #include <utility>
@@ skipping 79 matching lines @@
   virtual int Start(const CompletionCallback& callback) = 0;
 
   // Returns the query of this attempt.
   virtual const DnsQuery* GetQuery() const = 0;
 
   // Returns the response or NULL if has not received a matching response from
   // the server.
   virtual const DnsResponse* GetResponse() const = 0;
 
   // Returns the net log bound to the source of the socket.
-  virtual const BoundNetLog& GetSocketNetLog() const = 0;
+  virtual const NetLogWithSource& GetSocketNetLog() const = 0;
 
   // Returns the index of the destination server within DnsConfig::nameservers.
   unsigned server_index() const { return server_index_; }
 
   // Returns a Value representing the received response, along with a reference
   // to the NetLog source source of the UDP socket used.  The request must have
   // completed before this is called.
   std::unique_ptr<base::Value> NetLogResponseCallback(
       NetLogCaptureMode capture_mode) const {
     DCHECK(GetResponse()->IsValid());
@@ skipping 47 matching lines @@
     return DoLoop(OK);
   }
 
   const DnsQuery* GetQuery() const override { return query_.get(); }
 
   const DnsResponse* GetResponse() const override {
     const DnsResponse* resp = response_.get();
     return (resp != NULL && resp->IsValid()) ? resp : NULL;
   }
 
-  const BoundNetLog& GetSocketNetLog() const override {
+  const NetLogWithSource& GetSocketNetLog() const override {
     return socket_lease_->socket()->NetLog();
   }
 
  private:
   enum State {
     STATE_SEND_QUERY,
     STATE_SEND_QUERY_COMPLETE,
     STATE_READ_RESPONSE,
     STATE_READ_RESPONSE_COMPLETE,
     STATE_NONE,
@@ skipping 148 matching lines @@
     return DoLoop(rv);
   }
 
   const DnsQuery* GetQuery() const override { return query_.get(); }
 
   const DnsResponse* GetResponse() const override {
     const DnsResponse* resp = response_.get();
     return (resp != NULL && resp->IsValid()) ? resp : NULL;
   }
 
-  const BoundNetLog& GetSocketNetLog() const override {
+  const NetLogWithSource& GetSocketNetLog() const override {
     return socket_->NetLog();
   }
 
  private:
   enum State {
     STATE_CONNECT_COMPLETE,
     STATE_SEND_LENGTH,
     STATE_SEND_QUERY,
     STATE_READ_LENGTH,
     STATE_READ_LENGTH_COMPLETE,
@@ skipping 208 matching lines @@
 // DnsSession::NextFirstServerIndex, and the order is round-robin afterwards.
 // Each server is attempted DnsConfig::attempts times.
 class DnsTransactionImpl : public DnsTransaction,
                            public base::NonThreadSafe,
                            public base::SupportsWeakPtr<DnsTransactionImpl> {
  public:
   DnsTransactionImpl(DnsSession* session,
                      const std::string& hostname,
                      uint16_t qtype,
                      const DnsTransactionFactory::CallbackType& callback,
-                     const BoundNetLog& net_log)
+                     const NetLogWithSource& net_log)
       : session_(session),
         hostname_(hostname),
         qtype_(qtype),
         callback_(callback),
         net_log_(net_log),
         qnames_initial_size_(0),
         attempts_count_(0),
         had_tcp_attempt_(false),
         first_server_index_(0) {
     DCHECK(session_.get());
@@ skipping 366 matching lines @@
     if (result.rv != ERR_IO_PENDING)
       DoCallback(result);
   }
 
   scoped_refptr<DnsSession> session_;
   std::string hostname_;
   uint16_t qtype_;
   // Cleared in DoCallback.
   DnsTransactionFactory::CallbackType callback_;
 
-  BoundNetLog net_log_;
+  NetLogWithSource net_log_;
 
   // Search list of fully-qualified DNS names to query next (in DNS format).
   std::deque<std::string> qnames_;
   size_t qnames_initial_size_;
 
   // List of attempts for the current name.
   std::vector<std::unique_ptr<DnsAttempt>> attempts_;
   // Count of attempts, not reset when |attempts_| vector is cleared.
   int  attempts_count_;
   bool had_tcp_attempt_;
@@ skipping 13 matching lines @@
 class DnsTransactionFactoryImpl : public DnsTransactionFactory {
  public:
   explicit DnsTransactionFactoryImpl(DnsSession* session) {
     session_ = session;
   }
 
   std::unique_ptr<DnsTransaction> CreateTransaction(
       const std::string& hostname,
       uint16_t qtype,
       const CallbackType& callback,
-      const BoundNetLog& net_log) override {
+      const NetLogWithSource& net_log) override {
     return std::unique_ptr<DnsTransaction>(new DnsTransactionImpl(
         session_.get(), hostname, qtype, callback, net_log));
   }
 
  private:
   scoped_refptr<DnsSession> session_;
 };
 
 }  // namespace
 
 // static
 std::unique_ptr<DnsTransactionFactory> DnsTransactionFactory::CreateFactory(
     DnsSession* session) {
   return std::unique_ptr<DnsTransactionFactory>(
       new DnsTransactionFactoryImpl(session));
 }
 
 }  // namespace net