base::Bind: Convert Socket::Read.

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 41 matching lines @@
 
 // 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),
-      receive_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() {
 }
 
 int Messenger::Read(IOBuffer* buf, int buf_len, OldCompletionCallback* callback) {
   DCHECK(CalledOnValidThread());
-  DCHECK(!receive_complete_callback_);
+  DCHECK(!old_receive_complete_callback_);

[csilv, 2011/12/07 00:03:48]

change this to match line 91

[James Hawkins, 2011/12/07 00:19:37]

Done.

+
+  if (!received_list_.bytes_available()) {
+    old_receive_complete_callback_ = callback;
+    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::Read(IOBuffer* buf, int buf_len,
+                    const CompletionCallback& callback) {
+  DCHECK(CalledOnValidThread());
+  DCHECK(!old_receive_complete_callback_ &&
+         receive_complete_callback_.is_null());
 
   if (!received_list_.bytes_available()) {
     receive_complete_callback_ = callback;
     pending_receive_ = buf;
     pending_receive_length_ = buf_len;
     return ERR_IO_PENDING;
   }
 
   int bytes_read = InternalRead(buf, buf_len);
   DCHECK_LT(0, bytes_read);
@@ skipping 245 matching lines @@
     // Add to our received block list
     uint64 position = uint64_unpack(header->position);
     scoped_refptr<IOBuffer> buffer(new IOBuffer(body_length));
     memcpy(buffer->data(), message->data() + sizeof(Message), body_length);
     received_list_.AddBlock(position, buffer, body_length);
 
     SendAck(message_id);
   }
 
   // If we have data available, and a read is pending, notify the callback.
-  if (received_list_.bytes_available() && receive_complete_callback_) {
+  if (received_list_.bytes_available() &&
+      (old_receive_complete_callback_ ||
+       !receive_complete_callback_.is_null())) {
     // Pass the data up to the caller.
     int bytes_read = InternalRead(pending_receive_, pending_receive_length_);
-    OldCompletionCallback* callback = receive_complete_callback_;
-    receive_complete_callback_ = NULL;
-    callback->Run(bytes_read);
+    if (old_receive_complete_callback_) {
+      OldCompletionCallback* callback = old_receive_complete_callback_;
+      old_receive_complete_callback_ = NULL;
+      callback->Run(bytes_read);
+    } else {
+      CompletionCallback callback = receive_complete_callback_;
+      receive_complete_callback_.Reset();
+      callback.Run(bytes_read);
+    }
   }
 }
 
 void Messenger::SendAck(uint32 last_message_received) {
   scoped_refptr<IOBuffer> buffer(new IOBuffer(sizeof(Message)));
   memset(buffer->data(), 0, sizeof(Message));
   Message* message = reinterpret_cast<Message*>(buffer->data());
   uint32_pack(message->last_message_received, last_message_received);
   uint64_pack(message->acknowledge_1, received_list_.bytes_received());
   LOG(ERROR) << "SendAck " << received_list_.bytes_received();
   // TODO(mbelshe): fill in remainder of selective acknowledgements
 
   // TODO(mbelshe): Fix this - it is totally possible to have a send message
   //                in progress here...
   DCHECK(!send_message_in_progress_);
 
   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