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

net/http/http_stream_parser.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/http/http_stream_parser.h"
 
 #include "base/compiler_specific.h"
 #include "base/metrics/histogram.h"
 #include "base/stringprintf.h"
 #include "base/string_util.h"
@@ skipping 63 matching lines @@
       response_header_start_offset_(-1),
       response_body_length_(-1),
       response_body_read_(0),
       chunked_decoder_(NULL),
       user_read_buf_(NULL),
       user_read_buf_len_(0),
       user_callback_(NULL),
       connection_(connection),
       net_log_(net_log),
       ALLOW_THIS_IN_INITIALIZER_LIST(
-          io_callback_(this, &HttpStreamParser::OnIOComplete)),
+          io_callback_(
+              base::Bind(&HttpStreamParser::OnIOComplete,
+                         base::Unretained(this)))),
       chunk_length_(0),
       chunk_length_without_encoding_(0),
       sent_last_chunk_(false) {
 }
 
 HttpStreamParser::~HttpStreamParser() {
   if (request_body_ != NULL && request_body_->is_chunked())
     request_body_->set_chunk_callback(NULL);
 }
 
@@ skipping 212 matching lines @@
             coalesce = static_cast<size_t>(header_packets + body_packets);
         } else {
           coalesce = NO_ADVANTAGE;
         }
       }
       UMA_HISTOGRAM_ENUMERATION("Net.CoalescePotential", coalesce,
                                 COALESCE_POTENTIAL_MAX);
     }
     result = connection_->socket()->Write(request_headers_,
                                           bytes_remaining,
-                                          &io_callback_);
+                                          io_callback_);
   } else if (request_body_ != NULL &&
              (request_body_->is_chunked() || request_body_->size())) {
     io_state_ = STATE_SENDING_BODY;
     result = OK;
   } else {
     io_state_ = STATE_REQUEST_SENT;
   }
   return result;
 }
 
 int HttpStreamParser::DoSendBody(int result) {
   if (request_body_->is_chunked()) {
     chunk_length_ -= result;
     if (chunk_length_) {
       memmove(chunk_buf_->data(), chunk_buf_->data() + result, chunk_length_);
       return connection_->socket()->Write(chunk_buf_, chunk_length_,
-                                          &io_callback_);
+                                          io_callback_);
     }
 
     if (sent_last_chunk_) {
       io_state_ = STATE_REQUEST_SENT;
       return OK;
     }
 
     request_body_->MarkConsumedAndFillBuffer(chunk_length_without_encoding_);
     chunk_length_without_encoding_ = 0;
     chunk_length_ = 0;
@@ skipping 14 matching lines @@
       chunk_ptr += buf_len;
       memcpy(chunk_ptr, "\r\n", 2);
       chunk_length_without_encoding_ = buf_len;
       chunk_length_ = chunk_header.length() + buf_len + 2;
     }
 
     if (!chunk_length_)  // More POST data is yet to come?
       return ERR_IO_PENDING;
 
     return connection_->socket()->Write(chunk_buf_, chunk_length_,
-                                        &io_callback_);
+                                        io_callback_);
   }
 
   // Non-chunked request body.
   request_body_->MarkConsumedAndFillBuffer(result);
 
   if (!request_body_->eof()) {
     int buf_len = static_cast<int>(request_body_->buf_len());
     result = connection_->socket()->Write(request_body_->buf(), buf_len,
-                                          &io_callback_);
+                                          io_callback_);
   } else {
     io_state_ = STATE_REQUEST_SENT;
   }
   return result;
 }
 
 int HttpStreamParser::DoReadHeaders() {
   io_state_ = STATE_READ_HEADERS_COMPLETE;
 
   // Grow the read buffer if necessary.
   if (read_buf_->RemainingCapacity() == 0)
     read_buf_->SetCapacity(read_buf_->capacity() + kHeaderBufInitialSize);
 
   // http://crbug.com/16371: We're seeing |user_buf_->data()| return NULL.
   // See if the user is passing in an IOBuffer with a NULL |data_|.
   CHECK(read_buf_->data());
 
   return connection_->socket()->Read(read_buf_,
                                      read_buf_->RemainingCapacity(),
-                                     &io_callback_);
+                                     io_callback_);
 }
 
 int HttpStreamParser::DoReadHeadersComplete(int result) {
   if (result == 0)
     result = ERR_CONNECTION_CLOSED;
 
   if (result < 0 && result != ERR_CONNECTION_CLOSED) {
     io_state_ = STATE_DONE;
     return result;
   }
@@ skipping 110 matching lines @@
       read_buf_unused_offset_ = 0;
     }
   }
 
   // Check to see if we're done reading.
   if (IsResponseBodyComplete())
     return 0;
 
   DCHECK_EQ(0, read_buf_->offset());
   return connection_->socket()->Read(user_read_buf_, user_read_buf_len_,
-                                     &io_callback_);
+                                     io_callback_);
 }
 
 int HttpStreamParser::DoReadBodyComplete(int result) {
   // If we didn't get a Content-Length and aren't using a chunked encoding,
   // the only way to signal the end of a stream is to close the connection,
   // so we don't treat that as an error, though in some cases we may not
   // have completely received the resource.
   if (result == 0 && !IsResponseBodyComplete() && CanFindEndOfResponse())
     result = ERR_CONNECTION_CLOSED;
 
@@ skipping 219 matching lines @@
 void HttpStreamParser::GetSSLCertRequestInfo(
     SSLCertRequestInfo* cert_request_info) {
   if (request_->url.SchemeIs("https") && connection_->socket()) {
     SSLClientSocket* ssl_socket =
         static_cast<SSLClientSocket*>(connection_->socket());
     ssl_socket->GetSSLCertRequestInfo(cert_request_info);
   }
 }
 
 }  // namespace net