Add histograms for tracking the unused/unused_idle/reused socket states from TCPClientSocketPool.

Tracks the number of each socket type returned by the TCPClientSocketPool.
Also tracks the number of recoverable IO errors (resets, aborts, closes) per socket type.
Also tracks the idle time of a socket before a recoverable IO happens.

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

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

4 files changed, 38 insertions, 4 deletions

diff --git a/net/socket/client_socket_handle.cc b/net/socket/client_socket_handle.cc
index 66ca4ab..6e6310d 100644
--- a/net/socket/client_socket_handle.cc
+++ b/net/socket/client_socket_handle.cc
@@ -41,6 +41,8 @@ void ClientSocketHandle::ResetInternal(bool cancel) {
   group_name_.clear();
   is_reused_ = false;
   user_callback_ = NULL;
+  idle_time_ = base::TimeDelta();
+  init_time_ = base::TimeTicks();
 }
 
 LoadState ClientSocketHandle::GetLoadState() const {
diff --git a/net/socket/client_socket_handle.h b/net/socket/client_socket_handle.h
index 67c6cb8..9d63a41 100644
--- a/net/socket/client_socket_handle.h
+++ b/net/socket/client_socket_handle.h
@@ -10,6 +10,7 @@
 #include "base/logging.h"
 #include "base/ref_counted.h"
 #include "base/scoped_ptr.h"
+#include "base/time.h"
 #include "net/base/completion_callback.h"
 #include "net/base/load_states.h"
 #include "net/base/net_errors.h"
@@ -26,6 +27,13 @@ namespace net {
 //
 class ClientSocketHandle {
  public:
+  typedef enum {
+    UNUSED = 0,
+    UNUSED_IDLE,
+    REUSED_IDLE,
+    NUM_TYPES,
+  } SocketReuseType;
+
   explicit ClientSocketHandle(ClientSocketPool* pool);
   ~ClientSocketHandle();
 
@@ -72,15 +80,29 @@ class ClientSocketHandle {
   // Returns true when Init() has completed successfully.
   bool is_initialized() const { return socket_ != NULL; }
 
+  // Returns the time tick when Init() was called.
+  base::TimeTicks init_time() const { return init_time_; }
+
   // Used by ClientSocketPool to initialize the ClientSocketHandle.
   void set_is_reused(bool is_reused) { is_reused_ = is_reused; }
   void set_socket(ClientSocket* s) { socket_.reset(s); }
+  void set_idle_time(base::TimeDelta idle_time) { idle_time_ = idle_time; }
 
   // These may only be used if is_initialized() is true.
   const std::string& group_name() const { return group_name_; }
   ClientSocket* socket() { return socket_.get(); }
   ClientSocket* release_socket() { return socket_.release(); }
   bool is_reused() const { return is_reused_; }
+  base::TimeDelta idle_time() const { return idle_time_; }
+  SocketReuseType reuse_type() const {
+    if (is_reused()) {
+      return REUSED_IDLE;
+    } else if (idle_time() == base::TimeDelta()) {
+      return UNUSED;
+    } else {
+      return UNUSED_IDLE;
+    }
+  }
 
  private:
   // Called on asynchronous completion of an Init() request.
@@ -100,6 +122,8 @@ class ClientSocketHandle {
   bool is_reused_;
   CompletionCallbackImpl<ClientSocketHandle> callback_;
   CompletionCallback* user_callback_;
+  base::TimeDelta idle_time_;
+  base::TimeTicks init_time_;
 
   DISALLOW_COPY_AND_ASSIGN(ClientSocketHandle);
 };
@@ -114,6 +138,7 @@ int ClientSocketHandle::Init(const std::string& group_name,
   CHECK(!group_name.empty());
   ResetInternal(true);
   group_name_ = group_name;
+  init_time_ = base::TimeTicks::Now();
   int rv = pool_->RequestSocket(
       group_name, &socket_params, priority, this, &callback_, load_log);
   if (rv == ERR_IO_PENDING) {
diff --git a/net/socket/client_socket_pool_base.cc b/net/socket/client_socket_pool_base.cc
index bfe8405..d966555 100644
--- a/net/socket/client_socket_pool_base.cc
+++ b/net/socket/client_socket_pool_base.cc
@@ -132,8 +132,10 @@ int ClientSocketPoolBaseHelper::RequestSocket(
     DecrementIdleCount();
     if (idle_socket.socket->IsConnectedAndIdle()) {
       // We found one we can reuse!
+      base::TimeDelta idle_time =
+          base::TimeTicks::Now() - idle_socket.start_time;
       HandOutSocket(
-          idle_socket.socket, idle_socket.used, handle, &group);
+          idle_socket.socket, idle_socket.used, handle, idle_time, &group);
       return OK;
     }
     delete idle_socket.socket;
@@ -147,7 +149,7 @@ int ClientSocketPoolBaseHelper::RequestSocket(
   int rv = connect_job->Connect();
   if (rv == OK) {
     HandOutSocket(connect_job->ReleaseSocket(), false /* not reused */,
-                  handle, &group);
+                  handle, base::TimeDelta(), &group);
   } else if (rv == ERR_IO_PENDING) {
     connecting_socket_count_++;
 
@@ -395,7 +397,8 @@ void ClientSocketPoolBaseHelper::OnConnectJobComplete(
         scoped_ptr<const Request> r(group.pending_requests.front());
         group.pending_requests.pop_front();
         HandOutSocket(
-            socket.release(), false /* unused socket */, r->handle(), &group);
+            socket.release(), false /* unused socket */, r->handle(),
+            base::TimeDelta(), &group);
         r->callback()->Run(result);
       } else {
         AddIdleSocket(socket.release(), false /* unused socket */, &group);
@@ -431,7 +434,8 @@ void ClientSocketPoolBaseHelper::OnConnectJobComplete(
     MaybeOnAvailableSocketSlot(group_name);
   } else {
     DCHECK(socket.get());
-    HandOutSocket(socket.release(), false /* not reused */, handle, &group);
+    HandOutSocket(socket.release(), false /* not reused */, handle,
+                  base::TimeDelta(), &group);
     callback->Run(result);
   }
 }
@@ -520,10 +524,12 @@ void ClientSocketPoolBaseHelper::HandOutSocket(
     ClientSocket* socket,
     bool reused,
     ClientSocketHandle* handle,
+    base::TimeDelta idle_time,
     Group* group) {
   DCHECK(socket);
   handle->set_socket(socket);
   handle->set_is_reused(reused);
+  handle->set_idle_time(idle_time);
 
   handed_out_socket_count_++;
   group->active_socket_count++;
diff --git a/net/socket/client_socket_pool_base.h b/net/socket/client_socket_pool_base.h
index bae88b7..bdcee36d 100644
--- a/net/socket/client_socket_pool_base.h
+++ b/net/socket/client_socket_pool_base.h
@@ -312,6 +312,7 @@ class ClientSocketPoolBaseHelper
   void HandOutSocket(ClientSocket* socket,
                      bool reused,
                      ClientSocketHandle* handle,
+                     base::TimeDelta time_idle,
                      Group* group);
 
   // Adds |socket| to the list of idle sockets for |group|.  |used| indicates