* Change output of trace_event log to JSON to enable easier integration with ...

net/base/tcp_client_socket.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 "base/string_util.h"
 #include "base/trace_event.h"
 #include "net/base/net_errors.h"
 #include "net/base/winsock_init.h"
@@ skipping 139 matching lines @@
 int TCPClientSocket::Read(char* buf,
                           int buf_len,
                           CompletionCallback* callback) {
   DCHECK(socket_ != INVALID_SOCKET);
   DCHECK(wait_state_ == NOT_WAITING);
   DCHECK(!callback_);
 
   buffer_.len = buf_len;
   buffer_.buf = buf;
 
+  TRACE_EVENT_BEGIN("socket.read", this, "");
   // TODO(wtc): Remove the CHECKs after enough testing.
   CHECK(WaitForSingleObject(overlapped_.hEvent, 0) == WAIT_TIMEOUT);
   DWORD num, flags = 0;
   int rv = WSARecv(socket_, &buffer_, 1, &num, &flags, &overlapped_, NULL);
   if (rv == 0) {
     CHECK(WaitForSingleObject(overlapped_.hEvent, 0) == WAIT_OBJECT_0);
     BOOL ok = WSAResetEvent(overlapped_.hEvent);
     CHECK(ok);
+    TRACE_EVENT_END("socket.read", this, StringPrintf("%d bytes", num));
     return static_cast<int>(num);
   }
   int err = WSAGetLastError();
   if (err == WSA_IO_PENDING) {
     watcher_.StartWatching(overlapped_.hEvent, this);
     wait_state_ = WAITING_READ;
     callback_ = callback;
     return ERR_IO_PENDING;
   }
   return MapWinsockError(err);
 }
 
 int TCPClientSocket::Write(const char* buf,
                            int buf_len,
                            CompletionCallback* callback) {
   DCHECK(socket_ != INVALID_SOCKET);
   DCHECK(wait_state_ == NOT_WAITING);
   DCHECK(!callback_);
 
   buffer_.len = buf_len;
   buffer_.buf = const_cast<char*>(buf);
 
+  TRACE_EVENT_BEGIN("socket.write", this, "");
   // TODO(wtc): Remove the CHECKs after enough testing.
   CHECK(WaitForSingleObject(overlapped_.hEvent, 0) == WAIT_TIMEOUT);
   DWORD num;
   int rv = WSASend(socket_, &buffer_, 1, &num, 0, &overlapped_, NULL);
   if (rv == 0) {
     CHECK(WaitForSingleObject(overlapped_.hEvent, 0) == WAIT_OBJECT_0);
     BOOL ok = WSAResetEvent(overlapped_.hEvent);
     CHECK(ok);
+    TRACE_EVENT_END("socket.write", this, StringPrintf("%d bytes", num));
     return static_cast<int>(num);
   }
   int err = WSAGetLastError();
   if (err == WSA_IO_PENDING) {
     watcher_.StartWatching(overlapped_.hEvent, this);
     wait_state_ = WAITING_WRITE;
     callback_ = callback;
     return ERR_IO_PENDING;
   }
   return MapWinsockError(err);
@@ skipping 57 matching lines @@
   if (result != ERR_IO_PENDING)
     DoCallback(result);
 }
 
 void TCPClientSocket::DidCompleteIO() {
   DWORD num_bytes, flags;
   BOOL ok = WSAGetOverlappedResult(
       socket_, &overlapped_, &num_bytes, FALSE, &flags);
   WSAResetEvent(overlapped_.hEvent);
   if (wait_state_ == WAITING_READ) {
-    TRACE_EVENT_INSTANT("socket.read", this, 
-                        StringPrintf("%d bytes", num_bytes));
+    TRACE_EVENT_END("socket.read", this, StringPrintf("%d bytes", num_bytes));
   } else {
-    TRACE_EVENT_INSTANT("socket.write", this, 
-                        StringPrintf("%d bytes", num_bytes));
+    TRACE_EVENT_END("socket.write", this, StringPrintf("%d bytes", num_bytes));
   }
   wait_state_ = NOT_WAITING;
   DoCallback(ok ? num_bytes : MapWinsockError(WSAGetLastError()));
 }
 
 void TCPClientSocket::OnObjectSignaled(HANDLE object) {
   DCHECK(object == overlapped_.hEvent);
 
   switch (wait_state_) {
     case WAITING_CONNECT:
       DidCompleteConnect();
       break;
     case WAITING_READ:
     case WAITING_WRITE:
       DidCompleteIO();
       break;
     default:
       NOTREACHED();
       break;
   }
 }
 
 }  // namespace net