Remove experimental code to pick the "warmest" socket

net/socket/tcp_client_socket_win.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/tcp_client_socket_win.h"
 
 #include <mstcpip.h>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
@@ skipping 325 matching lines @@
                                        const net::NetLog::Source& source)
     : socket_(INVALID_SOCKET),
       bound_socket_(INVALID_SOCKET),
       addresses_(addresses),
       current_address_index_(-1),
       waiting_read_(false),
       waiting_write_(false),
       next_connect_state_(CONNECT_STATE_NONE),
       connect_os_error_(0),
       net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_SOCKET)),
-      previously_disconnected_(false),
-      num_bytes_read_(0) {
+      previously_disconnected_(false) {
   net_log_.BeginEvent(NetLog::TYPE_SOCKET_ALIVE,
                       source.ToEventParametersCallback());
   EnsureWinsockInit();
 }
 
 TCPClientSocketWin::~TCPClientSocketWin() {
   Disconnect();
   net_log_.EndEvent(NetLog::TYPE_SOCKET_ALIVE);
 }
 
@@ skipping 136 matching lines @@
 
   DCHECK(!core_);
   core_ = new Core(this);
   // WSAEventSelect sets the socket to non-blocking mode as a side effect.
   // Our connect() and recv() calls require that the socket be non-blocking.
   WSAEventSelect(socket_, core_->read_overlapped_.hEvent, FD_CONNECT);
 
   SockaddrStorage storage;
   if (!endpoint.ToSockAddr(storage.addr, &storage.addr_len))
     return ERR_INVALID_ARGUMENT;
-  connect_start_time_ = base::TimeTicks::Now();
   if (!connect(socket_, storage.addr, storage.addr_len)) {
     // Connected without waiting!
     //
     // The MSDN page for connect says:
     //   With a nonblocking socket, the connection attempt cannot be completed
     //   immediately. In this case, connect will return SOCKET_ERROR, and
     //   WSAGetLastError will return WSAEWOULDBLOCK.
     // which implies that for a nonblocking socket, connect never returns 0.
     // It's not documented whether the event object will be signaled or not
     // if connect does return 0.  So the code below is essentially dead code
@@ skipping 20 matching lines @@
   int os_error = connect_os_error_;
   connect_os_error_ = 0;
   if (result != OK) {
     net_log_.EndEvent(NetLog::TYPE_TCP_CONNECT_ATTEMPT,
                       NetLog::IntegerCallback("os_error", os_error));
   } else {
     net_log_.EndEvent(NetLog::TYPE_TCP_CONNECT_ATTEMPT);
   }
 
   if (result == OK) {
-    connect_time_micros_ = base::TimeTicks::Now() - connect_start_time_;
     use_history_.set_was_ever_connected();
     return OK;  // Done!
   }
 
   // Close whatever partially connected socket we currently have.
   DoDisconnect();
 
   // Try to fall back to the next address in the list.
   if (current_address_index_ + 1 < static_cast<int>(addresses_.size())) {
     next_connect_state_ = CONNECT_STATE_CONNECT;
@@ skipping 130 matching lines @@
 
 bool TCPClientSocketWin::WasEverUsed() const {
   return use_history_.was_used_to_convey_data();
 }
 
 bool TCPClientSocketWin::UsingTCPFastOpen() const {
   // Not supported on windows.
   return false;
 }
 
-int64 TCPClientSocketWin::NumBytesRead() const {
-  return num_bytes_read_;
-}
-
-base::TimeDelta TCPClientSocketWin::GetConnectTimeMicros() const {
-  return connect_time_micros_;
-}
-
 bool TCPClientSocketWin::WasNpnNegotiated() const {
   return false;
 }
 
 NextProto TCPClientSocketWin::GetNegotiatedProtocol() const {
   return kProtoUnknown;
 }
 
 bool TCPClientSocketWin::GetSSLInfo(SSLInfo* ssl_info) {
   return false;
@@ skipping 133 matching lines @@
         int net_error = MapSystemError(os_error);
         net_log_.AddEvent(NetLog::TYPE_SOCKET_READ_ERROR,
             CreateNetLogSocketErrorCallback(net_error, os_error));
         return net_error;
       }
     } else {
       base::StatsCounter read_bytes("tcp.read_bytes");
       if (rv > 0) {
         use_history_.set_was_used_to_convey_data();
         read_bytes.Add(rv);
-        num_bytes_read_ += rv;
       }
       net_log_.AddByteTransferEvent(NetLog::TYPE_SOCKET_BYTES_RECEIVED, rv,
                                     buf->data());
       return rv;
     }
   } else {
     buf_len = core_->ThrottleReadSize(buf_len);
 
     WSABUF read_buffer;
     read_buffer.len = buf_len;
     read_buffer.buf = buf->data();
 
     // TODO(wtc): Remove the assertion after enough testing.
     AssertEventNotSignaled(core_->read_overlapped_.hEvent);
     DWORD num;
     DWORD flags = 0;
     int rv = WSARecv(socket_, &read_buffer, 1, &num, &flags,
                      &core_->read_overlapped_, NULL);
     if (rv == 0) {
       if (ResetEventIfSignaled(core_->read_overlapped_.hEvent)) {
         base::StatsCounter read_bytes("tcp.read_bytes");
         if (num > 0) {
           use_history_.set_was_used_to_convey_data();
           read_bytes.Add(num);
-          num_bytes_read_ += num;
         }
         net_log_.AddByteTransferEvent(NetLog::TYPE_SOCKET_BYTES_RECEIVED, num,
                                       buf->data());
         return static_cast<int>(num);
       }
     } else {
       int os_error = WSAGetLastError();
       if (os_error != WSA_IO_PENDING) {
         int net_error = MapSystemError(os_error);
         net_log_.AddEvent(NetLog::TYPE_SOCKET_READ_ERROR,
@@ skipping 62 matching lines @@
 void TCPClientSocketWin::DidCompleteRead() {
   DCHECK(waiting_read_);
   DWORD num_bytes, flags;
   BOOL ok = WSAGetOverlappedResult(socket_, &core_->read_overlapped_,
                                    &num_bytes, FALSE, &flags);
   waiting_read_ = false;
   int rv;
   if (ok) {
     base::StatsCounter read_bytes("tcp.read_bytes");
     read_bytes.Add(num_bytes);
-    num_bytes_read_ += num_bytes;
     if (num_bytes > 0)
       use_history_.set_was_used_to_convey_data();
     net_log_.AddByteTransferEvent(NetLog::TYPE_SOCKET_BYTES_RECEIVED,
                                   num_bytes, core_->read_iobuffer_->data());
     rv = static_cast<int>(num_bytes);
   } else {
     int os_error = WSAGetLastError();
     rv = MapSystemError(os_error);
     net_log_.AddEvent(NetLog::TYPE_SOCKET_READ_ERROR,
                       CreateNetLogSocketErrorCallback(rv, os_error));
@@ skipping 75 matching lines @@
     core_->WatchForRead();
     return;
   }
   waiting_read_ = false;
   core_->read_iobuffer_ = NULL;
   core_->read_buffer_length_ = 0;
   DoReadCallback(rv);
 }
 
 }  // namespace net