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

net/base/ssl_client_socket_nss.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/ssl_client_socket_nss.h"
 
 #include <nspr.h>
 #include <nss.h>
 #include <secerr.h>
 // Work around https://bugzilla.mozilla.org/show_bug.cgi?id=455424
@@ skipping 87 matching lines @@
     :
       buffer_send_callback_(this, &SSLClientSocketNSS::BufferSendComplete),
       buffer_recv_callback_(this, &SSLClientSocketNSS::BufferRecvComplete),
       transport_send_busy_(false),
       transport_recv_busy_(false),
       io_callback_(this, &SSLClientSocketNSS::OnIOComplete),
       transport_(transport_socket),
       hostname_(hostname),
       ssl_config_(ssl_config),
       user_callback_(NULL),
-      user_buf_(NULL),
       user_buf_len_(0),
       server_cert_error_(0),
       completed_handshake_(false),
       next_state_(STATE_NONE),
       nss_fd_(NULL),
       nss_bufs_(NULL) {
   EnterFunction("");
 }
 
 SSLClientSocketNSS::~SSLClientSocketNSS() {
@@ skipping 191 matching lines @@
   // 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.
   EnterFunction("");
   bool ret = completed_handshake_ && transport_->IsConnectedAndIdle();
   LeaveFunction("");
   return ret;
 }
 
