Warmth of a connection (cwnd) is estimated by the amount of data written to the socket.

Choosing the warmest connection would mean faster resource load times. 

idle time is the time a socket has remained idle (no http requests being served on it). 
Probability of server resetting a connection increases with idle time duration. 

Using a cost function that takes into account bytes transferred and idle time to pick best connection to schedule http requests on.

CODEREVIEW done in http://codereview.chromium.org/6990036/

Contributed by gagansingh@google.com

Committed: http://src.chromium.org/viewvc/chrome?view=rev&revision=90373

Reverted: http://codereview.chromium.org/7255002 :(

Have fixed 2 things since:
1. Removed LOG(ERROR) from http_basic_stream.cc that was causing layout tests to fail.
2. Initialized class variables in http_basic_stream.cc that was causing uninitialized memory bugs in valgrind: http://code.google.com/p/chromium/issues/detail?id=87423

Review URL: http://codereview.chromium.org/7251004

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@90601 0039d316-1c4b-4281-b951-d872f2087c98

8 files changed, 109 insertions, 2 deletions

diff --git a/net/http/http_basic_stream.cc b/net/http/http_basic_stream.cc
index 6501a59..08785b8 100644
--- a/net/http/http_basic_stream.cc
+++ b/net/http/http_basic_stream.cc
@@ -4,6 +4,8 @@
 
 #include "net/http/http_basic_stream.h"
 
+#include "base/format_macros.h"
+#include "base/metrics/histogram.h"
 #include "base/stringprintf.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
@@ -12,6 +14,7 @@
 #include "net/http/http_stream_parser.h"
 #include "net/http/http_util.h"
 #include "net/socket/client_socket_handle.h"
