net: rename BoundNetLog to NetLogWithSource

net/socket/socket_test_util.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/socket/socket_test_util.h"
 
 #include <algorithm>
 #include <utility>
 #include <vector>
 
@@ skipping 737 matching lines @@
                    next_ssl_data->next_protos_expected_in_ssl_config.end(),
                    ssl_config.alpn_protos.begin()));
   }
   return std::unique_ptr<SSLClientSocket>(new MockSSLClientSocket(
       std::move(transport_socket), host_and_port, ssl_config, next_ssl_data));
 }
 
 void MockClientSocketFactory::ClearSSLSessionCache() {
 }
 
-MockClientSocket::MockClientSocket(const BoundNetLog& net_log)
-    : connected_(false),
-      net_log_(net_log),
-      weak_factory_(this) {
+MockClientSocket::MockClientSocket(const NetLogWithSource& net_log)
+    : connected_(false), net_log_(net_log), weak_factory_(this) {
   peer_addr_ = IPEndPoint(IPAddress(192, 0, 2, 33), 0);
 }
 
 int MockClientSocket::SetReceiveBufferSize(int32_t size) {
   return OK;
 }
 
 int MockClientSocket::SetSendBufferSize(int32_t size) {
   return OK;
 }
@@ skipping 15 matching lines @@
     return ERR_SOCKET_NOT_CONNECTED;
   *address = peer_addr_;
   return OK;
 }
 
 int MockClientSocket::GetLocalAddress(IPEndPoint* address) const {
   *address = IPEndPoint(IPAddress(192, 0, 2, 33), 123);
   return OK;
 }
 
-const BoundNetLog& MockClientSocket::NetLog() const {
+const NetLogWithSource& MockClientSocket::NetLog() const {
   return net_log_;
 }
 
 bool MockClientSocket::WasNpnNegotiated() const {
   return false;
 }
 
 NextProto MockClientSocket::GetNegotiatedProtocol() const {
   return kProtoUnknown;
 }
@@ skipping 48 matching lines @@
 
 void MockClientSocket::RunCallback(const CompletionCallback& callback,
                                    int result) {
   if (!callback.is_null())
     callback.Run(result);
 }
 
 MockTCPClientSocket::MockTCPClientSocket(const AddressList& addresses,
                                          net::NetLog* net_log,
                                          SocketDataProvider* data)
-    : MockClientSocket(BoundNetLog::Make(net_log, NetLogSourceType::NONE)),
+    : MockClientSocket(NetLogWithSource::Make(net_log, NetLogSourceType::NONE)),
       addresses_(addresses),
       data_(data),
       read_offset_(0),
       read_data_(SYNCHRONOUS, ERR_UNEXPECTED),
       need_read_data_(true),
       peer_closed_connection_(false),
       pending_read_buf_(NULL),
       pending_read_buf_len_(0),
       was_used_to_convey_data_(false) {
   DCHECK(data_);
@@ skipping 251 matching lines @@
     ssl_client_socket->connected_ = true;
   callback.Run(rv);
 }
 
 MockSSLClientSocket::MockSSLClientSocket(
     std::unique_ptr<ClientSocketHandle> transport_socket,
     const HostPortPair& host_port_pair,
     const SSLConfig& ssl_config,
     SSLSocketDataProvider* data)
     : MockClientSocket(
-          // Have to use the right BoundNetLog for LoadTimingInfo regression
+          // Have to use the right NetLogWithSource for LoadTimingInfo
+          // regression
           // tests.
           transport_socket->socket()->NetLog()),
       transport_(std::move(transport_socket)),
       data_(data) {
   DCHECK(data_);
   peer_addr_ = data->connect.peer_addr;
 }
 
 MockSSLClientSocket::~MockSSLClientSocket() {
   Disconnect();
@@ skipping 104 matching lines @@
                                          net::NetLog* net_log)
     : connected_(false),
       data_(data),
       read_offset_(0),
       read_data_(SYNCHRONOUS, ERR_UNEXPECTED),
       need_read_data_(true),
       source_port_(123),
       network_(NetworkChangeNotifier::kInvalidNetworkHandle),
       pending_read_buf_(NULL),
       pending_read_buf_len_(0),
-      net_log_(BoundNetLog::Make(net_log, NetLogSourceType::NONE)),
+      net_log_(NetLogWithSource::Make(net_log, NetLogSourceType::NONE)),
       weak_factory_(this) {
   DCHECK(data_);
   data_->Initialize(this);
   peer_addr_ = data->connect_data().peer_addr;
 }
 
 MockUDPClientSocket::~MockUDPClientSocket() {
   if (data_)
     data_->DetachSocket();
 }
@@ skipping 72 matching lines @@
   return OK;
 }
 
 int MockUDPClientSocket::GetLocalAddress(IPEndPoint* address) const {
   *address = IPEndPoint(IPAddress(192, 0, 2, 33), source_port_);
   return OK;
 }
 
 void MockUDPClientSocket::UseNonBlockingIO() {}
 
-const BoundNetLog& MockUDPClientSocket::NetLog() const {
+const NetLogWithSource& MockUDPClientSocket::NetLog() const {
   return net_log_;
 }
 
 int MockUDPClientSocket::Connect(const IPEndPoint& address) {
   if (!data_)
     return ERR_UNEXPECTED;
   connected_ = true;
   peer_addr_ = address;
   return data_->connect_data().result;
 }
@@ skipping 254 matching lines @@
 
 MockTransportClientSocketPool::~MockTransportClientSocketPool() {}
 
 int MockTransportClientSocketPool::RequestSocket(
     const std::string& group_name,
     const void* socket_params,
     RequestPriority priority,
     RespectLimits respect_limits,
     ClientSocketHandle* handle,
     const CompletionCallback& callback,
-    const BoundNetLog& net_log) {
+    const NetLogWithSource& net_log) {
   last_request_priority_ = priority;
   std::unique_ptr<StreamSocket> socket =
       client_socket_factory_->CreateTransportClientSocket(
           AddressList(), NULL, net_log.net_log(), NetLog::Source());
   MockConnectJob* job = new MockConnectJob(std::move(socket), handle, callback);
   job_list_.push_back(base::WrapUnique(job));
   handle->set_pool_id(1);
   return job->Connect();
 }
 
@@ skipping 28 matching lines @@
       transport_pool_(transport_pool) {}
 
 MockSOCKSClientSocketPool::~MockSOCKSClientSocketPool() {}
 
 int MockSOCKSClientSocketPool::RequestSocket(const std::string& group_name,
                                              const void* socket_params,
                                              RequestPriority priority,
                                              RespectLimits respect_limits,
                                              ClientSocketHandle* handle,
                                              const CompletionCallback& callback,
-                                             const BoundNetLog& net_log) {
+                                             const NetLogWithSource& net_log) {
   return transport_pool_->RequestSocket(group_name, socket_params, priority,
                                         respect_limits, handle, callback,
                                         net_log);
 }
 
 void MockSOCKSClientSocketPool::CancelRequest(
     const std::string& group_name,
     ClientSocketHandle* handle) {
   return transport_pool_->CancelRequest(group_name, handle);
 }
@@ skipping 42 matching lines @@
 }
 
 int64_t CountWriteBytes(const MockWrite writes[], size_t writes_size) {
   int64_t total = 0;
   for (const MockWrite* write = writes; write != writes + writes_size; ++write)
     total += write->data_len;
   return total;
 }
 
 }  // namespace net