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

net/ftp/ftp_network_transaction.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 "net/ftp/ftp_network_transaction.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/metrics/histogram.h"
@@ skipping 188 matching lines @@
 
 }  // namespace
 
 namespace net {
 
 FtpNetworkTransaction::FtpNetworkTransaction(
     FtpNetworkSession* session,
     ClientSocketFactory* socket_factory)
     : command_sent_(COMMAND_NONE),
       ALLOW_THIS_IN_INITIALIZER_LIST(
-          io_callback_(this, &FtpNetworkTransaction::OnIOComplete)),
-      user_callback_(NULL),
+          io_callback_(base::Bind(&FtpNetworkTransaction::OnIOComplete,
+                                  base::Unretained(this)))),
       session_(session),
       request_(NULL),
       resolver_(session->host_resolver()),
       read_ctrl_buf_(new IOBuffer(kCtrlBufLen)),
       ctrl_response_buffer_(new FtpCtrlResponseBuffer()),
       read_data_buf_len_(0),
       last_error_(OK),
       system_type_(SYSTEM_TYPE_UNKNOWN),
       // Use image (binary) transfer by default. It should always work,
       // whereas the ascii transfer may damage binary data.
@@ skipping 11 matching lines @@
 int FtpNetworkTransaction::Stop(int error) {
   if (command_sent_ == COMMAND_QUIT)
     return error;
 
   next_state_ = STATE_CTRL_WRITE_QUIT;
   last_error_ = error;
   return OK;
 }
 
 int FtpNetworkTransaction::RestartIgnoringLastError(
-    OldCompletionCallback* callback) {
+    const CompletionCallback& callback) {
   return ERR_NOT_IMPLEMENTED;
 }
 
 int FtpNetworkTransaction::Start(const FtpRequestInfo* request_info,
-                                 OldCompletionCallback* callback,
+                                 const CompletionCallback& callback,
                                  const BoundNetLog& net_log) {
   net_log_ = net_log;
   request_ = request_info;
 
   if (request_->url.has_username()) {
     string16 username;
     string16 password;
     GetIdentityFromURL(request_->url, &username, &password);
     credentials_.Set(username, password);
   } else {
     credentials_.Set(ASCIIToUTF16("anonymous"),
                      ASCIIToUTF16("chrome@example.com"));
   }
 
   DetectTypecode();
 
   next_state_ = STATE_CTRL_RESOLVE_HOST;
   int rv = DoLoop(OK);
   if (rv == ERR_IO_PENDING)
     user_callback_ = callback;
   return rv;
 }
 
 int FtpNetworkTransaction::RestartWithAuth(const AuthCredentials& credentials,
-                                           OldCompletionCallback* callback) {
+                                           const CompletionCallback& callback) {
   ResetStateForRestart();
 
   credentials_ = credentials;
 
   next_state_ = STATE_CTRL_RESOLVE_HOST;
   int rv = DoLoop(OK);
   if (rv == ERR_IO_PENDING)
     user_callback_ = callback;
   return rv;
 }
 
 int FtpNetworkTransaction::Read(IOBuffer* buf,
                                 int buf_len,
-                                OldCompletionCallback* callback) {
+                                const CompletionCallback& callback) {
   DCHECK(buf);
   DCHECK_GT(buf_len, 0);
 
   read_data_buf_ = buf;
   read_data_buf_len_ = buf_len;
 
   next_state_ = STATE_DATA_READ;
   int rv = DoLoop(OK);
   if (rv == ERR_IO_PENDING)
     user_callback_ = callback;
@@ skipping 26 matching lines @@
 
   return LOAD_STATE_IDLE;
 }
 
 uint64 FtpNetworkTransaction::GetUploadProgress() const {
   return 0;
 }
 
 void FtpNetworkTransaction::ResetStateForRestart() {
   command_sent_ = COMMAND_NONE;
-  user_callback_ = NULL;
+  user_callback_.Reset();
   response_ = FtpResponseInfo();
   read_ctrl_buf_ = new IOBuffer(kCtrlBufLen);
   ctrl_response_buffer_.reset(new FtpCtrlResponseBuffer());
   read_data_buf_ = NULL;
   read_data_buf_len_ = 0;
   if (write_buf_)
     write_buf_->SetOffset(0);
   last_error_ = OK;
   data_connection_port_ = 0;
   ctrl_socket_.reset();
   data_socket_.reset();
   next_state_ = STATE_NONE;
 }
 
 void FtpNetworkTransaction::DoCallback(int rv) {
   DCHECK(rv != ERR_IO_PENDING);
-  DCHECK(user_callback_);
+  DCHECK(!user_callback_.is_null());
 
   // Since Run may result in Read being called, clear callback_ up front.
-  OldCompletionCallback* c = user_callback_;
-  user_callback_ = NULL;
-  c->Run(rv);
+  CompletionCallback c = user_callback_;
+  user_callback_.Reset();
+  c.Run(rv);
 }
 
 void FtpNetworkTransaction::OnIOComplete(int result) {
   int rv = DoLoop(result);
   if (rv != ERR_IO_PENDING)
     DoCallback(rv);
 }
 
 int FtpNetworkTransaction::ProcessCtrlResponse() {
   FtpCtrlResponse response = ctrl_response_buffer_->PopResponse();
@@ skipping 272 matching lines @@
 int FtpNetworkTransaction::DoCtrlResolveHostComplete(int result) {
   if (result == OK)
     next_state_ = STATE_CTRL_CONNECT;
   return result;
 }
 
 int FtpNetworkTransaction::DoCtrlConnect() {
   next_state_ = STATE_CTRL_CONNECT_COMPLETE;
   ctrl_socket_.reset(socket_factory_->CreateTransportClientSocket(
         addresses_, net_log_.net_log(), net_log_.source()));
-  return ctrl_socket_->Connect(&io_callback_);
+  return ctrl_socket_->Connect(io_callback_);
 }
 
 int FtpNetworkTransaction::DoCtrlConnectComplete(int result) {
   if (result == OK) {
     // Put the peer's IP address and port into the response.
     AddressList address;
     result = ctrl_socket_->GetPeerAddress(&address);
     if (result == OK) {
       response_.socket_address = HostPortPair::FromAddrInfo(address.head());
       next_state_ = STATE_CTRL_READ;
     }
   }
   return result;
 }
 
 int FtpNetworkTransaction::DoCtrlRead() {
   next_state_ = STATE_CTRL_READ_COMPLETE;
-  return ctrl_socket_->Read(
-      read_ctrl_buf_,
-      kCtrlBufLen,
-      &io_callback_);
+  return ctrl_socket_->Read(read_ctrl_buf_, kCtrlBufLen, io_callback_);
 }
 
 int FtpNetworkTransaction::DoCtrlReadComplete(int result) {
   if (result == 0) {
     // Some servers (for example Pure-FTPd) apparently close the control
     // connection when anonymous login is not permitted. For more details
     // see http://crbug.com/25023.
     if (command_sent_ == COMMAND_USER &&
         credentials_.username() == ASCIIToUTF16("anonymous")) {
       response_.needs_auth = true;
@@ skipping 12 matching lines @@
   }
 
   return ProcessCtrlResponse();
 }
 
 int FtpNetworkTransaction::DoCtrlWrite() {
   next_state_ = STATE_CTRL_WRITE_COMPLETE;
 
   return ctrl_socket_->Write(write_buf_,
                              write_buf_->BytesRemaining(),
-                             &io_callback_);
+                             io_callback_);
 }
 
 int FtpNetworkTransaction::DoCtrlWriteComplete(int result) {
   if (result < 0)
     return result;
 
   write_buf_->DidConsume(result);
   if (write_buf_->BytesRemaining() == 0) {
     // Clear the write buffer.
     write_buf_ = NULL;
@@ skipping 480 matching lines @@
   next_state_ = STATE_DATA_CONNECT_COMPLETE;
   AddressList data_address;
   // Connect to the same host as the control socket to prevent PASV port
   // scanning attacks.
   int rv = ctrl_socket_->GetPeerAddress(&data_address);
   if (rv != OK)
     return Stop(rv);
   data_address.SetPort(data_connection_port_);
   data_socket_.reset(socket_factory_->CreateTransportClientSocket(
         data_address, net_log_.net_log(), net_log_.source()));
-  return data_socket_->Connect(&io_callback_);
+  return data_socket_->Connect(io_callback_);
 }
 
 int FtpNetworkTransaction::DoDataConnectComplete(int result) {
   if (result != OK && use_epsv_) {
     // It's possible we hit a broken server, sadly. They can break in different
     // ways. Some time out, some reset a connection. Fall back to PASV.
     // TODO(phajdan.jr): remember it for future transactions with this server.
     // TODO(phajdan.jr): write a test for this code path.
     use_epsv_ = false;
     next_state_ = STATE_CTRL_WRITE_PASV;
@@ skipping 26 matching lines @@
       next_state_ = STATE_CTRL_READ;
       return OK;
     }
 
     // We are no longer connected to the server, so just finish the transaction.
     return Stop(OK);
   }
 
   next_state_ = STATE_DATA_READ_COMPLETE;
   read_data_buf_->data()[0] = 0;
-  return data_socket_->Read(read_data_buf_, read_data_buf_len_,
-                            &io_callback_);
+  return data_socket_->Read(read_data_buf_, read_data_buf_len_, io_callback_);
 }
 
 int FtpNetworkTransaction::DoDataReadComplete(int result) {
   return result;
 }
 
 // We're using a histogram as a group of counters, with one bucket for each
 // enumeration value.  We're only interested in the values of the counters.
 // Ignore the shape, average, and standard deviation of the histograms because
 // they are meaningless.
@@ skipping 75 matching lines @@
   if (!had_error_type[type]) {
     had_error_type[type] = true;
     UMA_HISTOGRAM_ENUMERATION("Net.FtpDataConnectionErrorHappened",
         type, NUM_OF_NET_ERROR_TYPES);
   }
   UMA_HISTOGRAM_ENUMERATION("Net.FtpDataConnectionErrorCount",
       type, NUM_OF_NET_ERROR_TYPES);
 }
 
 }  // namespace net