net: rename BoundNetLog to NetLogWithSource

jingle/glue/proxy_resolving_client_socket.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 "jingle/glue/proxy_resolving_client_socket.h"
 
 #include <stdint.h>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 26 matching lines @@
       connect_callback_(
           base::Bind(&ProxyResolvingClientSocket::ProcessConnectDone,
                      base::Unretained(this))),
       ssl_config_(ssl_config),
       pac_request_(NULL),
       dest_host_port_pair_(dest_host_port_pair),
       // Assume that we intend to do TLS on this socket; all
       // current use cases do.
       proxy_url_("https://" + dest_host_port_pair_.ToString()),
       tried_direct_connect_fallback_(false),
-      bound_net_log_(net::BoundNetLog::Make(
+      net_log_(net::NetLogWithSource::Make(
           request_context_getter->GetURLRequestContext()->net_log(),
           net::NetLogSourceType::SOCKET)),
       weak_factory_(this) {
   DCHECK(request_context_getter.get());
   net::URLRequestContext* request_context =
       request_context_getter->GetURLRequestContext();
   DCHECK(request_context);
   DCHECK(!dest_host_port_pair_.host().empty());
   DCHECK_GT(dest_host_port_pair_.port(), 0);
   DCHECK(proxy_url_.is_valid());
@@ skipping 82 matching lines @@
   tried_direct_connect_fallback_ = false;
 
   // First we try and resolve the proxy.
   int status = network_session_->proxy_service()->ResolveProxy(
       proxy_url_,
       std::string(),
       &proxy_info_,
       proxy_resolve_callback_,
       &pac_request_,
       NULL,
-      bound_net_log_);
+      net_log_);
   if (status != net::ERR_IO_PENDING) {
     // We defer execution of ProcessProxyResolveDone instead of calling it
     // directly here for simplicity. From the caller's point of view,
     // the connect always happens asynchronously.
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(&ProxyResolvingClientSocket::ProcessProxyResolveDone,
                    weak_factory_.GetWeakPtr(), status));
   }
   user_connect_callback_ = callback;
@@ skipping 36 matching lines @@
       CloseTransportSocket();
       RunUserConnectCallback(status);
       return;
     }
   }
 
   transport_.reset(new net::ClientSocketHandle);
   // Now that we have resolved the proxy, we need to connect.
   status = net::InitSocketHandleForRawConnect(
       dest_host_port_pair_, network_session_.get(), proxy_info_, ssl_config_,
-      ssl_config_, net::PRIVACY_MODE_DISABLED, bound_net_log_, transport_.get(),
+      ssl_config_, net::PRIVACY_MODE_DISABLED, net_log_, transport_.get(),
       connect_callback_);
   if (status != net::ERR_IO_PENDING) {
     // Since this method is always called asynchronously. it is OK to call
     // ProcessConnectDone synchronously.
     ProcessConnectDone(status);
   }
 }
 
 void ProxyResolvingClientSocket::ProcessConnectDone(int status) {
   if (status != net::OK) {
@@ skipping 67 matching lines @@
       return error;
   }
 
   if (proxy_info_.is_https() && ssl_config_.send_client_cert) {
     network_session_->ssl_client_auth_cache()->Remove(
         proxy_info_.proxy_server().host_port_pair());
   }
 
   int rv = network_session_->proxy_service()->ReconsiderProxyAfterError(
       proxy_url_, std::string(), error, &proxy_info_, proxy_resolve_callback_,
-      &pac_request_, NULL, bound_net_log_);
+      &pac_request_, NULL, net_log_);
   if (rv == net::OK || rv == net::ERR_IO_PENDING) {
     CloseTransportSocket();
   } else {
     // If ReconsiderProxyAfterError() failed synchronously, it means
     // there was nothing left to fall-back to, so fail the transaction
     // with the last connection error we got.
     rv = error;
   }
 
   // We either have new proxy info or there was an error in falling back.
@@ skipping 57 matching lines @@
 }
 
 int ProxyResolvingClientSocket::GetLocalAddress(
     net::IPEndPoint* address) const {
   if (transport_.get() && transport_->socket())
     return transport_->socket()->GetLocalAddress(address);
   NOTREACHED();
   return net::ERR_SOCKET_NOT_CONNECTED;
 }
 
-const net::BoundNetLog& ProxyResolvingClientSocket::NetLog() const {
+const net::NetLogWithSource& ProxyResolvingClientSocket::NetLog() const {
   if (transport_.get() && transport_->socket())
     return transport_->socket()->NetLog();
   NOTREACHED();
-  return bound_net_log_;
+  return net_log_;
 }
 
 void ProxyResolvingClientSocket::SetSubresourceSpeculation() {
   if (transport_.get() && transport_->socket())
     transport_->socket()->SetSubresourceSpeculation();
   else
     NOTREACHED();
 }
 
 void ProxyResolvingClientSocket::SetOmniboxSpeculation() {
@@ skipping 35 matching lines @@
   return 0;
 }
 
 void ProxyResolvingClientSocket::CloseTransportSocket() {
   if (transport_.get() && transport_->socket())
     transport_->socket()->Disconnect();
   transport_.reset();
 }
 
 }  // namespace jingle_glue