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

chrome/browser/chromeos/web_socket_proxy.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 "chrome/browser/chromeos/web_socket_proxy.h"
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
@@ skipping 31 matching lines @@
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/common/url_constants.h"
 #include "googleurl/src/gurl.h"
 #include "googleurl/src/url_parse.h"
 #include "net/base/address_list.h"
 #include "net/base/cert_verifier.h"
-#include "net/base/completion_callback.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/base/ssl_config_service.h"
 #include "net/socket/client_socket_factory.h"
 #include "net/socket/client_socket_handle.h"
 #include "net/socket/ssl_client_socket.h"
 #include "net/socket/stream_socket.h"
 #include "third_party/libevent/evdns.h"
 #include "third_party/libevent/event.h"
@@ skipping 485 matching lines @@
   SSLChan(const net::AddressList address_list,
           const net::HostPortPair host_port_pair,
           int read_pipe,
           int write_pipe)
       : phase_(PHASE_CONNECTING),
         host_port_pair_(host_port_pair),
         inbound_stream_(WebSocketProxy::kBufferLimit),
         outbound_stream_(WebSocketProxy::kBufferLimit),
         read_pipe_(read_pipe),
         write_pipe_(write_pipe),
-        method_factory_(this),
-        ALLOW_THIS_IN_INITIALIZER_LIST(socket_connect_callback_(
-            base::Bind(&SSLChan::OnSocketConnect, base::Unretained(this)))),
-        ALLOW_THIS_IN_INITIALIZER_LIST(ssl_handshake_callback_(
-            base::Bind(&SSLChan::OnSSLHandshakeCompleted,
-                       base::Unretained(this)))),
-        ALLOW_THIS_IN_INITIALIZER_LIST(socket_read_callback_(
-            base::Bind(&SSLChan::OnSocketRead, base::Unretained(this)))),
-        socket_write_callback_(NewCallback(this, &SSLChan::OnSocketWrite)) {
+        method_factory_(this) {
     if (!SetNonBlock(read_pipe_) || !SetNonBlock(write_pipe_)) {
       Shut(net::ERR_UNEXPECTED);
       return;
     }
     net::ClientSocketFactory* factory =
         net::ClientSocketFactory::GetDefaultFactory();
     socket_.reset(factory->CreateTransportClientSocket(
         address_list, NULL, net::NetLog::Source()));
     if (socket_ == NULL) {
       Shut(net::ERR_FAILED);
       return;
     }
-    int result = socket_->Connect(socket_connect_callback_);
+    int result = socket_->Connect(base::Bind(&SSLChan::OnSocketConnect,
+                                             base::Unretained(this)));
     if (result != net::ERR_IO_PENDING)
       OnSocketConnect(result);
   }
 
   ~SSLChan() {
     phase_ = PHASE_CLOSED;
     write_pipe_controller_.StopWatchingFileDescriptor();
     read_pipe_controller_.StopWatchingFileDescriptor();
     close(write_pipe_);
     close(read_pipe_);
@@ skipping 39 matching lines @@
     if (!cert_verifier_.get())
       cert_verifier_.reset(new net::CertVerifier());
     ssl_context.cert_verifier = cert_verifier_.get();
     socket_.reset(factory->CreateSSLClientSocket(
         handle, host_port_pair_, ssl_config_, NULL, ssl_context));
     if (!socket_.get()) {
       LOG(WARNING) << "Failed to create an SSL client socket.";
       OnSSLHandshakeCompleted(net::ERR_UNEXPECTED);
       return;
     }
-    result = socket_->Connect(ssl_handshake_callback_);
+    result = socket_->Connect(base::Bind(&SSLChan::OnSSLHandshakeCompleted,
+                                         base::Unretained(this)));
     if (result != net::ERR_IO_PENDING)
       OnSSLHandshakeCompleted(result);
   }
 
   void OnSSLHandshakeCompleted(int result) {
     if (result) {
       Shut(result);
       return;
     }
     is_socket_read_pending_ = false;
@@ skipping 77 matching lines @@
             DCHECK_LT(rv, 0);
             Shut(net::ERR_UNEXPECTED);
             return;
           }
         }
       }
       if (!is_socket_read_pending_ && phase_ == PHASE_RUNNING) {
         scoped_refptr<net::IOBufferWithSize> buf =
             inbound_stream_.GetIOBufferToFill();
         if (buf && buf->size() > 0) {
-          int rv = socket_->Read(buf, buf->size(), socket_read_callback_);
+          int rv = socket_->Read(
+              buf, buf->size(),
+              base::Bind(&SSLChan::OnSocketRead, base::Unretained(this)));
           is_socket_read_pending_ = true;
           if (rv != net::ERR_IO_PENDING) {
             MessageLoop::current()->PostTask(FROM_HERE,
                 method_factory_.NewRunnableMethod(&SSLChan::OnSocketRead, rv));
           }
         }
       }
       if (!is_socket_write_pending_) {
         scoped_refptr<net::IOBufferWithSize> buf =
             outbound_stream_.GetIOBufferToProcess();
         if (buf && buf->size() > 0) {
           int rv = socket_->Write(
-              buf, buf->size(), socket_write_callback_.get());
+              buf, buf->size(),
+              base::Bind(&SSLChan::OnSocketWrite, base::Unretained(this)));
           is_socket_write_pending_ = true;
           if (rv != net::ERR_IO_PENDING) {
             MessageLoop::current()->PostTask(FROM_HERE,
                 method_factory_.NewRunnableMethod(&SSLChan::OnSocketWrite, rv));
           }
         } else if (phase_ == PHASE_CLOSING) {
           Shut(0);
         }
       }
       if (!is_write_pipe_blocked_) {
@@ skipping 29 matching lines @@
   net::SSLConfig ssl_config_;
   IOBufferQueue inbound_stream_;
   IOBufferQueue outbound_stream_;
   int read_pipe_;
   int write_pipe_;
   bool is_socket_read_pending_;
   bool is_socket_write_pending_;
   bool is_read_pipe_blocked_;
   bool is_write_pipe_blocked_;
   ScopedRunnableMethodFactory<SSLChan> method_factory_;
-  net::CompletionCallback socket_connect_callback_;
-  net::CompletionCallback ssl_handshake_callback_;
-  net::CompletionCallback socket_read_callback_;
-  scoped_ptr<net::OldCompletionCallback> socket_write_callback_;
   MessageLoopForIO::FileDescriptorWatcher read_pipe_controller_;
   MessageLoopForIO::FileDescriptorWatcher write_pipe_controller_;
 
   friend class DeleteTask<SSLChan>;
   DISALLOW_COPY_AND_ASSIGN(SSLChan);
 };
 
 Serv::Serv(const std::vector<std::string>& allowed_origins)
     : allowed_origins_(allowed_origins),
       evbase_(NULL),
@@ skipping 1105 matching lines @@
 
 void WebSocketProxy::Shutdown() {
   static_cast<Serv*>(impl_)->Shutdown();
 }
 
 void WebSocketProxy::OnNetworkChange() {
   static_cast<Serv*>(impl_)->OnNetworkChange();
 }
 
 }  // namespace chromeos