If a write is pending, just add it to the buffer. Don't trigger a second conc...

net/socket/ssl_client_socket_mac.cc

 // Copyright (c) 2008-2009 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/socket/ssl_client_socket_mac.h"
 
 #include "base/singleton.h"
 #include "base/string_util.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
@@ skipping 718 matching lines @@
   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;
   }
 
+  bool send_pending = !us->send_buffer_.empty();
+
   if (data)
     us->send_buffer_.insert(us->send_buffer_.end(),
                             static_cast<const char*>(data),
                             static_cast<const char*>(data) + *data_length);
+
+  if (send_pending) {
+    // If we have I/O in flight, just add the data to the end of the buffer and
+    // return to our caller. The existing callback will trigger the write of the
+    // new data when it sees that data remains in the buffer after removing the
+    // sent data.
+    return noErr;

[wtc, 2009/07/29 18:05:17]

Perhaps you can reproduce the "always lie to our caller"
comment here.  I wondered whether we should return noErr
or a would-block/io-pending error.

[Avi (use Gerrit), 2009/07/29 18:22:41]

Sure.

We can't return would-block. The caller wants to know how much is written and
we'd have no idea what to return.

+  }
+
   int rv;
   do {
     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