Add LoadLog to ClientSocket::Connect().

net/socket/tcp_client_socket_win.cc

 // Copyright (c) 2006-2008 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 "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/field_trial.h"  // for SlowStart trial
 #include "base/memory_debug.h"
 #include "base/stats_counters.h"
 #include "base/string_util.h"
 #include "base/sys_info.h"
 #include "base/trace_event.h"
 #include "net/base/io_buffer.h"
+#include "net/base/load_log.h"
 #include "net/base/net_errors.h"
 #include "net/base/winsock_init.h"
 
 namespace net {
 
 namespace {
 
 // If the (manual-reset) event object is signaled, resets it and returns true.
 // Otherwise, does nothing and returns false.  Called after a Winsock function
 // succeeds synchronously
@@ skipping 238 matching lines @@
       waiting_write_(false),
       read_callback_(NULL),
       write_callback_(NULL) {
   EnsureWinsockInit();
 }
 
 TCPClientSocketWin::~TCPClientSocketWin() {
   Disconnect();
 }
 
-int TCPClientSocketWin::Connect(CompletionCallback* callback) {
+int TCPClientSocketWin::Connect(CompletionCallback* callback,
+                                LoadLog* load_log) {
   // If already connected, then just return OK.
   if (socket_ != INVALID_SOCKET)
     return OK;
 
+  DCHECK(!load_log_);
+
   static StatsCounter connects("tcp.connect");
   connects.Increment();
 
   TRACE_EVENT_BEGIN("socket.connect", this, "");
+
+  LoadLog::BeginEvent(load_log, LoadLog::TYPE_TCP_CONNECT);
+
+  int rv = DoConnect();
+
+  if (rv == ERR_IO_PENDING) {
+    // Synchronous operation not supported.
+    DCHECK(callback);
+
+    load_log_ = load_log;
+    waiting_connect_ = true;
+    read_callback_ = callback;
+  } else {
+    TRACE_EVENT_END("socket.connect", this, "");
+    LoadLog::EndEvent(load_log, LoadLog::TYPE_TCP_CONNECT);
+  }
+
+  return rv;
+}
+
+int TCPClientSocketWin::DoConnect() {
   const struct addrinfo* ai = current_ai_;
   DCHECK(ai);
 
   int rv = CreateSocket(ai);
   if (rv != OK)
     return rv;
 
   DCHECK(!core_);
   core_ = new Core(this);
 
@@ skipping 11 matching lines @@
     // 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
     // and we don't know if it's correct.
     NOTREACHED();
 
-    if (ResetEventIfSignaled(core_->read_overlapped_.hEvent)) {
-      TRACE_EVENT_END("socket.connect", this, "");
+    if (ResetEventIfSignaled(core_->read_overlapped_.hEvent))
       return OK;
-    }
   } else {
     DWORD err = WSAGetLastError();
     if (err != WSAEWOULDBLOCK) {
       LOG(ERROR) << "connect failed: " << err;
       return MapConnectError(err);
     }
   }
 
   core_->WatchForRead();
-  waiting_connect_ = true;
-  read_callback_ = callback;
   return ERR_IO_PENDING;
 }
 
 void TCPClientSocketWin::Disconnect() {
   if (socket_ == INVALID_SOCKET)
     return;
 
   TRACE_EVENT_INSTANT("socket.disconnect", this, "");
 
   // Note: don't use CancelIo to cancel pending IO because it doesn't work
@@ skipping 241 matching lines @@
   // since Run may result in Write being called, clear write_callback_ up front.
   CompletionCallback* c = write_callback_;
   write_callback_ = NULL;
   c->Run(rv);
 }
 
 void TCPClientSocketWin::DidCompleteConnect() {
   DCHECK(waiting_connect_);
   int result;
 
-  TRACE_EVENT_END("socket.connect", this, "");
   waiting_connect_ = false;
 
   WSANETWORKEVENTS events;
   int rv = WSAEnumNetworkEvents(socket_, core_->read_overlapped_.hEvent,
                                 &events);
   if (rv == SOCKET_ERROR) {
     NOTREACHED();
     result = MapWinsockError(WSAGetLastError());
   } else if (events.lNetworkEvents & FD_CONNECT) {
     DWORD error_code = static_cast<DWORD>(events.iErrorCode[FD_CONNECT_BIT]);
     if (current_ai_->ai_next && (
         error_code == WSAEADDRNOTAVAIL ||
         error_code == WSAEAFNOSUPPORT ||
         error_code == WSAECONNREFUSED ||
         error_code == WSAENETUNREACH ||
         error_code == WSAEHOSTUNREACH ||
         error_code == WSAETIMEDOUT)) {
       // Try using the next address.
       const struct addrinfo* next = current_ai_->ai_next;
       Disconnect();
       current_ai_ = next;
-      result = Connect(read_callback_);
+      scoped_refptr<LoadLog> load_log;
+      load_log.swap(load_log_);
+      TRACE_EVENT_END("socket.connect", this, "");
+      LoadLog::EndEvent(load_log, LoadLog::TYPE_TCP_CONNECT);
+      result = Connect(read_callback_, load_log);
     } else {
       result = MapConnectError(error_code);
+      TRACE_EVENT_END("socket.connect", this, "");
+      LoadLog::EndEvent(load_log_, LoadLog::TYPE_TCP_CONNECT);
+      load_log_ = NULL;
     }
   } else {
     NOTREACHED();
     result = ERR_UNEXPECTED;
+    TRACE_EVENT_END("socket.connect", this, "");
+    LoadLog::EndEvent(load_log_, LoadLog::TYPE_TCP_CONNECT);
+    load_log_ = NULL;
   }
 
   if (result != ERR_IO_PENDING)
     DoReadCallback(result);
 }
 
 void TCPClientSocketWin::DidCompleteRead() {
   DCHECK(waiting_read_);
   DWORD num_bytes, flags;
   BOOL ok = WSAGetOverlappedResult(socket_, &core_->read_overlapped_,
@@ skipping 12 matching lines @@
   BOOL ok = WSAGetOverlappedResult(socket_, &core_->write_overlapped_,
                                    &num_bytes, FALSE, &flags);
   WSAResetEvent(core_->write_overlapped_.hEvent);
   TRACE_EVENT_END("socket.write", this, StringPrintf("%d bytes", num_bytes));
   waiting_write_ = false;
   core_->write_iobuffer_ = NULL;
   DoWriteCallback(ok ? num_bytes : MapWinsockError(WSAGetLastError()));
 }
 
 }  // namespace net