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

remoting/protocol/pepper_transport_socket_adapter.cc

Index: remoting/protocol/pepper_transport_socket_adapter.cc
diff --git a/remoting/protocol/pepper_transport_socket_adapter.cc b/remoting/protocol/pepper_transport_socket_adapter.cc
index 0385b9bbe1f3f7ac3dad894cd4cde7c5642936a7..ca1c4702aef682d1403ba7897fdefa86b1fbcf91 100644
--- a/remoting/protocol/pepper_transport_socket_adapter.cc
+++ b/remoting/protocol/pepper_transport_socket_adapter.cc
@@ -48,9 +48,7 @@ PepperTransportSocketAdapter::PepperTransportSocketAdapter(
       observer_(observer),
       transport_(transport),
       connected_(false),
-      get_address_pending_(false),
-      old_read_callback_(NULL),
-      write_callback_(NULL) {
+      get_address_pending_(false) {
   callback_factory_.Initialize(this);
 }
 
@@ -65,32 +63,11 @@ void PepperTransportSocketAdapter::AddRemoteCandidate(
     transport_->ReceiveRemoteAddress(candidate);
 }
 
-int PepperTransportSocketAdapter::Read(net::IOBuffer* buf, int buf_len,
-                                       net::OldCompletionCallback* 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) {
-    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_callback_.is_null());
   DCHECK(!read_buffer_);
 
   if (!transport_.get())
@@ -109,10 +86,11 @@ int PepperTransportSocketAdapter::Read(
   return result;
 }
 
-int PepperTransportSocketAdapter::Write(net::IOBuffer* buf, int buf_len,
-                                        net::OldCompletionCallback* callback) {
+int PepperTransportSocketAdapter::Write(
+    net::IOBuffer* buf, int buf_len,
+    const net::CompletionCallback& callback) {
   DCHECK(CalledOnValidThread());
-  DCHECK(!write_callback_);
+  DCHECK(write_callback_.is_null());
   DCHECK(!write_buffer_);
 
   if (!transport_.get())
@@ -146,29 +124,6 @@ bool PepperTransportSocketAdapter::SetSendBufferSize(int32 size) {
 }
 
 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());
 
@@ -300,49 +255,36 @@ void PepperTransportSocketAdapter::OnNextAddress(int32_t result) {
 
 void PepperTransportSocketAdapter::OnConnect(int result) {
   DCHECK(CalledOnValidThread());
-  DCHECK(old_connect_callback_ || !connect_callback_.is_null());
+  DCHECK(!connect_callback_.is_null());
 
   if (result == PP_OK)
     connected_ = true;
 
-  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));
-  }
+  net::CompletionCallback callback = connect_callback_;
+  connect_callback_.Reset();
+  callback.Run(PPErrorToNetError(result));
 }
 
 void PepperTransportSocketAdapter::OnRead(int32_t result) {
   DCHECK(CalledOnValidThread());
-  DCHECK(old_read_callback_ || read_callback_.is_null());
+  DCHECK(!read_callback_.is_null());
   DCHECK(read_buffer_);
 
-  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));
-  }
+  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_callback_.is_null());
   DCHECK(write_buffer_);
 
-  net::OldCompletionCallback* callback = write_callback_;
-  write_callback_ = NULL;
+  net::CompletionCallback callback = write_callback_;
+  write_callback_.Reset();
   write_buffer_ = NULL;
-  callback->Run(PPErrorToNetError(result));
+  callback.Run(PPErrorToNetError(result));
 }
 
 }  // namespace protocol