base::Bind: Convert Socket::Read.

remoting/jingle_glue/ssl_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/jingle_glue/ssl_socket_adapter.h"
 
 #include "base/base64.h"
 #include "base/compiler_specific.h"
 #include "base/message_loop.h"
 #include "jingle/glue/utils.h"
@@ skipping 169 matching lines @@
     int result = BeginSSL();
     if (0 != result) {
       // TODO(zork): Handle this case gracefully.
       LOG(WARNING) << "BeginSSL() failed with " << result;
     }
   }
 }
 
 TransportSocket::TransportSocket(talk_base::AsyncSocket* socket,
                                  SSLSocketAdapter *ssl_adapter)
-    : read_callback_(NULL),
+    : old_read_callback_(NULL),
       write_callback_(NULL),
       read_buffer_len_(0),
       write_buffer_len_(0),
       socket_(socket),
       was_used_to_convey_data_(false) {
   socket_->SignalReadEvent.connect(this, &TransportSocket::OnReadEvent);
   socket_->SignalWriteEvent.connect(this, &TransportSocket::OnWriteEvent);
 }
 
 TransportSocket::~TransportSocket() {
@@ skipping 82 matching lines @@
 }
 
 base::TimeDelta TransportSocket::GetConnectTimeMicros() const {
   NOTREACHED();
   return base::TimeDelta::FromMicroseconds(-1);
 }
 
 int TransportSocket::Read(net::IOBuffer* buf, int buf_len,
                           net::OldCompletionCallback* callback) {
   DCHECK(buf);
-  DCHECK(!read_callback_);
+  DCHECK(!old_read_callback_ && read_callback_.is_null());
   DCHECK(!read_buffer_.get());
   int result = socket_->Recv(buf->data(), buf_len);
   if (result < 0) {
+    result = net::MapSystemError(socket_->GetError());
+    if (result == net::ERR_IO_PENDING) {
+      old_read_callback_ = callback;
+      read_buffer_ = buf;
+      read_buffer_len_ = buf_len;
+    }
+  }
+  if (result != net::ERR_IO_PENDING)
+    was_used_to_convey_data_ = true;
+  return result;
+}
+int TransportSocket::Read(net::IOBuffer* buf, int buf_len,
+                          const net::CompletionCallback& callback) {
+  DCHECK(buf);
+  DCHECK(!old_read_callback_ && read_callback_.is_null());
+  DCHECK(!read_buffer_.get());
+  int result = socket_->Recv(buf->data(), buf_len);
+  if (result < 0) {
     result = net::MapSystemError(socket_->GetError());
     if (result == net::ERR_IO_PENDING) {
       read_callback_ = callback;
       read_buffer_ = buf;
       read_buffer_len_ = buf_len;
     }
   }
   if (result != net::ERR_IO_PENDING)
     was_used_to_convey_data_ = true;
   return result;
@@ skipping 22 matching lines @@
   // Not implemented.
   return false;
 }
 
 bool TransportSocket::SetSendBufferSize(int32 size) {
   // Not implemented.
   return false;
 }
 
 void TransportSocket::OnReadEvent(talk_base::AsyncSocket* socket) {
-  if (read_callback_) {
+  if (old_read_callback_ || !read_callback_.is_null()) {
     DCHECK(read_buffer_.get());
-    net::OldCompletionCallback* callback = read_callback_;
+    net::OldCompletionCallback* old_callback = old_read_callback_;
+    net::CompletionCallback callback = read_callback_;
     scoped_refptr<net::IOBuffer> buffer = read_buffer_;
     int buffer_len = read_buffer_len_;
 
-    read_callback_ = NULL;
+    old_read_callback_ = NULL;
+    read_callback_.Reset();
     read_buffer_ = NULL;
     read_buffer_len_ = 0;
 
     int result = socket_->Recv(buffer->data(), buffer_len);
     if (result < 0) {
       result = net::MapSystemError(socket_->GetError());
       if (result == net::ERR_IO_PENDING) {
+        old_read_callback_ = old_callback;
         read_callback_ = callback;
         read_buffer_ = buffer;
         read_buffer_len_ = buffer_len;
         return;
       }
     }
     was_used_to_convey_data_ = true;
-    callback->RunWithParams(Tuple1<int>(result));
+    if (old_callback)
+      old_callback->RunWithParams(Tuple1<int>(result));
+    else
+      callback.Run(result);
   }
 }
 
 void TransportSocket::OnWriteEvent(talk_base::AsyncSocket* socket) {
   if (write_callback_) {
     DCHECK(write_buffer_.get());
     net::OldCompletionCallback* callback = write_callback_;
     scoped_refptr<net::IOBuffer> buffer = write_buffer_;
     int buffer_len = write_buffer_len_;
 
@@ skipping 10 matching lines @@
         write_buffer_len_ = buffer_len;
         return;
       }
     }
     was_used_to_convey_data_ = true;
     callback->RunWithParams(Tuple1<int>(result));
   }
 }
 
 }  // namespace remoting