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

remoting/protocol/v1_host_channel_authenticator.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/v1_host_channel_authenticator.h"
 
 #include "crypto/rsa_private_key.h"
 #include "crypto/secure_util.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/base/ssl_config_service.h"
 #include "net/base/x509_certificate.h"
 #include "net/socket/ssl_server_socket.h"
 #include "remoting/protocol/auth_util.h"
 
 namespace remoting {
 namespace protocol {
 
 V1HostChannelAuthenticator::V1HostChannelAuthenticator(
     const std::string& local_cert,
     crypto::RSAPrivateKey* local_private_key,
     const std::string& shared_secret)
     : local_cert_(local_cert),
       local_private_key_(local_private_key),
       shared_secret_(shared_secret),
       socket_(NULL),
       ALLOW_THIS_IN_INITIALIZER_LIST(connect_callback_(
-          this, &V1HostChannelAuthenticator::OnConnected)),
-      ALLOW_THIS_IN_INITIALIZER_LIST(auth_read_callback_(
-          this, &V1HostChannelAuthenticator::OnAuthBytesRead)) {
+          this, &V1HostChannelAuthenticator::OnConnected)) {
 }
 
 V1HostChannelAuthenticator::~V1HostChannelAuthenticator() {
 }
 
 void V1HostChannelAuthenticator::SecureAndAuthenticate(
     net::StreamSocket* socket, const DoneCallback& done_callback) {
   DCHECK(CalledOnValidThread());
 
   scoped_ptr<net::StreamSocket> channel_socket(socket);
@@ skipping 26 matching lines @@
   }
 
   // Read an authentication digest.
   auth_read_buf_ = new net::GrowableIOBuffer();
   auth_read_buf_->SetCapacity(kAuthDigestLength);
   DoAuthRead();
 }
 
 void V1HostChannelAuthenticator::DoAuthRead(){
   while (true) {
-    int result = socket_->Read(auth_read_buf_,
-                               auth_read_buf_->RemainingCapacity(),
-                               &auth_read_callback_);
+    int result = socket_->Read(
+        auth_read_buf_,
+        auth_read_buf_->RemainingCapacity(),
+        base::Bind(&V1HostChannelAuthenticator::OnAuthBytesRead,
+                   base::Unretained(this)));
     if (result == net::ERR_IO_PENDING)
       break;
     if (!HandleAuthBytesRead(result))
       break;
   }
 }
 
 void V1HostChannelAuthenticator::OnAuthBytesRead(int result) {
   DCHECK(CalledOnValidThread());
 
@@ skipping 43 matching lines @@
     done_callback_.Run(net::ERR_FAILED, NULL);
     return false;
   }
 
   return crypto::SecureMemEqual(received_auth_bytes.data(),
                                 &(auth_bytes[0]), kAuthDigestLength);
 }
 
 }  // namespace protocol
 }  // namespace remoting