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

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_libevent.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <netdb.h>
 #include <sys/socket.h>
@@ skipping 154 matching lines @@
   char c;
   int rv = recv(socket_, &c, 1, MSG_PEEK);
   if (rv >= 0)
     return false;
   if (errno != EAGAIN && errno != EWOULDBLOCK)
     return false;
 
   return true;
 }
 
-int TCPClientSocketLibevent::Read(char* buf,
+int TCPClientSocketLibevent::Read(IOBuffer* buf,
                                   int buf_len,
                                   CompletionCallback* callback) {
   DCHECK_NE(kInvalidSocket, socket_);
   DCHECK(!waiting_connect_);
   DCHECK(!read_callback_);
   // Synchronous operation not supported
   DCHECK(callback);
   DCHECK_GT(buf_len, 0);
 
   TRACE_EVENT_BEGIN("socket.read", this, "");
-  int nread = read(socket_, buf, buf_len);
+  int nread = read(socket_, buf->data(), 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)) {
     DLOG(INFO) << "WatchFileDescriptor failed on read, errno " << errno;
     return MapPosixError(errno);
   }
 
   read_buf_ = buf;
   read_buf_len_ = buf_len;
   read_callback_ = callback;
   return ERR_IO_PENDING;
 }
 
-int TCPClientSocketLibevent::Write(const char* buf,
+int TCPClientSocketLibevent::Write(IOBuffer* buf,
                                    int buf_len,
                                    CompletionCallback* callback) {
   DCHECK_NE(kInvalidSocket, socket_);
   DCHECK(!waiting_connect_);
   DCHECK(!write_callback_);
   // Synchronous operation not supported
   DCHECK(callback);
   DCHECK_GT(buf_len, 0);
 
   TRACE_EVENT_BEGIN("socket.write", this, "");
-  int nwrite = write(socket_, buf, buf_len);
+  int nwrite = write(socket_, buf->data(), 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)) {
@@ skipping 71 matching lines @@
     waiting_connect_ = false;
   }
 
   if (result != ERR_IO_PENDING) {
     DoReadCallback(result);
   }
 }
 
 void TCPClientSocketLibevent::DidCompleteRead() {
   int bytes_transferred;
-  bytes_transferred = read(socket_, read_buf_, read_buf_len_);
+  bytes_transferred = read(socket_, read_buf_->data(), read_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) {
     read_buf_ = NULL;
     read_buf_len_ = 0;
     socket_watcher_.StopWatchingFileDescriptor();
     DoReadCallback(result);
   }
 }
 
 void TCPClientSocketLibevent::DidCompleteWrite() {
   int bytes_transferred;
-  bytes_transferred = write(socket_, write_buf_, write_buf_len_);
+  bytes_transferred = write(socket_, write_buf_->data(), 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);
   }
 
@@ skipping 20 matching lines @@
     DidCompleteWrite();
   }
 }
 
 int TCPClientSocketLibevent::GetPeerName(struct sockaddr *name,
                                          socklen_t *namelen) {
   return ::getpeername(socket_, name, namelen);
 }
 
 }  // namespace net