net: rename BoundNetLog to NetLogWithSource

net/socket/websocket_transport_client_socket_pool.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/websocket_transport_client_socket_pool.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/compiler_specific.h"
@@ skipping 22 matching lines @@
     RequestPriority priority,
     ClientSocketPool::RespectLimits respect_limits,
     const scoped_refptr<TransportSocketParams>& params,
     base::TimeDelta timeout_duration,
     const CompletionCallback& callback,
     ClientSocketFactory* client_socket_factory,
     HostResolver* host_resolver,
     ClientSocketHandle* handle,
     Delegate* delegate,
     NetLog* pool_net_log,
-    const BoundNetLog& request_net_log)
+    const NetLogWithSource& request_net_log)
     : ConnectJob(
           group_name,
           timeout_duration,
           priority,
           respect_limits,
           delegate,
-          BoundNetLog::Make(pool_net_log, NetLogSourceType::CONNECT_JOB)),
+          NetLogWithSource::Make(pool_net_log, NetLogSourceType::CONNECT_JOB)),
       params_(params),
       resolver_(host_resolver),
       client_socket_factory_(client_socket_factory),
       next_state_(STATE_NONE),
       race_result_(TransportConnectJob::RACE_UNKNOWN),
       handle_(handle),
       callback_(callback),
       request_net_log_(request_net_log),
       had_ipv4_(false),
       had_ipv6_(false) {}
@@ skipping 256 matching lines @@
     WebSocketEndpointLockManager::GetInstance()->UnlockEndpoint(address);
 }
 
 int WebSocketTransportClientSocketPool::RequestSocket(
     const std::string& group_name,
     const void* params,
     RequestPriority priority,
     RespectLimits respect_limits,
     ClientSocketHandle* handle,
     const CompletionCallback& callback,
-    const BoundNetLog& request_net_log) {
+    const NetLogWithSource& request_net_log) {
   DCHECK(params);
   const scoped_refptr<TransportSocketParams>& casted_params =
       *static_cast<const scoped_refptr<TransportSocketParams>*>(params);
 
   NetLogTcpClientSocketPoolRequestedSocket(request_net_log, &casted_params);
 
   CHECK(!callback.is_null());
   CHECK(handle);
 
   request_net_log.BeginEvent(NetLogEventType::SOCKET_POOL);
@@ skipping 40 matching lines @@
     TryHandOutSocket(result, connect_job.get());
   }
 
   return result;
 }
 
 void WebSocketTransportClientSocketPool::RequestSockets(
     const std::string& group_name,
     const void* params,
     int num_sockets,
-    const BoundNetLog& net_log) {
+    const NetLogWithSource& net_log) {
   NOTIMPLEMENTED();
 }
 
 void WebSocketTransportClientSocketPool::CancelRequest(
     const std::string& group_name,
     ClientSocketHandle* handle) {
   DCHECK(!handle->is_initialized());
   if (DeleteStalledRequest(handle))
     return;
   std::unique_ptr<StreamSocket> socket = handle->PassSocket();
@@ skipping 95 matching lines @@
   return !stalled_request_queue_.empty();
 }
 
 bool WebSocketTransportClientSocketPool::TryHandOutSocket(
     int result,
     WebSocketTransportConnectJob* job) {
   DCHECK_NE(result, ERR_IO_PENDING);
 
   std::unique_ptr<StreamSocket> socket = job->PassSocket();
   ClientSocketHandle* const handle = job->handle();
-  BoundNetLog request_net_log = job->request_net_log();
+  NetLogWithSource request_net_log = job->request_net_log();
   LoadTimingInfo::ConnectTiming connect_timing = job->connect_timing();
 
   if (result == OK) {
     DCHECK(socket);
 
     HandOutSocket(std::move(socket), connect_timing, handle, request_net_log);
 
     request_net_log.EndEvent(NetLogEventType::SOCKET_POOL);
 
     return true;
@@ skipping 67 matching lines @@
 bool WebSocketTransportClientSocketPool::ReachedMaxSocketsLimit() const {
   return handed_out_socket_count_ >= max_sockets_ ||
          base::checked_cast<int>(pending_connects_.size()) >=
              max_sockets_ - handed_out_socket_count_;
 }
 
 void WebSocketTransportClientSocketPool::HandOutSocket(
     std::unique_ptr<StreamSocket> socket,
     const LoadTimingInfo::ConnectTiming& connect_timing,
     ClientSocketHandle* handle,
-    const BoundNetLog& net_log) {
+    const NetLogWithSource& net_log) {
   DCHECK(socket);
   DCHECK_EQ(ClientSocketHandle::UNUSED, handle->reuse_type());
   DCHECK_EQ(0, handle->idle_time().InMicroseconds());
 
   handle->SetSocket(std::move(socket));
   handle->set_pool_id(0);
   handle->set_connect_timing(connect_timing);
 
   net_log.AddEvent(
       NetLogEventType::SOCKET_POOL_BOUND_TO_SOCKET,
@@ skipping 78 matching lines @@
     ConnectJob* job) {
   owner_->OnConnectJobComplete(result,
                                static_cast<WebSocketTransportConnectJob*>(job));
 }
 
 WebSocketTransportClientSocketPool::StalledRequest::StalledRequest(
     const scoped_refptr<TransportSocketParams>& params,
     RequestPriority priority,
     ClientSocketHandle* handle,
     const CompletionCallback& callback,
-    const BoundNetLog& net_log)
+    const NetLogWithSource& net_log)
     : params(params),
       priority(priority),
       handle(handle),
       callback(callback),
       net_log(net_log) {}
 
 WebSocketTransportClientSocketPool::StalledRequest::StalledRequest(
     const StalledRequest& other) = default;
 
 WebSocketTransportClientSocketPool::StalledRequest::~StalledRequest() {}
 
 }  // namespace net