net: rename BoundNetLog to NetLogWithSource

net/socket/transport_client_socket_pool_test_util.cc

 // Copyright 2014 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/socket/transport_client_socket_pool_test_util.h"
 
 #include <stdint.h>
 #include <string>
 #include <utility>
 
@@ skipping 23 matching lines @@
   CHECK(address.AssignFromIPLiteral(ip));
   return address;
 }
 
 // A StreamSocket which connects synchronously and successfully.
 class MockConnectClientSocket : public StreamSocket {
  public:
   MockConnectClientSocket(const AddressList& addrlist, net::NetLog* net_log)
       : connected_(false),
         addrlist_(addrlist),
-        net_log_(BoundNetLog::Make(net_log, NetLogSourceType::SOCKET)) {}
+        net_log_(NetLogWithSource::Make(net_log, NetLogSourceType::SOCKET)) {}
 
   // StreamSocket implementation.
   int Connect(const CompletionCallback& callback) override {
     connected_ = true;
     return OK;
   }
   void Disconnect() override { connected_ = false; }
   bool IsConnected() const override { return connected_; }
   bool IsConnectedAndIdle() const override { return connected_; }
 
   int GetPeerAddress(IPEndPoint* address) const override {
     *address = addrlist_.front();
     return OK;
   }
   int GetLocalAddress(IPEndPoint* address) const override {
     if (!connected_)
       return ERR_SOCKET_NOT_CONNECTED;
     if (addrlist_.front().GetFamily() == ADDRESS_FAMILY_IPV4)
       SetIPv4Address(address);
     else
       SetIPv6Address(address);
     return OK;
   }
-  const BoundNetLog& NetLog() const override { return net_log_; }
+  const NetLogWithSource& NetLog() const override { return net_log_; }
 
   void SetSubresourceSpeculation() override {}
   void SetOmniboxSpeculation() override {}
   bool WasEverUsed() const override { return false; }
   void EnableTCPFastOpenIfSupported() override {}
   bool WasNpnNegotiated() const override { return false; }
   NextProto GetNegotiatedProtocol() const override { return kProtoUnknown; }
   bool GetSSLInfo(SSLInfo* ssl_info) override { return false; }
   void GetConnectionAttempts(ConnectionAttempts* out) const override {
     out->clear();
@@ skipping 15 matching lines @@
             int buf_len,
             const CompletionCallback& callback) override {
     return ERR_FAILED;
   }
   int SetReceiveBufferSize(int32_t size) override { return OK; }
   int SetSendBufferSize(int32_t size) override { return OK; }
 
  private:
   bool connected_;
   const AddressList addrlist_;
-  BoundNetLog net_log_;
+  NetLogWithSource net_log_;
 
   DISALLOW_COPY_AND_ASSIGN(MockConnectClientSocket);
 };
 
 class MockFailingClientSocket : public StreamSocket {
  public:
   MockFailingClientSocket(const AddressList& addrlist, net::NetLog* net_log)
       : addrlist_(addrlist),
-        net_log_(BoundNetLog::Make(net_log, NetLogSourceType::SOCKET)) {}
+        net_log_(NetLogWithSource::Make(net_log, NetLogSourceType::SOCKET)) {}
 
   // StreamSocket implementation.
   int Connect(const CompletionCallback& callback) override {
     return ERR_CONNECTION_FAILED;
   }
 
   void Disconnect() override {}
 
   bool IsConnected() const override { return false; }
   bool IsConnectedAndIdle() const override { return false; }
   int GetPeerAddress(IPEndPoint* address) const override {
     return ERR_UNEXPECTED;
   }
   int GetLocalAddress(IPEndPoint* address) const override {
     return ERR_UNEXPECTED;
   }
-  const BoundNetLog& NetLog() const override { return net_log_; }
+  const NetLogWithSource& NetLog() const override { return net_log_; }
 
   void SetSubresourceSpeculation() override {}
   void SetOmniboxSpeculation() override {}
   bool WasEverUsed() const override { return false; }
   void EnableTCPFastOpenIfSupported() override {}
   bool WasNpnNegotiated() const override { return false; }
   NextProto GetNegotiatedProtocol() const override { return kProtoUnknown; }
   bool GetSSLInfo(SSLInfo* ssl_info) override { return false; }
   void GetConnectionAttempts(ConnectionAttempts* out) const override {
     out->clear();
@@ skipping 17 matching lines @@
   int Write(IOBuffer* buf,
             int buf_len,
             const CompletionCallback& callback) override {
     return ERR_FAILED;
   }
   int SetReceiveBufferSize(int32_t size) override { return OK; }
   int SetSendBufferSize(int32_t size) override { return OK; }
 
  private:
   const AddressList addrlist_;
-  BoundNetLog net_log_;
+  NetLogWithSource net_log_;
 
   DISALLOW_COPY_AND_ASSIGN(MockFailingClientSocket);
 };
 
 class MockTriggerableClientSocket : public StreamSocket {
  public:
   // |should_connect| indicates whether the socket should successfully complete
   // or fail.
   MockTriggerableClientSocket(const AddressList& addrlist,
                               bool should_connect,
                               net::NetLog* net_log)
       : should_connect_(should_connect),
         is_connected_(false),
         addrlist_(addrlist),
-        net_log_(BoundNetLog::Make(net_log, NetLogSourceType::SOCKET)),
+        net_log_(NetLogWithSource::Make(net_log, NetLogSourceType::SOCKET)),
         weak_factory_(this) {}
 
   // Call this method to get a closure which will trigger the connect callback
   // when called. The closure can be called even after the socket is deleted; it
   // will safely do nothing.
   base::Closure GetConnectCallback() {
     return base::Bind(&MockTriggerableClientSocket::DoCallback,
                       weak_factory_.GetWeakPtr());
   }
 
@@ skipping 52 matching lines @@
   }
   int GetLocalAddress(IPEndPoint* address) const override {
     if (!is_connected_)
       return ERR_SOCKET_NOT_CONNECTED;
     if (addrlist_.front().GetFamily() == ADDRESS_FAMILY_IPV4)
       SetIPv4Address(address);
     else
       SetIPv6Address(address);
     return OK;
   }
-  const BoundNetLog& NetLog() const override { return net_log_; }
+  const NetLogWithSource& NetLog() const override { return net_log_; }
 
   void SetSubresourceSpeculation() override {}
   void SetOmniboxSpeculation() override {}
   bool WasEverUsed() const override { return false; }
   void EnableTCPFastOpenIfSupported() override {}
   bool WasNpnNegotiated() const override { return false; }
   NextProto GetNegotiatedProtocol() const override { return kProtoUnknown; }
   bool GetSSLInfo(SSLInfo* ssl_info) override { return false; }
   void GetConnectionAttempts(ConnectionAttempts* out) const override {
     *out = connection_attempts_;
@@ skipping 25 matching lines @@
 
  private:
   void DoCallback() {
     is_connected_ = should_connect_;
     callback_.Run(is_connected_ ? OK : ERR_CONNECTION_FAILED);
   }
 
   bool should_connect_;
   bool is_connected_;
   const AddressList addrlist_;
-  BoundNetLog net_log_;
+  NetLogWithSource net_log_;
   CompletionCallback callback_;
   ConnectionAttempts connection_attempts_;
 
   base::WeakPtrFactory<MockTriggerableClientSocket> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(MockTriggerableClientSocket);
 };
 
 }  // namespace
 
@@ skipping 144 matching lines @@
     run_loop_quit_closure_ = run_loop.QuitClosure();
     run_loop.Run();
     run_loop_quit_closure_.Reset();
   }
   base::Closure trigger = triggerable_sockets_.front();
   triggerable_sockets_.pop();
   return trigger;
 }
 
 }  // namespace net