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

net/base/ssl_client_socket_mac.cc

 // Copyright (c) 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/ssl_client_socket_mac.h"
 
 #include "base/singleton.h"
 #include "base/string_util.h"
 #include "net/base/net_errors.h"
 #include "net/base/ssl_info.h"
@@ skipping 331 matching lines @@
   // Unlike IsConnected, this method doesn't return a false positive.
   //
   // Strictly speaking, we should check if we have received the close_notify
   // alert message from the server, and return false in that case.  Although
   // the close_notify alert message means EOF in the SSL layer, it is just
   // bytes to the transport layer below, so transport_->IsConnectedAndIdle()
   // returns the desired false when we receive close_notify.
   return completed_handshake_ && transport_->IsConnectedAndIdle();
 }
 
-int SSLClientSocketMac::Read(char* buf, int buf_len,
+int SSLClientSocketMac::Read(IOBuffer* buf, int buf_len,
                              CompletionCallback* callback) {
   DCHECK(completed_handshake_);
   DCHECK(next_state_ == STATE_NONE);
   DCHECK(!user_callback_);
+  DCHECK(!user_buf_);
 
   user_buf_ = buf;
   user_buf_len_ = buf_len;
 
   next_state_ = STATE_PAYLOAD_READ;
   int rv = DoLoop(OK);
-  if (rv == ERR_IO_PENDING)
+  if (rv == ERR_IO_PENDING) {
     user_callback_ = callback;
+  } else {
+    user_buf_ = NULL;
+  }
   return rv;
 }
 
-int SSLClientSocketMac::Write(const char* buf, int buf_len,
+int SSLClientSocketMac::Write(IOBuffer* buf, int buf_len,
                               CompletionCallback* callback) {
   DCHECK(completed_handshake_);
   DCHECK(next_state_ == STATE_NONE);
   DCHECK(!user_callback_);
+  DCHECK(!user_buf_);
 
-  user_buf_ = const_cast<char*>(buf);
+  user_buf_ = buf;
   user_buf_len_ = buf_len;
 
   next_state_ = STATE_PAYLOAD_WRITE;
   int rv = DoLoop(OK);
-  if (rv == ERR_IO_PENDING)
+  if (rv == ERR_IO_PENDING) {
     user_callback_ = callback;
+  } else {
+    user_buf_ = NULL;
+  }
   return rv;
 }
 
 void SSLClientSocketMac::GetSSLInfo(SSLInfo* ssl_info) {
   DCHECK(completed_handshake_);
   OSStatus status;
 
   ssl_info->Reset();
 
   // set cert
@@ skipping 21 matching lines @@
     ssl_info->security_bits = KeySizeOfCipherSuite(suite);
 }
 
 void SSLClientSocketMac::DoCallback(int rv) {
   DCHECK(rv != ERR_IO_PENDING);
   DCHECK(user_callback_);
 
   // since Run may result in Read being called, clear user_callback_ up front.
   CompletionCallback* c = user_callback_;
   user_callback_ = NULL;
+  user_buf_ = NULL;
   c->Run(rv);
 }
 
 void SSLClientSocketMac::OnIOComplete(int result) {
   if (next_io_state_ != STATE_NONE) {
     State next_state = next_state_;
     next_state_ = next_io_state_;
     next_io_state_ = STATE_NONE;
     result = DoLoop(result);
     next_state_ = next_state;
@@ skipping 59 matching lines @@
 
   // TODO(wtc): for now, always check revocation.
   server_cert_status_ = CERT_STATUS_REV_CHECKING_ENABLED;
   if (net_error)
     server_cert_status_ |= MapNetErrorToCertStatus(net_error);
 
   return net_error;
 }
 
 int SSLClientSocketMac::DoReadComplete(int result) {
-  if (result < 0)
+  if (result < 0) {
+    read_io_buf_ = NULL;
     return result;
+  }
+
+  char* buffer = &recv_buffer_[recv_buffer_.size() - recv_buffer_tail_slop_];
+  memcpy(buffer, read_io_buf_->data(), result);
+  read_io_buf_ = NULL;
 
   recv_buffer_tail_slop_ -= result;
 
   return result;
 }
 
 void SSLClientSocketMac::OnWriteComplete(int result) {
   if (result < 0) {
     pending_send_error_ = result;
     return;
   }
 
   send_buffer_.erase(send_buffer_.begin(),
                      send_buffer_.begin() + result);
 
   if (!send_buffer_.empty())
     SSLWriteCallback(this, NULL, NULL);
 }
 
 int SSLClientSocketMac::DoPayloadRead() {
   size_t processed;
   OSStatus status = SSLRead(ssl_context_,
-                            user_buf_,
+                            user_buf_->data(),
                             user_buf_len_,
                             &processed);
 
   // There's a subtle difference here in semantics of the "would block" errors.
   // In our code, ERR_IO_PENDING means the whole operation is async, while
   // errSSLWouldBlock means that the stream isn't ending (and is often returned
   // along with partial data). So even though "would block" is returned, if we
   // have data, let's just return it.
 
   if (processed > 0) {
     next_state_ = STATE_NONE;
     return processed;
   }
 
   if (status == errSSLWouldBlock) {
     next_state_ = STATE_PAYLOAD_READ;
   }
 
   return NetErrorFromOSStatus(status);
 }
 
 int SSLClientSocketMac::DoPayloadWrite() {
   size_t processed;
   OSStatus status = SSLWrite(ssl_context_,
-                             user_buf_,
+                             user_buf_->data(),
                              user_buf_len_,
                              &processed);
 
   if (processed > 0)
     return processed;
 
   return NetErrorFromOSStatus(status);
 }
 
 // Handling the reading from the network is one of those things that should be
@@ skipping 92 matching lines @@
 
   // Resize the buffer if needed
 
   if (us->recv_buffer_.size() - us->recv_buffer_head_slop_ < *data_length) {
     us->recv_buffer_.resize(us->recv_buffer_head_slop_ + *data_length);
     us->recv_buffer_tail_slop_ = *data_length - total_read;
   }
 
   int rv = 1;  // any old value to spin the loop below
   while (rv > 0 && total_read < *data_length) {
-    rv = us->transport_->Read(&us->recv_buffer_[us->recv_buffer_head_slop_ +
-                                                total_read],
-                              us->recv_buffer_tail_slop_,
+    char* buffer = &us->recv_buffer_[us->recv_buffer_head_slop_ + total_read];
+    us->read_io_buf_ = new IOBuffer(*data_length - total_read);
+    rv = us->transport_->Read(us->read_io_buf_,
+                              *data_length - total_read,
                               &us->io_callback_);
 
-    if (rv > 0) {
+    if (rv >= 0) {
+      memcpy(buffer, us->read_io_buf_->data(), rv);
+      us->read_io_buf_ = NULL;
       total_read += rv;
       us->recv_buffer_tail_slop_ -= rv;
     }
   }
 
   *data_length = total_read;
   if (total_read) {
     memcpy(data, &us->recv_buffer_[us->recv_buffer_head_slop_], total_read);
     if (rv == ERR_IO_PENDING) {
       // We have I/O in flight which is going to land in our buffer. We can't
       // shuffle things around, so we need to just fiddle with pointers.
       us->recv_buffer_head_slop_ += total_read;
     } else {
       us->recv_buffer_.erase(us->recv_buffer_.begin(),
                              us->recv_buffer_.begin() +
                              total_read +
                              us->recv_buffer_head_slop_);
       us->recv_buffer_head_slop_ = 0;
     }
   }
 
   if (rv == ERR_IO_PENDING) {
     us->next_io_state_ = STATE_READ_COMPLETE;
+  } else {
+    us->read_io_buf_ = NULL;
   }
 
   if (rv < 0)
     return OSStatusFromNetError(rv);
 
   return noErr;
 }
 
 // static
 OSStatus SSLClientSocketMac::SSLWriteCallback(SSLConnectionRef connection,
                                               const void* data,
                                               size_t* data_length) {
   SSLClientSocketMac* us =
       const_cast<SSLClientSocketMac*>(
           static_cast<const SSLClientSocketMac*>(connection));
 
   if (us->pending_send_error_ != OK) {
     OSStatus status = OSStatusFromNetError(us->pending_send_error_);
     us->pending_send_error_ = OK;
     return status;
   }
 
   if (data)
     us->send_buffer_.insert(us->send_buffer_.end(),
                             static_cast<const char*>(data),
                             static_cast<const char*>(data) + *data_length);
   int rv;
   do {
-    rv = us->transport_->Write(&us->send_buffer_[0],
+    scoped_refptr<IOBuffer> buffer = new IOBuffer(us->send_buffer_.size());
+    memcpy(buffer->data(), &us->send_buffer_[0], us->send_buffer_.size());
+    rv = us->transport_->Write(buffer,
                                us->send_buffer_.size(),
                                &us->write_callback_);
     if (rv > 0) {
       us->send_buffer_.erase(us->send_buffer_.begin(),
                              us->send_buffer_.begin() + rv);
 
     }
   } while (rv > 0 && !us->send_buffer_.empty());
 
   if (rv < 0 && rv != ERR_IO_PENDING) {
     return OSStatusFromNetError(rv);
   }
 
   // always lie to our caller
   return noErr;
 }
 
 }  // namespace net