base::Bind: Convert most of net/http.

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 59 matching lines @@
       request_headers_(NULL),
       request_body_(NULL),
       read_buf_(read_buffer),
       read_buf_unused_offset_(0),
       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_(
               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);
 }
 
 int HttpStreamParser::SendRequest(const std::string& request_line,
                                   const HttpRequestHeaders& headers,
                                   UploadDataStream* request_body,
                                   HttpResponseInfo* response,
-                                  OldCompletionCallback* callback) {
+                                  const CompletionCallback& callback) {
   DCHECK_EQ(STATE_NONE, io_state_);
-  DCHECK(!user_callback_);
-  DCHECK(callback);
+  DCHECK(callback_.is_null());
+  DCHECK(!callback.is_null());
   DCHECK(response);
 
   if (net_log_.IsLoggingAllEvents()) {
     net_log_.AddEvent(
         NetLog::TYPE_HTTP_TRANSACTION_SEND_REQUEST_HEADERS,
         make_scoped_refptr(new NetLogHttpRequestParameter(
             request_line, headers)));
   }
   DVLOG(1) << __FUNCTION__ << "()"
            << " request_line = \"" << request_line << "\""
@@ skipping 15 matching lines @@
   if (request_body_ != NULL && request_body_->is_chunked()) {
     request_body_->set_chunk_callback(this);
     const int kChunkHeaderFooterSize = 12;  // 2 CRLFs + max of 8 hex chars.
     chunk_buf_ = new IOBuffer(request_body_->GetMaxBufferSize() +
                               kChunkHeaderFooterSize);
   }
 
   io_state_ = STATE_SENDING_HEADERS;
   result = DoLoop(OK);
   if (result == ERR_IO_PENDING)
-    user_callback_ = callback;
+    callback_ = callback;
 
   return result > 0 ? OK : result;
 }
 
-int HttpStreamParser::ReadResponseHeaders(OldCompletionCallback* callback) {
+int HttpStreamParser::ReadResponseHeaders(const CompletionCallback& callback) {
   DCHECK(io_state_ == STATE_REQUEST_SENT || io_state_ == STATE_DONE);
-  DCHECK(!user_callback_);
-  DCHECK(callback);
+  DCHECK(callback_.is_null());
+  DCHECK(!callback.is_null());
 
   // This function can be called with io_state_ == STATE_DONE if the
   // connection is closed after seeing just a 1xx response code.
   if (io_state_ == STATE_DONE)
     return ERR_CONNECTION_CLOSED;
 
   int result = OK;
   io_state_ = STATE_READ_HEADERS;
 
   if (read_buf_->offset() > 0) {
     // Simulate the state where the data was just read from the socket.
     result = read_buf_->offset() - read_buf_unused_offset_;
     read_buf_->set_offset(read_buf_unused_offset_);
   }
   if (result > 0)
     io_state_ = STATE_READ_HEADERS_COMPLETE;
 
   result = DoLoop(result);
   if (result == ERR_IO_PENDING)
-    user_callback_ = callback;
+    callback_ = callback;
 
   return result > 0 ? OK : result;
 }
 
 void HttpStreamParser::Close(bool not_reusable) {
   if (not_reusable && connection_->socket())
     connection_->socket()->Disconnect();
   connection_->Reset();
 }
 
 int HttpStreamParser::ReadResponseBody(IOBuffer* buf, int buf_len,
-                                       OldCompletionCallback* callback) {
+                                       const CompletionCallback& callback) {
   DCHECK(io_state_ == STATE_BODY_PENDING || io_state_ == STATE_DONE);
-  DCHECK(!user_callback_);
-  DCHECK(callback);
+  DCHECK(callback_.is_null());
+  DCHECK(!callback.is_null());
   DCHECK_LE(buf_len, kMaxBufSize);
 
   if (io_state_ == STATE_DONE)
     return OK;
 
   user_read_buf_ = buf;
   user_read_buf_len_ = buf_len;
   io_state_ = STATE_READ_BODY;
 
   int result = DoLoop(OK);
   if (result == ERR_IO_PENDING)
-    user_callback_ = callback;
+    callback_ = callback;
 
   return result;
 }
 
 void HttpStreamParser::OnIOComplete(int result) {
   result = DoLoop(result);
 
   // The client callback can do anything, including destroying this class,
   // so any pending callback must be issued after everything else is done.
-  if (result != ERR_IO_PENDING && user_callback_) {
-    OldCompletionCallback* c = user_callback_;
-    user_callback_ = NULL;
-    c->Run(result);
+  if (result != ERR_IO_PENDING && !callback_.is_null()) {
+    CompletionCallback c = callback_;
+    callback_.Reset();
+    c.Run(result);
   }
 }
 
 void HttpStreamParser::OnChunkAvailable() {
   // This method may get called while sending the headers or body, so check
   // before processing the new data. If we were still initializing or sending
   // headers, we will automatically start reading the chunks once we get into
   // STATE_SENDING_BODY so nothing to do here.
   DCHECK(io_state_ == STATE_SENDING_HEADERS || io_state_ == STATE_SENDING_BODY);
   if (io_state_ == STATE_SENDING_BODY)
@@ skipping 542 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