Extend the use of IOBuffers to the code underneath...

net/base/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/base/tcp_client_socket_win.h"
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/memory_debug.h"
 #include "base/string_util.h"
@@ skipping 155 matching lines @@
   WSACloseEvent(read_overlapped_.hEvent);
   memset(&read_overlapped_, 0, sizeof(read_overlapped_));
   WSACloseEvent(write_overlapped_.hEvent);
   memset(&write_overlapped_, 0, sizeof(write_overlapped_));
 
   // Reset for next time.
   current_ai_ = addresses_.head();
 
   waiting_read_ = false;
   waiting_write_ = false;
+  read_iobuffer_ = NULL;
+  write_iobuffer_ = NULL;
   waiting_connect_ = false;
 }
 
 bool TCPClientSocketWin::IsConnected() const {
   if (socket_ == INVALID_SOCKET || waiting_connect_)
     return false;
 
   // Check if connection is alive.
   char c;
   int rv = recv(socket_, &c, 1, MSG_PEEK);
@@ skipping 14 matching lines @@
   char c;
   int rv = recv(socket_, &c, 1, MSG_PEEK);
   if (rv >= 0)
     return false;
   if (WSAGetLastError() != WSAEWOULDBLOCK)
     return false;
 
   return true;
 }
 
-int TCPClientSocketWin::Read(char* buf,
+int TCPClientSocketWin::Read(IOBuffer* buf,
                              int buf_len,
                              CompletionCallback* callback) {
   DCHECK_NE(socket_, INVALID_SOCKET);
   DCHECK(!waiting_read_);
   DCHECK(!read_callback_);
+  DCHECK(!read_iobuffer_);
 
   read_buffer_.len = buf_len;
-  read_buffer_.buf = buf;
+  read_buffer_.buf = buf->data();
 
   TRACE_EVENT_BEGIN("socket.read", this, "");
   // TODO(wtc): Remove the CHECK after enough testing.
   CHECK(WaitForSingleObject(read_overlapped_.hEvent, 0) == WAIT_TIMEOUT);
   DWORD num, flags = 0;
   int rv = WSARecv(
       socket_, &read_buffer_, 1, &num, &flags, &read_overlapped_, NULL);
   if (rv == 0) {
     WaitForAndResetEvent(read_overlapped_.hEvent);
     TRACE_EVENT_END("socket.read", this, StringPrintf("%d bytes", num));
 
     // Because of how WSARecv fills memory when used asynchronously, Purify
     // isn't able to detect that it's been initialized, so it scans for 0xcd
     // in the buffer and reports UMRs (uninitialized memory reads) for those
     // individual bytes. We override that in PURIFY builds to avoid the false
     // error reports.
     // See bug 5297.
     base::MemoryDebug::MarkAsInitialized(read_buffer_.buf, num);
     return static_cast<int>(num);
   }
   int err = WSAGetLastError();
   if (err == WSA_IO_PENDING) {
     read_watcher_.StartWatching(read_overlapped_.hEvent, &reader_);
     waiting_read_ = true;
     read_callback_ = callback;
+    read_iobuffer_ = buf;
     return ERR_IO_PENDING;
   }
   return MapWinsockError(err);
 }
 
-int TCPClientSocketWin::Write(const char* buf,
+int TCPClientSocketWin::Write(IOBuffer* buf,
                               int buf_len,
                               CompletionCallback* callback) {
   DCHECK_NE(socket_, INVALID_SOCKET);
   DCHECK(!waiting_write_);
   DCHECK(!write_callback_);
   DCHECK_GT(buf_len, 0);
+  DCHECK(!write_iobuffer_);
 
   write_buffer_.len = buf_len;
-  write_buffer_.buf = const_cast<char*>(buf);
+  write_buffer_.buf = buf->data();
 
   TRACE_EVENT_BEGIN("socket.write", this, "");
   // TODO(wtc): Remove the CHECK after enough testing.
   CHECK(WaitForSingleObject(write_overlapped_.hEvent, 0) == WAIT_TIMEOUT);
   DWORD num;
   int rv =
       WSASend(socket_, &write_buffer_, 1, &num, 0, &write_overlapped_, NULL);
   if (rv == 0) {
     WaitForAndResetEvent(write_overlapped_.hEvent);
     TRACE_EVENT_END("socket.write", this, StringPrintf("%d bytes", num));
     return static_cast<int>(num);
   }
   int err = WSAGetLastError();
   if (err == WSA_IO_PENDING) {
     write_watcher_.StartWatching(write_overlapped_.hEvent, &writer_);
     waiting_write_ = true;
     write_callback_ = callback;
+    write_iobuffer_ = buf;
     return ERR_IO_PENDING;
   }
   return MapWinsockError(err);
 }
 
 int TCPClientSocketWin::CreateSocket(const struct addrinfo* ai) {
   socket_ = WSASocket(ai->ai_family, ai->ai_socktype, ai->ai_protocol, NULL, 0,
                       WSA_FLAG_OVERLAPPED);
   if (socket_ == INVALID_SOCKET) {
     DWORD err = WSAGetLastError();
@@ skipping 112 matching lines @@
   if (result != ERR_IO_PENDING)
     DoReadCallback(result);
 }
 
 void TCPClientSocketWin::ReadDelegate::OnObjectSignaled(HANDLE object) {
   DCHECK_EQ(object, tcp_socket_->read_overlapped_.hEvent);
 
   if (tcp_socket_->waiting_connect_) {
     tcp_socket_->DidCompleteConnect();
   } else {
+    DCHECK(tcp_socket_->waiting_read_);
     DWORD num_bytes, flags;
     BOOL ok = WSAGetOverlappedResult(
         tcp_socket_->socket_, &tcp_socket_->read_overlapped_, &num_bytes,
         FALSE, &flags);
     WSAResetEvent(object);
     TRACE_EVENT_END("socket.read", tcp_socket_,
                     StringPrintf("%d bytes", num_bytes));
     tcp_socket_->waiting_read_ = false;
+    tcp_socket_->read_iobuffer_ = NULL;
     tcp_socket_->DoReadCallback(
         ok ? num_bytes : MapWinsockError(WSAGetLastError()));
   }
 }
 
 void TCPClientSocketWin::WriteDelegate::OnObjectSignaled(HANDLE object) {
   DCHECK_EQ(object, tcp_socket_->write_overlapped_.hEvent);
+  DCHECK(tcp_socket_->waiting_write_);
 
   DWORD num_bytes, flags;
   BOOL ok = WSAGetOverlappedResult(
       tcp_socket_->socket_, &tcp_socket_->write_overlapped_, &num_bytes,
       FALSE, &flags);
   WSAResetEvent(object);
   TRACE_EVENT_END("socket.write", tcp_socket_,
                   StringPrintf("%d bytes", num_bytes));
   tcp_socket_->waiting_write_ = false;
+  tcp_socket_->write_iobuffer_ = NULL;
   tcp_socket_->DoWriteCallback(
       ok ? num_bytes : MapWinsockError(WSAGetLastError()));
 }
 
 }  // namespace net