base::Bind: Convert StreamSocket::Connect.

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 105 matching lines @@
   return false;
 }
 
 bool PepperTransportSocketAdapter::SetSendBufferSize(int32 size) {
   DCHECK(CalledOnValidThread());
   // TODO(sergeyu): Implement this: crbug.com/91439.
   NOTIMPLEMENTED();
   return false;
 }
 
-int PepperTransportSocketAdapter::Connect(net::OldCompletionCallback* callback) {
+int PepperTransportSocketAdapter::Connect(
+    net::OldCompletionCallback* callback) {
   DCHECK(CalledOnValidThread());
 
   if (!transport_.get())
+    return net::ERR_UNEXPECTED;
+
+  old_connect_callback_ = callback;
+
+  // This will return false when GetNextAddress() returns an
+  // error. This helps to detect when the P2P Transport API is not
+  // supported.
+  int result = ProcessCandidates();
+  if (result != net::OK)
+    return result;
+
+  result = transport_->Connect(
+      callback_factory_.NewRequiredCallback(
+          &PepperTransportSocketAdapter::OnConnect));
+  DCHECK_EQ(result, PP_OK_COMPLETIONPENDING);
+
+  return net::ERR_IO_PENDING;
+}
+int PepperTransportSocketAdapter::Connect(
+    const net::CompletionCallback& callback) {
+  DCHECK(CalledOnValidThread());
+
+  if (!transport_.get())
     return net::ERR_UNEXPECTED;
 
   connect_callback_ = callback;
 
   // This will return false when GetNextAddress() returns an
   // error. This helps to detect when the P2P Transport API is not
   // supported.
   int result = ProcessCandidates();
   if (result != net::OK)
     return result;
@@ skipping 107 matching lines @@
 
 void PepperTransportSocketAdapter::OnNextAddress(int32_t result) {
   DCHECK(CalledOnValidThread());
 
   get_address_pending_ = false;
   ProcessCandidates();
 }
 
 void PepperTransportSocketAdapter::OnConnect(int result) {
   DCHECK(CalledOnValidThread());
-  DCHECK(connect_callback_);
+  DCHECK(old_connect_callback_ || !connect_callback_.is_null());
 
   if (result == PP_OK)
     connected_ = true;
 
-  net::OldCompletionCallback* callback = connect_callback_;
-  connect_callback_ = NULL;
-  callback->Run(PPErrorToNetError(result));
+  if (old_connect_callback_) {
+    net::OldCompletionCallback* callback = old_connect_callback_;
+    old_connect_callback_ = NULL;
+    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(read_buffer_);
 
   net::OldCompletionCallback* callback = read_callback_;
   read_callback_ = NULL;
   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