base::Bind: Convert Socket::Read.

remoting/protocol/pepper_transport_socket_adapter.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 "remoting/protocol/pepper_transport_socket_adapter.h"
 
 #include "base/logging.h"
 #include "net/base/address_list.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
@@ skipping 31 matching lines @@
 
 PepperTransportSocketAdapter::PepperTransportSocketAdapter(
     pp::Transport_Dev* transport,
     const std::string& name,
     Observer* observer)
     : name_(name),
       observer_(observer),
       transport_(transport),
       connected_(false),
       get_address_pending_(false),
-      read_callback_(NULL),
+      old_read_callback_(NULL),
       write_callback_(NULL) {
   callback_factory_.Initialize(this);
 }
 
 PepperTransportSocketAdapter::~PepperTransportSocketAdapter() {
   observer_->OnChannelDeleted();
 }
 
 void PepperTransportSocketAdapter::AddRemoteCandidate(
     const std::string& candidate) {
   DCHECK(CalledOnValidThread());
   if (transport_.get())
     transport_->ReceiveRemoteAddress(candidate);
 }
 
 int PepperTransportSocketAdapter::Read(net::IOBuffer* buf, int buf_len,
                                        net::OldCompletionCallback* callback) {
   DCHECK(CalledOnValidThread());
-  DCHECK(!read_callback_);
+  DCHECK(!old_read_callback_ && read_callback_.is_null());
   DCHECK(!read_buffer_);
 
   if (!transport_.get())
+    return net::ERR_SOCKET_NOT_CONNECTED;
+
+  int result = PPErrorToNetError(transport_->Recv(
+      buf->data(), buf_len,
+      callback_factory_.NewOptionalCallback(
+          &PepperTransportSocketAdapter::OnRead)));
+
+  if (result == net::ERR_IO_PENDING) {
+    old_read_callback_ = callback;
+    read_buffer_ = buf;
+  }
+
+  return result;
+}
+int PepperTransportSocketAdapter::Read(
+    net::IOBuffer* buf, int buf_len,
+    const net::CompletionCallback& callback) {
+  DCHECK(CalledOnValidThread());
+  DCHECK(!old_read_callback_ && read_callback_.is_null());
+  DCHECK(!read_buffer_);
+
+  if (!transport_.get())
     return net::ERR_SOCKET_NOT_CONNECTED;
 
   int result = PPErrorToNetError(transport_->Recv(
       buf->data(), buf_len,
       callback_factory_.NewOptionalCallback(
           &PepperTransportSocketAdapter::OnRead)));
 
   if (result == net::ERR_IO_PENDING) {
     read_callback_ = callback;
     read_buffer_ = buf;
@@ skipping 204 matching lines @@
     callback->Run(PPErrorToNetError(result));
   } else {
     net::CompletionCallback callback = connect_callback_;
     connect_callback_.Reset();
     callback.Run(PPErrorToNetError(result));
   }
 }
 
 void PepperTransportSocketAdapter::OnRead(int32_t result) {
   DCHECK(CalledOnValidThread());
-  DCHECK(read_callback_);
+  DCHECK(old_read_callback_ || read_callback_.is_null());
   DCHECK(read_buffer_);
 
-  net::OldCompletionCallback* callback = read_callback_;
-  read_callback_ = NULL;
-  read_buffer_ = NULL;
-  callback->Run(PPErrorToNetError(result));
+  if (old_read_callback_) {
+    net::OldCompletionCallback* callback = old_read_callback_;
+    old_read_callback_ = NULL;
+    read_buffer_ = NULL;
+    callback->Run(PPErrorToNetError(result));
+  } else {
+    net::CompletionCallback callback = read_callback_;
+    read_callback_.Reset();
+    read_buffer_ = NULL;
+    callback.Run(PPErrorToNetError(result));
+  }
 }
 
 void PepperTransportSocketAdapter::OnWrite(int32_t result) {
   DCHECK(CalledOnValidThread());
   DCHECK(write_callback_);
   DCHECK(write_buffer_);
 
   net::OldCompletionCallback* callback = write_callback_;
   write_callback_ = NULL;
   write_buffer_ = NULL;
   callback->Run(PPErrorToNetError(result));
 }
 
 }  // namespace protocol
 }  // namespace remoting