Add net log entries that summarize transmit and receive byte counts.

net/socket/client_socket_pool_base.cc

 // Copyright (c) 2010 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/client_socket_pool_base.h"
 
 #include "base/compiler_specific.h"
 #include "base/format_macros.h"
 #include "base/message_loop.h"
 #include "base/stats_counters.h"
@@ skipping 20 matching lines @@
 
 namespace net {
 
 ConnectJob::ConnectJob(const std::string& group_name,
                        base::TimeDelta timeout_duration,
                        Delegate* delegate,
                        const BoundNetLog& net_log)
     : group_name_(group_name),
       timeout_duration_(timeout_duration),
       delegate_(delegate),
-      net_log_(net_log) {
+      net_log_(net_log),
+      idle_(true) {
   DCHECK(!group_name.empty());
   DCHECK(delegate);
 }
 
 ConnectJob::~ConnectJob() {
-  if (delegate_) {
+  if (delegate_ && !idle_) {
     // If the delegate was not NULLed, then NotifyDelegateOfCompletion has
-    // not been called yet (hence we are cancelling).
+    // not been called yet.  If we've started then we are cancelling.
     net_log_.AddEvent(NetLog::TYPE_CANCELLED);
     net_log_.EndEvent(NetLog::TYPE_SOCKET_POOL_CONNECT_JOB);
   }
 }
 
 int ConnectJob::Connect() {
   if (timeout_duration_ != base::TimeDelta())
     timer_.Start(timeout_duration_, this, &ConnectJob::OnTimeout);
 
   net_log_.BeginEventWithString(NetLog::TYPE_SOCKET_POOL_CONNECT_JOB,
                                 group_name_);
+  idle_ = false;
 
   int rv = ConnectInternal();
 
   if (rv != ERR_IO_PENDING) {
     delegate_ = NULL;
     net_log_.EndEvent(NetLog::TYPE_SOCKET_POOL_CONNECT_JOB);
   }
 
   return rv;
 }
@@ skipping 153 matching lines @@
 
   // See if we already have enough connect jobs or sockets that will be released
   // soon.
   if (group.HasReleasingSockets()) {
     return ERR_IO_PENDING;
   }
 
   // We couldn't find a socket to reuse, so allocate and connect a new one.
   BoundNetLog job_net_log = BoundNetLog::Make(
       request->net_log().net_log(), NetLog::SOURCE_CONNECT_JOB);
+  request->net_log().BeginEventWithInteger(
+      NetLog::TYPE_SOCKET_POOL_CONNECT_JOB_ID, job_net_log.source().id);
 
   scoped_ptr<ConnectJob> connect_job(
       connect_job_factory_->NewConnectJob(group_name, *request, this,
                                           job_net_log));
 
   int rv = connect_job->Connect();
-
-  if (rv != ERR_IO_PENDING) {
-    request->net_log().AddEventWithInteger(
-        NetLog::TYPE_SOCKET_POOL_CONNECT_JOB_ID,
-        job_net_log.source().id);
-  }
-
   if (rv == OK) {
+    request->net_log().EndEventWithInteger(
+        NetLog::TYPE_SOCKET_POOL_CONNECT_JOB_ID, job_net_log.source().id);
     HandOutSocket(connect_job->ReleaseSocket(), false /* not reused */,
                   handle, base::TimeDelta(), &group, request->net_log());
   } else if (rv == ERR_IO_PENDING) {
     // If we don't have any sockets in this group, set a timer for potentially
     // creating a new one.  If the SYN is lost, this backup socket may complete
     // before the slow socket, improving end user latency.
     if (group.IsEmpty() && !group.backup_job && backup_jobs_enabled_) {
       group.backup_job = connect_job_factory_->NewConnectJob(group_name,
                                                              *request,
                                                              this,
                                                              job_net_log);
       StartBackupSocketTimer(group_name);
     }
 
     connecting_socket_count_++;
 
     ConnectJob* job = connect_job.release();
     group.jobs.insert(job);
-  } else if (group.IsEmpty()) {
-    group_map_.erase(group_name);
+  } else {
+    request->net_log().EndEventWithInteger(
+        NetLog::TYPE_SOCKET_POOL_CONNECT_JOB_ID, job_net_log.source().id);
+    if (group.IsEmpty())
+      group_map_.erase(group_name);
   }
 
   return rv;
 }
 
 void ClientSocketPoolBaseHelper::StartBackupSocketTimer(
     const std::string& group_name) {
   CHECK(ContainsKey(group_map_, group_name));
   Group& group = group_map_[group_name];
 
@@ skipping 281 matching lines @@
   scoped_ptr<ClientSocket> socket(job->ReleaseSocket());
 
   BoundNetLog job_log = job->net_log();
   RemoveConnectJob(job, &group);
 
   if (result == OK) {
     DCHECK(socket.get());
     if (!group.pending_requests.empty()) {
       scoped_ptr<const Request> r(RemoveRequestFromQueue(
           group.pending_requests.begin(), &group.pending_requests));
-      r->net_log().AddEventWithInteger(NetLog::TYPE_SOCKET_POOL_CONNECT_JOB_ID,
+      r->net_log().EndEventWithInteger(NetLog::TYPE_SOCKET_POOL_CONNECT_JOB_ID,
                                        job_log.source().id);
       r->net_log().EndEvent(NetLog::TYPE_SOCKET_POOL);
       HandOutSocket(
           socket.release(), false /* unused socket */, r->handle(),
           base::TimeDelta(), &group, r->net_log());
       r->callback()->Run(result);
     } else {
       AddIdleSocket(socket.release(), false /* unused socket */, &group);
       OnAvailableSocketSlot(group_name, &group);
     }
   } else {
     DCHECK(!socket.get());
     if (!group.pending_requests.empty()) {
       scoped_ptr<const Request> r(RemoveRequestFromQueue(
           group.pending_requests.begin(), &group.pending_requests));
-      r->net_log().AddEventWithInteger(NetLog::TYPE_SOCKET_POOL_CONNECT_JOB_ID,
+      r->net_log().EndEventWithInteger(NetLog::TYPE_SOCKET_POOL_CONNECT_JOB_ID,
                                        job_log.source().id);
       r->net_log().EndEvent(NetLog::TYPE_SOCKET_POOL);
       r->callback()->Run(result);
     }
     MaybeOnAvailableSocketSlot(group_name);
   }
 }
 
 void ClientSocketPoolBaseHelper::OnIPAddressChanged() {
   CloseIdleSockets();
@@ skipping 75 matching lines @@
   handle->set_is_reused(reused);
   handle->set_idle_time(idle_time);
 
   if (reused)
     net_log.AddStringLiteral("Reusing socket.");
   if (idle_time != base::TimeDelta()) {
     net_log.AddString(
         StringPrintf("Socket sat idle for %" PRId64 " milliseconds",
                      idle_time.InMilliseconds()));
   }
+  net_log.AddEventWithInteger(NetLog::TYPE_SOCKET_POOL_SOCKET_ID,
+                              socket->NetLog().source().id);
 
   handed_out_socket_count_++;
   group->active_socket_count++;
 }
 
 void ClientSocketPoolBaseHelper::AddIdleSocket(
     ClientSocket* socket, bool used, Group* group) {
   DCHECK(socket);
   IdleSocket idle_socket;
   idle_socket.socket = socket;
@@ skipping 27 matching lines @@
 bool ClientSocketPoolBaseHelper::ReachedMaxSocketsLimit() const {
   // Each connecting socket will eventually connect and be handed out.
   int total = handed_out_socket_count_ + connecting_socket_count_;
   DCHECK_LE(total, max_sockets_);
   return total == max_sockets_;
 }
 
 }  // namespace internal
 
 }  // namespace net