Add LoadLog to ClientSocket::Connect().

net/socket/tcp_client_socket_libevent.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_libevent.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <netdb.h>
 #include <sys/socket.h>
 
 #include "base/eintr_wrapper.h"
 #include "base/message_loop.h"
 #include "base/string_util.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 "third_party/libevent/event.h"
 
 
 namespace net {
 
 namespace {
 
 const int kInvalidSocket = -1;
 
@@ skipping 83 matching lines @@
       read_watcher_(this),
       write_watcher_(this),
       read_callback_(NULL),
       write_callback_(NULL) {
 }
 
 TCPClientSocketLibevent::~TCPClientSocketLibevent() {
   Disconnect();
 }
 
-int TCPClientSocketLibevent::Connect(CompletionCallback* callback) {
+int TCPClientSocketLibevent::Connect(CompletionCallback* callback,
+                                     LoadLog* load_log) {
   // If already connected, then just return OK.
   if (socket_ != kInvalidSocket)
     return OK;
 
   DCHECK(!waiting_connect_);
+  DCHECK(!load_log_);
 
   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;
+    write_callback_ = callback;
+  } else {
+    TRACE_EVENT_END("socket.connect", this, "");
+    LoadLog::EndEvent(load_log, LoadLog::TYPE_TCP_CONNECT);
+  }
+
+  return rv;
+}
+
+int TCPClientSocketLibevent::DoConnect() {
   while (true) {
     DCHECK(current_ai_);
 
     int rv = CreateSocket(current_ai_);
     if (rv != OK)
       return rv;
 
     if (!HANDLE_EINTR(connect(socket_, current_ai_->ai_addr,
                               static_cast<int>(current_ai_->ai_addrlen)))) {
-      TRACE_EVENT_END("socket.connect", this, "");
       // Connected without waiting!
       return OK;
     }
 
     int error_code = errno;
     if (error_code == EINPROGRESS)
       break;
 
     close(socket_);
     socket_ = kInvalidSocket;
 
     if (current_ai_->ai_next && ShouldTryNextAddress(error_code)) {
       // connect() can fail synchronously for an address even on a
       // non-blocking socket.  As an example, this can happen when there is
       // no route to the host.  Retry using the next address in the list.
       current_ai_ = current_ai_->ai_next;
     } else {
       DLOG(INFO) << "connect failed: " << error_code;
       return MapConnectError(error_code);
     }
   }
 
-  // Synchronous operation not supported
-  DCHECK(callback);
-
   // Initialize write_socket_watcher_ and link it to our MessagePump.
   // POLLOUT is set if the connection is established.
   // POLLIN is set if the connection fails.
   if (!MessageLoopForIO::current()->WatchFileDescriptor(
           socket_, true, MessageLoopForIO::WATCH_WRITE, &write_socket_watcher_,
           &write_watcher_)) {
     DLOG(INFO) << "WatchFileDescriptor failed: " << errno;
     close(socket_);
     socket_ = kInvalidSocket;
     return MapPosixError(errno);
   }
 
-  waiting_connect_ = true;
-  write_callback_ = callback;
   return ERR_IO_PENDING;
 }
 
 void TCPClientSocketLibevent::Disconnect() {
   if (socket_ == kInvalidSocket)
     return;
 
   TRACE_EVENT_INSTANT("socket.disconnect", this, "");
 
   bool ok = read_socket_watcher_.StopWatchingFileDescriptor();
@@ skipping 150 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 TCPClientSocketLibevent::DidCompleteConnect() {
   int result = ERR_UNEXPECTED;
 
-  TRACE_EVENT_END("socket.connect", this, "");
-
   // Check to see if connect succeeded
   int error_code = 0;
   socklen_t len = sizeof(error_code);
   if (getsockopt(socket_, SOL_SOCKET, SO_ERROR, &error_code, &len) < 0)
     error_code = errno;
 
   if (error_code == EINPROGRESS || error_code == EALREADY) {
     NOTREACHED();  // This indicates a bug in libevent or our code.
     result = ERR_IO_PENDING;
   } else if (current_ai_->ai_next && ShouldTryNextAddress(error_code)) {
     // This address failed, try next one in list.
     const addrinfo* next = current_ai_->ai_next;
     Disconnect();
     current_ai_ = next;
-    result = Connect(write_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(write_callback_, load_log);
   } else {
     result = MapConnectError(error_code);
     bool ok = write_socket_watcher_.StopWatchingFileDescriptor();
     DCHECK(ok);
     waiting_connect_ = false;
+    TRACE_EVENT_END("socket.connect", this, "");
+    LoadLog::EndEvent(load_log_, LoadLog::TYPE_TCP_CONNECT);
+    load_log_ = NULL;
   }
 
   if (result != ERR_IO_PENDING) {
     DoWriteCallback(result);
   }
 }
 
 void TCPClientSocketLibevent::DidCompleteRead() {
   int bytes_transferred;
   bytes_transferred = HANDLE_EINTR(read(socket_, read_buf_->data(),
@@ skipping 38 matching lines @@
     DoWriteCallback(result);
   }
 }
 
 int TCPClientSocketLibevent::GetPeerName(struct sockaddr *name,
                                          socklen_t *namelen) {
   return ::getpeername(socket_, name, namelen);
 }
 
 }  // namespace net