+#include "net/socket/client_socket_pool_base.h"
 
 namespace net {
 
@@ -22,7 +25,9 @@ HttpBasicStream::HttpBasicStream(ClientSocketHandle* connection,
       parser_(parser),
       connection_(connection),
       using_proxy_(using_proxy),
-      request_info_(NULL) {
+      request_info_(NULL),
+      response_(NULL),
+      bytes_read_offset_(0) {
 }
 
 HttpBasicStream::~HttpBasicStream() {}
@@ -34,6 +39,7 @@ int HttpBasicStream::InitializeStream(const HttpRequestInfo* request_info,
   request_info_ = request_info;
   parser_.reset(new HttpStreamParser(connection_.get(), request_info,
                                      read_buf_, net_log));
+  bytes_read_offset_ = connection_->socket()->NumBytesRead();
   return OK;
 }
 
@@ -50,6 +56,7 @@ int HttpBasicStream::SendRequest(const HttpRequestHeaders& headers,
   request_line_ = base::StringPrintf("%s %s HTTP/1.1\r\n",
                                      request_info_->method.c_str(),
                                      path.c_str());
+  response_ = response;
   return parser_->SendRequest(request_line_, headers, request_body, response,
                               callback);
 }
@@ -119,4 +126,44 @@ bool HttpBasicStream::IsSpdyHttpStream() const {
   return false;
 }
 
+void HttpBasicStream::LogNumRttVsBytesMetrics() const {
+  int socket_reuse_policy = GetSocketReusePolicy();
+  if (socket_reuse_policy > 2 || socket_reuse_policy < 0) {
+    return;
+  }
+
+  int64 total_bytes_read = connection_->socket()->NumBytesRead();
+  int64 bytes_received = total_bytes_read - bytes_read_offset_;
+  int64 num_kb = bytes_received / 1024;
+  double rtt = connection_->socket()->GetConnectTimeMicros().ToInternalValue();
+  rtt /= 1000.0;
+
+  if (num_kb < 1024 && rtt > 0) {  // Ignore responses > 1MB
+    base::TimeDelta duration = base::Time::Now() -
+                               response_->request_time;
+    double num_rtt = static_cast<double>(duration.InMilliseconds()) / rtt;
+    int64 num_rtt_scaled = (4 * num_rtt);
+
+    static const char* const kGroups[] = {
+      "warmest_socket", "warm_socket", "last_accessed_socket"
+    };
+    int bucket = (num_kb / 5) * 5;
+    const std::string histogram(StringPrintf("Net.Num_RTT_vs_KB_%s_%dKB",
+                                             kGroups[socket_reuse_policy],
+                                             bucket));
+    base::Histogram* counter = base::Histogram::FactoryGet(
+        histogram, 0, 1000, 2, base::Histogram::kUmaTargetedHistogramFlag);
+    DCHECK_EQ(histogram, counter->histogram_name());
+    counter->Add(num_rtt_scaled);
+
+    VLOG(2) << StringPrintf("%s\nrtt = %f\tnum_rtt = %f\t"
+                            "num_kb = %" PRId64 "\t"
+                            "total bytes = %" PRId64 "\t"
+                            "histogram = %s",
+                            request_line_.data(),
+                            rtt, num_rtt, num_kb, total_bytes_read,
+                            histogram.data());
+  }
+}
+
 }  // namespace net
diff --git a/net/http/http_basic_stream.h b/net/http/http_basic_stream.h
index 267c7c1..303d68f 100644
--- a/net/http/http_basic_stream.h
+++ b/net/http/http_basic_stream.h
@@ -81,6 +81,8 @@ class HttpBasicStream : public HttpStream {
 
   virtual bool IsSpdyHttpStream() const OVERRIDE;
 
+  virtual void LogNumRttVsBytesMetrics() const OVERRIDE;
+
  private:
   scoped_refptr<GrowableIOBuffer> read_buf_;
 
@@ -94,6 +96,10 @@ class HttpBasicStream : public HttpStream {
 
   const HttpRequestInfo* request_info_;
 
+  const HttpResponseInfo* response_;
+
+  int64 bytes_read_offset_;
+
   DISALLOW_COPY_AND_ASSIGN(HttpBasicStream);
 };
 
diff --git a/net/http/http_network_transaction.cc b/net/http/http_network_transaction.cc
index d7a65e2..403f60f 100644
--- a/net/http/http_network_transaction.cc
+++ b/net/http/http_network_transaction.cc
@@ -920,6 +920,7 @@ int HttpNetworkTransaction::DoReadBodyComplete(int result) {
   // Clean up connection if we are done.
   if (done) {
     LogTransactionMetrics();
+    stream_->LogNumRttVsBytesMetrics();
     stream_->Close(!keep_alive);
     // Note: we don't reset the stream here.  We've closed it, but we still
     // need it around so that callers can call methods such as
diff --git a/net/http/http_network_transaction_unittest.cc b/net/http/http_network_transaction_unittest.cc
index 65d699e..a1de71f 100644
--- a/net/http/http_network_transaction_unittest.cc
+++ b/net/http/http_network_transaction_unittest.cc
@@ -12,6 +12,7 @@
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/metrics/histogram.h"
 #include "base/utf_string_conversions.h"
 #include "net/base/auth.h"
 #include "net/base/capturing_net_log.h"
@@ -333,6 +334,34 @@ static const char kExpectedNPNString[] = "\x08http/1.1\x06spdy/2";
 static const char kAlternateProtocolHttpHeader[] =
     "Alternate-Protocol: 443:npn-spdy/2\r\n\r\n";
 
+TEST_F(HttpNetworkTransactionTest, LogNumRttVsBytesMetrics_WarmestSocket) {
+  MockRead data_reads[1000];
+  data_reads[0] = MockRead("HTTP/1.0 200 OK\r\n\r\n");
+  for (int i = 1; i < 999; i++) {
+    data_reads[i] = MockRead("Gagan is a good boy!");
+  }
+  data_reads[999] = MockRead(false, OK);
+
+  net::SetSocketReusePolicy(0);
+  SimpleGetHelperResult out = SimpleGetHelper(data_reads,
+                                              arraysize(data_reads));
+
+  base::Histogram* histogram = NULL;
+  base::StatisticsRecorder::FindHistogram(
+      "Net.Num_RTT_vs_KB_warmest_socket_15KB", &histogram);
+  CHECK(histogram);
+
+  base::Histogram::SampleSet sample_set;
+  histogram->SnapshotSample(&sample_set);
+  EXPECT_EQ(1, sample_set.TotalCount());
+
+  EXPECT_EQ(OK, out.rv);
+  EXPECT_EQ("HTTP/1.0 200 OK", out.status_line);
+}
+
+// TODO(gagansingh): Add test for LogNumRttVsBytesMetrics_LastAccessSocket once
+// it is possible to clear histograms from previous tests.
+
 TEST_F(HttpNetworkTransactionTest, Basic) {
   SessionDependencies session_deps;
   scoped_ptr<HttpTransaction> trans(
diff --git a/net/http/http_proxy_client_socket.cc b/net/http/http_proxy_client_socket.cc
index 0a41c1f..584cecd 100644
--- a/net/http/http_proxy_client_socket.cc
+++ b/net/http/http_proxy_client_socket.cc
@@ -1,4 +1,4 @@
-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// 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.
 
@@ -165,6 +165,22 @@ bool HttpProxyClientSocket::UsingTCPFastOpen() const {
   return false;
 }
 
+int64 HttpProxyClientSocket::NumBytesRead() const {
+  if (transport_.get() && transport_->socket()) {
+    return transport_->socket()->NumBytesRead();
+  }
+  NOTREACHED();
+  return -1;
+}
+
+base::TimeDelta HttpProxyClientSocket::GetConnectTimeMicros() const {
+  if (transport_.get() && transport_->socket()) {
+    return transport_->socket()->GetConnectTimeMicros();
+  }
+  NOTREACHED();
+  return base::TimeDelta::FromMicroseconds(-1);
+}
+
 int HttpProxyClientSocket::Read(IOBuffer* buf, int buf_len,
                                 CompletionCallback* callback) {
   DCHECK(!user_callback_);
diff --git a/net/http/http_proxy_client_socket.h b/net/http/http_proxy_client_socket.h
index bd25bab..b1f32a6 100644
--- a/net/http/http_proxy_client_socket.h
+++ b/net/http/http_proxy_client_socket.h
@@ -78,6 +78,8 @@ class HttpProxyClientSocket : public ProxyClientSocket {
   virtual void SetOmniboxSpeculation();
   virtual bool WasEverUsed() const;
   virtual bool UsingTCPFastOpen() const;
+  virtual int64 NumBytesRead() const;
+  virtual base::TimeDelta GetConnectTimeMicros() const;
 
   // Socket methods:
   virtual int Read(IOBuffer* buf, int buf_len, CompletionCallback* callback);
diff --git a/net/http/http_response_body_drainer_unittest.cc b/net/http/http_response_body_drainer_unittest.cc
index 45c826e..47602e9 100644
--- a/net/http/http_response_body_drainer_unittest.cc
+++ b/net/http/http_response_body_drainer_unittest.cc
@@ -117,6 +117,8 @@ class MockHttpStream : public HttpStream {
 
   virtual bool IsSpdyHttpStream() const OVERRIDE { return false; }
 
+  virtual void LogNumRttVsBytesMetrics() const OVERRIDE {}
+
   // Methods to tweak/observer mock behavior:
   void StallReadsForever() { stall_reads_forever_ = true; }
 
diff --git a/net/http/http_stream.h b/net/http/http_stream.h
index 7ca2203..66fd97c 100644
--- a/net/http/http_stream.h
+++ b/net/http/http_stream.h
@@ -135,6 +135,10 @@ class NET_TEST HttpStream {
   // the HttpStream implementation. This is just a quick hack.
   virtual bool IsSpdyHttpStream() const = 0;
 
+  // Record histogram of number of round trips taken to download the full
+  // response body vs bytes transferred.
+  virtual void LogNumRttVsBytesMetrics() const = 0;
+
  private:
   DISALLOW_COPY_AND_ASSIGN(HttpStream);
 };