-int SSLClientSocketNSS::Read(char* buf, int buf_len,
+int SSLClientSocketNSS::Read(IOBuffer* buf, int buf_len,
                              CompletionCallback* callback) {
   EnterFunction(buf_len);
   DCHECK(completed_handshake_);
   DCHECK(next_state_ == STATE_NONE);
   DCHECK(!user_callback_);
   DCHECK(!user_buf_);
 
   user_buf_ = buf;
   user_buf_len_ = buf_len;
 
   GotoState(STATE_PAYLOAD_READ);
   int rv = DoLoop(OK);
   if (rv == ERR_IO_PENDING)
     user_callback_ = callback;
   LeaveFunction(rv);
   return rv;
 }
 
-int SSLClientSocketNSS::Write(const char* buf, int buf_len,
+int SSLClientSocketNSS::Write(IOBuffer* buf, int buf_len,
                            CompletionCallback* callback) {
   EnterFunction(buf_len);
   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;
 
   GotoState(STATE_PAYLOAD_WRITE);
   int rv = DoLoop(OK);
   if (rv == ERR_IO_PENDING)
     user_callback_ = callback;
   LeaveFunction(rv);
   return rv;
 }
 
@@ skipping 40 matching lines @@
 }
 
 void SSLClientSocketNSS::DoCallback(int rv) {
   EnterFunction(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);
   LeaveFunction("");
 }
 
 void SSLClientSocketNSS::OnIOComplete(int result) {
   EnterFunction(result);
   int rv = DoLoop(result);
   if (rv != ERR_IO_PENDING && user_callback_ != NULL)
     DoCallback(rv);
   LeaveFunction("");
 }
 
 // Map a Chromium net error code to an NSS error code
 // See _MD_unix_map_default_error in the NSS source
 // tree for inspiration.
 static PRErrorCode MapErrorToNSS(int result) {
   if (result >=0)
     return result;
   // TODO(port): add real table
   LOG(ERROR) << "MapErrorToNSS " << result;
   return PR_UNKNOWN_ERROR;
 }
 
-/*
- * Do network I/O between the given buffer and the given socket.
- * Return 0 for EOF,
- * > 0 for bytes transferred immediately,
- * < 0 for error (or the non-error ERR_IO_PENDING).
- */
+// Do network I/O between the given buffer and the given socket.
+// Return 0 for EOF,
+// > 0 for bytes transferred immediately,
+// < 0 for error (or the non-error ERR_IO_PENDING).
 int SSLClientSocketNSS::BufferSend(void) {
   if (transport_send_busy_) return ERR_IO_PENDING;
 
   const char *buf;
   int nb = memio_GetWriteParams(nss_bufs_, &buf);
   EnterFunction(nb);
 
   int rv;
   if (!nb) {
     rv = OK;
   } else {
-    rv = transport_->Write(buf, nb, &buffer_send_callback_);
+    scoped_refptr<IOBuffer> send_buffer = new IOBuffer(nb);
+    memcpy(send_buffer->data(), buf, nb);
+    rv = transport_->Write(send_buffer, nb, &buffer_send_callback_);
     if (rv == ERR_IO_PENDING)
       transport_send_busy_ = true;
     else
       memio_PutWriteResult(nss_bufs_, MapErrorToNSS(rv));
   }
 
   LeaveFunction(rv);
   return rv;
 }
 
@@ skipping 10 matching lines @@
   if (transport_recv_busy_) return ERR_IO_PENDING;
 
   char *buf;
   int nb = memio_GetReadParams(nss_bufs_, &buf);
   EnterFunction(nb);
   int rv;
   if (!nb) {
     // buffer too full to read into, so no I/O possible at moment
     rv = ERR_IO_PENDING;
   } else {
-    rv = transport_->Read(buf, nb, &buffer_recv_callback_);
-    if (rv == ERR_IO_PENDING)
+    recv_buffer_ = new IOBuffer(nb);
+    rv = transport_->Read(recv_buffer_, nb, &buffer_recv_callback_);
+    if (rv == ERR_IO_PENDING) {
       transport_recv_busy_ = true;
-    else
+    } else {
+      if (rv > 0)
+        memcpy(buf, recv_buffer_->data(), rv);
       memio_PutReadResult(nss_bufs_, MapErrorToNSS(rv));
+      recv_buffer_ = NULL;
+    }
   }
   LeaveFunction(rv);
   return rv;
 }
 
 void SSLClientSocketNSS::BufferRecvComplete(int result) {
   EnterFunction(result);
+  if (result > 0) {
+    char *buf;
+    memio_GetReadParams(nss_bufs_, &buf);
+    memcpy(buf, recv_buffer_->data(), result);
+  }
+  recv_buffer_ = NULL;
   memio_PutReadResult(nss_bufs_, result);
   transport_recv_busy_ = false;
   OnIOComplete(result);
   LeaveFunction("");
 }
 
 int SSLClientSocketNSS::DoLoop(int last_io_result) {
   EnterFunction(last_io_result);
   bool network_moved;
   int rv = last_io_result;
@@ skipping 99 matching lines @@
                  << ", net_error " << net_error;
     }
   }
 
   LeaveFunction("");
   return net_error;
 }
 
 int SSLClientSocketNSS::DoPayloadRead() {
   EnterFunction(user_buf_len_);
-  int rv = PR_Read(nss_fd_, user_buf_, user_buf_len_);
+  int rv = PR_Read(nss_fd_, user_buf_->data(), user_buf_len_);
   if (rv >= 0) {
-    LogData(user_buf_, rv);
+    LogData(user_buf_->data(), rv);
     user_buf_ = NULL;
     LeaveFunction("");
     return rv;
   }
   PRErrorCode prerr = PR_GetError();
   if (prerr == PR_WOULD_BLOCK_ERROR) {
     GotoState(STATE_PAYLOAD_READ);
     LeaveFunction("");
     return ERR_IO_PENDING;
   }
   user_buf_ = NULL;
   LeaveFunction("");
   return NetErrorFromNSPRError(prerr);
 }
 
 int SSLClientSocketNSS::DoPayloadWrite() {
   EnterFunction(user_buf_len_);
-  int rv = PR_Write(nss_fd_, user_buf_, user_buf_len_);
+  int rv = PR_Write(nss_fd_, user_buf_->data(), user_buf_len_);
   if (rv >= 0) {
-    LogData(user_buf_, rv);
+    LogData(user_buf_->data(), rv);
     user_buf_ = NULL;
     LeaveFunction("");
     return rv;
   }
   PRErrorCode prerr = PR_GetError();
   if (prerr == PR_WOULD_BLOCK_ERROR) {
     GotoState(STATE_PAYLOAD_WRITE);
     return ERR_IO_PENDING;
   }
   user_buf_ = NULL;
   LeaveFunction("");
   return NetErrorFromNSPRError(prerr);
 }
 
 }  // namespace net