Add TRACE_EVENT calls to tcp_client_socket_linux.

net/base/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/base/tcp_client_socket.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <netdb.h>
 #include <sys/socket.h>
 
 #include "base/message_loop.h"
+#include "base/string_util.h"
+#include "base/trace_event.h"
 #include "net/base/net_errors.h"
 #include "third_party/libevent/event.h"
 
 
 namespace net {
 
 const int kInvalidSocket = -1;
 
 // Return 0 on success, -1 on failure.
 // Too small a function to bother putting in a library?
@@ skipping 53 matching lines @@
   Disconnect();
 }
 
 int TCPClientSocket::Connect(CompletionCallback* callback) {
   // If already connected, then just return OK.
   if (socket_ != kInvalidSocket)
     return OK;
 
   DCHECK(!waiting_connect_);
 
+  TRACE_EVENT_BEGIN("socket.connect", this, "");
   const addrinfo* ai = current_ai_;
   DCHECK(ai);
 
   int rv = CreateSocket(ai);
   if (rv != OK)
     return rv;
 
   if (!connect(socket_, ai->ai_addr, static_cast<int>(ai->ai_addrlen))) {
+    TRACE_EVENT_END("socket.connect", this, "");
     // Connected without waiting!
     return OK;
   }
 
   // Synchronous operation not supported
   DCHECK(callback);
 
   if (errno != EINPROGRESS) {
     DLOG(INFO) << "connect failed: " << errno;
     close(socket_);
@@ skipping 20 matching lines @@
 
 int TCPClientSocket::ReconnectIgnoringLastError(CompletionCallback* callback) {
   // No ignorable errors!
   return ERR_UNEXPECTED;
 }
 
 void TCPClientSocket::Disconnect() {
   if (socket_ == kInvalidSocket)
     return;
 
+  TRACE_EVENT_INSTANT("socket.disconnect", this, "");
+
   socket_watcher_.StopWatchingFileDescriptor();
   close(socket_);
   socket_ = kInvalidSocket;
   waiting_connect_ = false;
 
   // Reset for next time.
   current_ai_ = addresses_.head();
 }
 
 bool TCPClientSocket::IsConnected() const {
@@ skipping 14 matching lines @@
 int TCPClientSocket::Read(char* buf,
                           int buf_len,
                           CompletionCallback* callback) {
   DCHECK(socket_ != kInvalidSocket);
   DCHECK(!waiting_connect_);
   DCHECK(!callback_);
   // Synchronous operation not supported
   DCHECK(callback);
   DCHECK(buf_len > 0);
 
+  TRACE_EVENT_BEGIN("socket.read", this, "");
   int nread = read(socket_, buf, buf_len);
   if (nread >= 0) {
+    TRACE_EVENT_END("socket.read", this, StringPrintf("%d bytes", nread));
     return nread;
   }
   if (errno != EAGAIN && errno != EWOULDBLOCK) {
     DLOG(INFO) << "read failed, errno " << errno;
     return MapPosixError(errno);
   }
 
   if (!MessageLoopForIO::current()->WatchFileDescriptor(
           socket_, true, MessageLoopForIO::WATCH_READ, &socket_watcher_, this))
       {
@@ skipping 10 matching lines @@
 int TCPClientSocket::Write(const char* buf,
                            int buf_len,
                            CompletionCallback* callback) {
   DCHECK(socket_ != kInvalidSocket);
   DCHECK(!waiting_connect_);
   DCHECK(!write_callback_);
   // Synchronous operation not supported
   DCHECK(callback);
   DCHECK(buf_len > 0);
 
+  TRACE_EVENT_BEGIN("socket.write", this, "");
   int nwrite = write(socket_, buf, buf_len);
   if (nwrite >= 0) {
+    TRACE_EVENT_END("socket.write", this, StringPrintf("%d bytes", nwrite));
     return nwrite;
   }
   if (errno != EAGAIN && errno != EWOULDBLOCK)
     return MapPosixError(errno);
 
   if (!MessageLoopForIO::current()->WatchFileDescriptor(
           socket_, true, MessageLoopForIO::WATCH_WRITE, &socket_watcher_, this))
       {
     DLOG(INFO) << "WatchFileDescriptor failed on write, errno " << errno;
     return MapPosixError(errno);
   }
 
 
   write_buf_ = buf;
   write_buf_len_ = buf_len;
   write_callback_ = callback;
   return ERR_IO_PENDING;
 }
 
 int TCPClientSocket::CreateSocket(const addrinfo* ai) {
   socket_ = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol);
   if (socket_ == kInvalidSocket)
     return MapPosixError(errno);
 
-  // All our socket I/O is nonblocking
   if (SetNonBlocking(socket_))
     return MapPosixError(errno);
 
   return OK;
 }
 
 void TCPClientSocket::DoCallback(int rv) {
   DCHECK(rv != ERR_IO_PENDING);
   DCHECK(callback_);
 
   // since Run may result in Read being called, clear callback_ up front.
   CompletionCallback* c = callback_;
   callback_ = NULL;
   c->Run(rv);
 }
 
 void TCPClientSocket::DoWriteCallback(int rv) {
   DCHECK(rv != ERR_IO_PENDING);
   DCHECK(write_callback_);
 
   // since Run may result in Write being called, clear write_callback_ up front.
   CompletionCallback* c = write_callback_;
   write_callback_ = NULL;
   c->Run(rv);
 }
 
 void TCPClientSocket::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 && (
@@ skipping 18 matching lines @@
     DoCallback(result);
   }
 }
 
 void TCPClientSocket::DidCompleteRead() {
   int bytes_transferred;
   bytes_transferred = read(socket_, buf_, buf_len_);
 
   int result;
   if (bytes_transferred >= 0) {
+    TRACE_EVENT_END("socket.read", this,
+                    StringPrintf("%d bytes", bytes_transferred));
     result = bytes_transferred;
   } else {
     result = MapPosixError(errno);
   }
 
   if (result != ERR_IO_PENDING) {
     buf_ = NULL;
     buf_len_ = 0;
     socket_watcher_.StopWatchingFileDescriptor();
     DoCallback(result);
   }
 }
 
 void TCPClientSocket::DidCompleteWrite() {
   int bytes_transferred;
   bytes_transferred = write(socket_, write_buf_, write_buf_len_);
 
   int result;
   if (bytes_transferred >= 0) {
     result = bytes_transferred;
+    TRACE_EVENT_END("socket.write", this,
+                    StringPrintf("%d bytes", bytes_transferred));
   } else {
     result = MapPosixError(errno);
   }
 
   if (result != ERR_IO_PENDING) {
     write_buf_ = NULL;
     write_buf_len_ = 0;
     socket_watcher_.StopWatchingFileDescriptor();
     DoWriteCallback(result);
   }
@@ skipping 14 matching lines @@
     DidCompleteWrite();
   }
 }
 
 int TCPClientSocket::GetPeerName(struct sockaddr *name, socklen_t *namelen) {
   return ::getpeername(socket_, name, namelen);
 }
 
 }  // namespace net