Use sockets with unread data if they've never been used before.

net/socket/socks_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 "net/socket/socks_client_socket.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"
+#include "base/callback_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/sys_byteorder.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_log.h"
 #include "net/base/net_util.h"
 #include "net/socket/client_socket_handle.h"
 
 namespace net {
 
 // Every SOCKS server requests a user-id from the client. It is optional
@@ skipping 39 matching lines @@
 SOCKSClientSocket::SOCKSClientSocket(
     scoped_ptr<ClientSocketHandle> transport_socket,
     const HostResolver::RequestInfo& req_info,
     RequestPriority priority,
     HostResolver* host_resolver)
     : transport_(transport_socket.Pass()),
       next_state_(STATE_NONE),
       completed_handshake_(false),
       bytes_sent_(0),
       bytes_received_(0),
+      was_used_to_convey_data_(false),
       host_resolver_(host_resolver),
       host_request_info_(req_info),
       priority_(priority),
       net_log_(transport_->socket()->NetLog()) {}
 
 SOCKSClientSocket::~SOCKSClientSocket() {
   Disconnect();
 }
 
 int SOCKSClientSocket::Connect(const CompletionCallback& callback) {
@@ skipping 52 matching lines @@
 
 void SOCKSClientSocket::SetOmniboxSpeculation() {
   if (transport_.get() && transport_->socket()) {
     transport_->socket()->SetOmniboxSpeculation();
   } else {
     NOTREACHED();
   }
 }
 
 bool SOCKSClientSocket::WasEverUsed() const {
-  if (transport_.get() && transport_->socket()) {
-    return transport_->socket()->WasEverUsed();
-  }
-  NOTREACHED();
-  return false;
+  return was_used_to_convey_data_;
 }
 
 bool SOCKSClientSocket::UsingTCPFastOpen() const {
   if (transport_.get() && transport_->socket()) {
     return transport_->socket()->UsingTCPFastOpen();
   }
   NOTREACHED();
   return false;
 }
 
@@ skipping 23 matching lines @@
 }
 
 // Read is called by the transport layer above to read. This can only be done
 // if the SOCKS handshake is complete.
 int SOCKSClientSocket::Read(IOBuffer* buf, int buf_len,
                             const CompletionCallback& callback) {
   DCHECK(completed_handshake_);
   DCHECK_EQ(STATE_NONE, next_state_);
   DCHECK(user_callback_.is_null());
 
-  return transport_->socket()->Read(buf, buf_len, callback);
+  int rv = transport_->socket()->Read(
+      buf, buf_len,
+      base::Bind(&SOCKSClientSocket::OnReadWriteComplete,
+                 base::Unretained(this), callback));
+  if (rv > 0)
+    was_used_to_convey_data_ = true;
+  return rv;
 }
 
 // Write is called by the transport layer. This can only be done if the
 // SOCKS handshake is complete.
 int SOCKSClientSocket::Write(IOBuffer* buf, int buf_len,
                              const CompletionCallback& callback) {
   DCHECK(completed_handshake_);
   DCHECK_EQ(STATE_NONE, next_state_);
   DCHECK(user_callback_.is_null());
 
-  return transport_->socket()->Write(buf, buf_len, callback);
+  int rv = transport_->socket()->Write(
+      buf, buf_len,
+      base::Bind(&SOCKSClientSocket::OnReadWriteComplete,
+                 base::Unretained(this), callback));
+  if (rv > 0)
+    was_used_to_convey_data_ = true;
+  return rv;
 }
 
 bool SOCKSClientSocket::SetReceiveBufferSize(int32 size) {
   return transport_->socket()->SetReceiveBufferSize(size);
 }
 
 bool SOCKSClientSocket::SetSendBufferSize(int32 size) {
   return transport_->socket()->SetSendBufferSize(size);
 }
 
 void SOCKSClientSocket::DoCallback(int result) {
   DCHECK_NE(ERR_IO_PENDING, result);
   DCHECK(!user_callback_.is_null());
 
   // Since Run() may result in Read being called,
   // clear user_callback_ up front.
-  CompletionCallback c = user_callback_;
-  user_callback_.Reset();
   DVLOG(1) << "Finished setting up SOCKS handshake";
-  c.Run(result);
+  base::ResetAndReturn(&user_callback_).Run(result);
 }
 
 void SOCKSClientSocket::OnIOComplete(int result) {
   DCHECK_NE(STATE_NONE, next_state_);
   int rv = DoLoop(result);
   if (rv != ERR_IO_PENDING) {
     net_log_.EndEventWithNetErrorCode(NetLog::TYPE_SOCKS_CONNECT, rv);
     DoCallback(rv);
   }
 }
 
+void SOCKSClientSocket::OnReadWriteComplete(const CompletionCallback& callback,
+                                            int result) {
+  DCHECK_NE(ERR_IO_PENDING, result);
+  DCHECK(!callback.is_null());
+
+  if (result > 0)
+    was_used_to_convey_data_ = true;
+  callback.Run(result);
+}
+
 int SOCKSClientSocket::DoLoop(int last_io_result) {
   DCHECK_NE(next_state_, STATE_NONE);
   int rv = last_io_result;
   do {
     State state = next_state_;
     next_state_ = STATE_NONE;
     switch (state) {
       case STATE_RESOLVE_HOST:
         DCHECK_EQ(OK, rv);
         rv = DoResolveHost();
@@ skipping 185 matching lines @@
 
 int SOCKSClientSocket::GetPeerAddress(IPEndPoint* address) const {
   return transport_->socket()->GetPeerAddress(address);
 }
 
 int SOCKSClientSocket::GetLocalAddress(IPEndPoint* address) const {
   return transport_->socket()->GetLocalAddress(address);
 }
 
 }  // namespace net