Deciding best connection to schedule requests on based on cwnd and idle time

net/socket/tcp_client_socket_libevent.cc

 // Copyright (c) 2011 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.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <netdb.h>
 #include <sys/socket.h>
@@ skipping 124 matching lines @@
       current_ai_(NULL),
       read_watcher_(this),
       write_watcher_(this),
       read_callback_(NULL),
       write_callback_(NULL),
       next_connect_state_(CONNECT_STATE_NONE),
       connect_os_error_(0),
       net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_SOCKET)),
       previously_disconnected_(false),
       use_tcp_fastopen_(false),
-      tcp_fastopen_connected_(false) {
+      tcp_fastopen_connected_(false),
+      num_bytes_read_(0),
+      connect_time_micros_(-1) {
   scoped_refptr<NetLog::EventParameters> params;
   if (source.is_valid())
     params = new NetLogSourceParameter("source_dependency", source);
   net_log_.BeginEvent(NetLog::TYPE_SOCKET_ALIVE, params);
 
   if (is_tcp_fastopen_enabled())
     use_tcp_fastopen_ = true;
 }
 
 TCPClientSocketLibevent::~TCPClientSocketLibevent() {
@@ skipping 140 matching lines @@
       size_t addr_len = sizeof(addr_storage);
       if (!bind_address_->ToSockAddr(addr, &addr_len))
         return ERR_INVALID_ARGUMENT;
       if (HANDLE_EINTR(bind(socket_, addr, addr_len)))
         return MapSystemError(errno);
     }
   }
 
   // Connect the socket.
   if (!use_tcp_fastopen_) {
+    connect_start_time_ = base::Time::Now();
     if (!HANDLE_EINTR(connect(socket_, current_ai_->ai_addr,
                               static_cast<int>(current_ai_->ai_addrlen)))) {
       // Connected without waiting!
       return OK;
     }
   } else {
     // With TCP FastOpen, we pretend that the socket is connected.
     DCHECK(!tcp_fastopen_connected_);
     return OK;
   }
@@ skipping 21 matching lines @@
   int os_error = connect_os_error_;
   connect_os_error_ = 0;
   scoped_refptr<NetLog::EventParameters> params;
   if (result != OK)
     params = new NetLogIntegerParameter("os_error", os_error);
   net_log_.EndEvent(NetLog::TYPE_TCP_CONNECT_ATTEMPT, params);
 
   write_socket_watcher_.StopWatchingFileDescriptor();
 
   if (result == OK) {
+    connect_time_micros_ = (base::Time::Now() -
+                            connect_start_time_).InMicroseconds();
     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_ai_->ai_next) {
     next_connect_state_ = CONNECT_STATE_CONNECT;
@@ skipping 66 matching lines @@
                                   CompletionCallback* callback) {
   DCHECK(CalledOnValidThread());
   DCHECK_NE(kInvalidSocket, socket_);
   DCHECK(!waiting_connect());
   DCHECK(!read_callback_);
   // Synchronous operation not supported
   DCHECK(callback);
   DCHECK_GT(buf_len, 0);
 
   int nread = HANDLE_EINTR(read(socket_, buf->data(), buf_len));
+  LOG(ERROR) << "this = " << (int*) this << "\tnread = " << nread;

[willchan no longer on Chromium, 2011/06/13 15:06:07]

Ditch these LOGs please.

[Gagan, 2011/06/14 18:25:02]

Done.

   if (nread >= 0) {
     base::StatsCounter read_bytes("tcp.read_bytes");
     read_bytes.Add(nread);
+    num_bytes_read_ += static_cast<int64>(nread);
+    LOG(ERROR) << "this = " << (int*) this << "\tRead " << nread;
     if (nread > 0)
       use_history_.set_was_used_to_convey_data();
     net_log_.AddByteTransferEvent(NetLog::TYPE_SOCKET_BYTES_RECEIVED, nread,
                                   buf->data());
     return nread;
   }
   if (errno != EAGAIN && errno != EWOULDBLOCK) {
     DVLOG(1) << "read failed, errno " << errno;
     return MapSystemError(errno);
   }
 
   if (!MessageLoopForIO::current()->WatchFileDescriptor(
           socket_, true, MessageLoopForIO::WATCH_READ,
           &read_socket_watcher_, &read_watcher_)) {
     DVLOG(1) << "WatchFileDescriptor failed on read, errno " << errno;
     return MapSystemError(errno);
   }
 
+  LOG(ERROR) << "this = " << (int*) this << "\tread_buf_len_ = " << read_buf_len_;
   read_buf_ = buf;
   read_buf_len_ = buf_len;
   read_callback_ = callback;
   return ERR_IO_PENDING;
 }
 
 int TCPClientSocketLibevent::Write(IOBuffer* buf,
                                    int buf_len,
                                    CompletionCallback* callback) {
   DCHECK(CalledOnValidThread());
@@ skipping 156 matching lines @@
 void TCPClientSocketLibevent::DidCompleteRead() {
   int bytes_transferred;
   bytes_transferred = HANDLE_EINTR(read(socket_, read_buf_->data(),
                                         read_buf_len_));
 
   int result;
   if (bytes_transferred >= 0) {
     result = bytes_transferred;
     base::StatsCounter read_bytes("tcp.read_bytes");
     read_bytes.Add(bytes_transferred);
+    num_bytes_read_ += static_cast<int64>(bytes_transferred);
+    LOG(ERROR) << "this = " << (int*) this << "\tRead " << bytes_transferred;
     if (bytes_transferred > 0)
       use_history_.set_was_used_to_convey_data();
     net_log_.AddByteTransferEvent(NetLog::TYPE_SOCKET_BYTES_RECEIVED, result,
                                   read_buf_->data());
   } else {
     result = MapSystemError(errno);
   }
 
   if (result != ERR_IO_PENDING) {
     read_buf_ = NULL;
@@ skipping 70 matching lines @@
 
 bool TCPClientSocketLibevent::WasEverUsed() const {
   return use_history_.was_used_to_convey_data();
 }
 
 bool TCPClientSocketLibevent::UsingTCPFastOpen() const {
   return use_tcp_fastopen_;
 }
 
 }  // namespace net