Migrate net/socket/socket.h, net/socket/stream_socket.h to base::Bind().

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/bind.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/curvecp/protocol.h"
 
 // Basic protocol design:
 //
 // OnTimeout:    Called when the timeout timer pops.
 //   - call SendMessage()
@@ skipping 34 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_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)) {
+      send_message_in_progress_(false) {
 }
 
 Messenger::~Messenger() {
 }
 
-int Messenger::Read(IOBuffer* buf, int buf_len, OldCompletionCallback* callback) {
-  DCHECK(CalledOnValidThread());
-  DCHECK(!old_receive_complete_callback_ &&
-         receive_complete_callback_.is_null());
-
-  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());
+  DCHECK(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);
   return bytes_read;
 }
 
-int Messenger::Write(IOBuffer* buf, int buf_len, OldCompletionCallback* callback) {
+int Messenger::Write(IOBuffer* buf, int buf_len,
+                     const CompletionCallback& callback) {
   DCHECK(CalledOnValidThread());
   DCHECK(!pending_send_.get());   // Already a write pending!
-  DCHECK(!send_complete_callback_);
+  DCHECK(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.
@@ skipping 40 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 (!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);
+      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 77 matching lines @@
   uint16_pack(header->size.val, data->size());
   uint64_pack(header->position, position);
   // TODO(mbelshe): Fill in rest of the header fields.
   //     needs to have the block-position.  He tags each chunk with an
   //     absolute offset into the data stream.
   // Copy the contents of the message into the Message frame.
   memcpy(message->data() + sizeof(Message), data->data(), data->size());
 
   sent_list_.MarkBlockSent(position, id);
 
-  int rv = packetizer_->SendMessage(key_,
-                                    message->data(),
-                                    padded_size,
-                                    &send_message_callback_);
+  int rv = packetizer_->SendMessage(
+      key_, message->data(), padded_size,
+      base::Bind(&Messenger::OnSendMessageComplete, base::Unretained(this)));
   if (rv == ERR_IO_PENDING) {
     send_message_in_progress_ = true;
     return;
   }
 
   // UDP must write all or none.
   DCHECK_EQ(padded_size, static_cast<size_t>(rv));
   OnSendMessageComplete(rv);
 }
 
@@ skipping 59 matching lines @@
     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() &&
-      (old_receive_complete_callback_ ||
-       !receive_complete_callback_.is_null())) {
+      !receive_complete_callback_.is_null()) {
     // Pass the data up to the caller.
     int bytes_read = InternalRead(pending_receive_, pending_receive_length_);
-    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);
-    }
+    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_);
+  int rv = packetizer_->SendMessage(
+      key_, buffer->data(), sizeof(Message),
+      base::Bind(&Messenger::OnSendMessageComplete, base::Unretained(this)));
   // TODO(mbelshe): Fix me!  Deal with the error cases
   DCHECK(rv == sizeof(Message));
 }
 
 }  // namespace net