base::Bind: Convert Socket::Write.

net/curvecp/messenger.cc

 // Copyright (c) 2011 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/curvecp/messenger.h"
 
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
@@ skipping 40 matching lines @@
 static const size_t kMaxWriteQueueMessages = 128;
 
 // Size of the send buffer.
 static const size_t kSendBufferSize = (128 * 1024);
 // Size of the receive buffer.
 static const size_t kReceiveBufferSize = (128 * 1024);
 
 Messenger::Messenger(Packetizer* packetizer)
     : packetizer_(packetizer),
       send_buffer_(kSendBufferSize),
-      send_complete_callback_(NULL),
+      old_send_complete_callback_(NULL),
       old_receive_complete_callback_(NULL),
       pending_receive_length_(0),
       send_message_in_progress_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           send_message_callback_(this, &Messenger::OnSendMessageComplete)),
       ALLOW_THIS_IN_INITIALIZER_LIST(factory_(this)) {
 }
 
 Messenger::~Messenger() {
 }
@@ skipping 25 matching lines @@
     pending_receive_ = buf;
     pending_receive_length_ = buf_len;
     return ERR_IO_PENDING;
   }
 
   int bytes_read = InternalRead(buf, buf_len);
   DCHECK_LT(0, bytes_read);
   return bytes_read;
 }
 
-int Messenger::Write(IOBuffer* buf, int buf_len, OldCompletionCallback* callback) {
+int Messenger::Write(
+    IOBuffer* buf, int buf_len, OldCompletionCallback* callback) {
   DCHECK(CalledOnValidThread());
   DCHECK(!pending_send_.get());   // Already a write pending!
-  DCHECK(!send_complete_callback_);
+  DCHECK(!old_send_complete_callback_ && send_complete_callback_.is_null());
   DCHECK_LT(0, buf_len);
 
   int len = send_buffer_.write(buf->data(), buf_len);
+  if (!send_timer_.IsRunning())
+    send_timer_.Start(FROM_HERE, base::TimeDelta(),
+                      this, &Messenger::OnSendTimer);
+  if (len)
+    return len;
+
+  // We couldn't add data to the send buffer, so block the application.
+  pending_send_ = buf;
+  pending_send_length_ = buf_len;
+  old_send_complete_callback_ = callback;
+  return ERR_IO_PENDING;
+}
+int Messenger::Write(
+    IOBuffer* buf, int buf_len, const CompletionCallback& callback) {
+  DCHECK(CalledOnValidThread());
+  DCHECK(!pending_send_.get());   // Already a write pending!
+  DCHECK(!old_send_complete_callback_ && send_complete_callback_.is_null());
+  DCHECK_LT(0, buf_len);
+
+  int len = send_buffer_.write(buf->data(), buf_len);
   if (!send_timer_.IsRunning())
     send_timer_.Start(FROM_HERE, base::TimeDelta(),
                       this, &Messenger::OnSendTimer);
   if (len)
     return len;
 
   // We couldn't add data to the send buffer, so block the application.
   pending_send_ = buf;
   pending_send_length_ = buf_len;
   send_complete_callback_ = callback;
@@ skipping 37 matching lines @@
 IOBufferWithSize* Messenger::CreateBufferFromSendQueue() {
   DCHECK_LT(0, send_buffer_.length());
 
   int length = std::min(packetizer_->max_message_payload(),
                         send_buffer_.length());
   IOBufferWithSize* rv = new IOBufferWithSize(length);
   int bytes = send_buffer_.read(rv->data(), length);
   DCHECK_EQ(bytes, length);
 
   // We consumed data, check to see if someone is waiting to write more data.
-  if (send_complete_callback_) {
+  if (old_send_complete_callback_ || !send_complete_callback_.is_null()) {
     DCHECK(pending_send_.get());
 
     int len = send_buffer_.write(pending_send_->data(), pending_send_length_);
     if (len) {
       pending_send_ = NULL;
-      OldCompletionCallback* callback = send_complete_callback_;
-      send_complete_callback_ = NULL;
-      callback->Run(len);
+      if (old_send_complete_callback_) {
+        OldCompletionCallback* callback = old_send_complete_callback_;
+        old_send_complete_callback_ = NULL;
+        callback->Run(len);
+      } else {
+        CompletionCallback callback = send_complete_callback_;
+        send_complete_callback_.Reset();
+        callback.Run(len);
+      }
     }
   }
 
   return rv;
 }
 
 void Messenger::OnSendMessageComplete(int result) {
   DCHECK_NE(ERR_IO_PENDING, result);
 
   send_message_in_progress_ = false;
@@ skipping 198 matching lines @@
 
   int rv = packetizer_->SendMessage(key_,
                                     buffer->data(),
                                     sizeof(Message),
                                     &send_message_callback_);
   // TODO(mbelshe): Fix me!  Deal with the error cases
   DCHECK(rv == sizeof(Message));
 }
 
 }  // namespace net