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

net/http/http_pipelined_connection_impl.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_pipelined_connection_impl.h"
 
+#include "base/bind.h"
+#include "base/bind_helpers.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
 #include "net/base/io_buffer.h"
 #include "net/http/http_pipelined_stream.h"
 #include "net/http/http_request_info.h"
 #include "net/http/http_response_body_drainer.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_stream_parser.h"
 #include "net/http/http_version.h"
 #include "net/socket/client_socket_handle.h"
@@ skipping 11 matching lines @@
       connection_(connection),
       used_ssl_config_(used_ssl_config),
       used_proxy_info_(used_proxy_info),
       net_log_(net_log),
       was_npn_negotiated_(was_npn_negotiated),
       read_buf_(new GrowableIOBuffer()),
       next_pipeline_id_(1),
       active_(false),
       usable_(true),
       completed_one_request_(false),
-      ALLOW_THIS_IN_INITIALIZER_LIST(method_factory_(this)),
+      ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
       send_next_state_(SEND_STATE_NONE),
       send_still_on_call_stack_(false),
-      ALLOW_THIS_IN_INITIALIZER_LIST(send_io_callback_(
-          this, &HttpPipelinedConnectionImpl::OnSendIOCallback)),
       read_next_state_(READ_STATE_NONE),
       active_read_id_(0),
-      read_still_on_call_stack_(false),
-      ALLOW_THIS_IN_INITIALIZER_LIST(read_io_callback_(
-          this, &HttpPipelinedConnectionImpl::OnReadIOCallback)) {
+      read_still_on_call_stack_(false) {
   CHECK(connection_.get());
 }
 
 HttpPipelinedConnectionImpl::~HttpPipelinedConnectionImpl() {
   CHECK_EQ(depth(), 0);
   CHECK(stream_info_map_.empty());
   CHECK(pending_send_request_queue_.empty());
   CHECK(request_order_.empty());
   CHECK_EQ(send_next_state_, SEND_STATE_NONE);
   CHECK_EQ(read_next_state_, READ_STATE_NONE);
@@ skipping 21 matching lines @@
   CHECK(!stream_info_map_[pipeline_id].parser.get());
   stream_info_map_[pipeline_id].state = STREAM_BOUND;
   stream_info_map_[pipeline_id].parser.reset(new HttpStreamParser(
       connection_.get(), request, read_buf_.get(), net_log));
 
   // In case our first stream doesn't SendRequest() immediately, we should still
   // allow others to use this pipeline.
   if (pipeline_id == 1) {
     MessageLoop::current()->PostTask(
         FROM_HERE,
-        method_factory_.NewRunnableMethod(
-            &HttpPipelinedConnectionImpl::ActivatePipeline));
+        base::Bind(&HttpPipelinedConnectionImpl::ActivatePipeline,
+                   weak_factory_.GetWeakPtr()));
   }
 }
 
 void HttpPipelinedConnectionImpl::ActivatePipeline() {
   if (!active_) {
     active_ = true;
     delegate_->OnPipelineHasCapacity(this);
   }
 }
 
 void HttpPipelinedConnectionImpl::OnStreamDeleted(int pipeline_id) {
   CHECK(ContainsKey(stream_info_map_, pipeline_id));
   Close(pipeline_id, false);
 
   if (stream_info_map_[pipeline_id].state != STREAM_CREATED &&
       stream_info_map_[pipeline_id].state != STREAM_UNUSED) {
     CHECK_EQ(stream_info_map_[pipeline_id].state, STREAM_CLOSED);
     CHECK(stream_info_map_[pipeline_id].parser.get());
     stream_info_map_[pipeline_id].parser.reset();
   }
   CHECK(!stream_info_map_[pipeline_id].parser.get());
   stream_info_map_.erase(pipeline_id);
 
   delegate_->OnPipelineHasCapacity(this);
 }
 
-int HttpPipelinedConnectionImpl::SendRequest(int pipeline_id,
-                                             const std::string& request_line,
-                                             const HttpRequestHeaders& headers,
-                                             UploadDataStream* request_body,
-                                             HttpResponseInfo* response,
-                                             OldCompletionCallback* callback) {
+int HttpPipelinedConnectionImpl::SendRequest(
+    int pipeline_id, const std::string& request_line,
+    const HttpRequestHeaders& headers, UploadDataStream* request_body,
+    HttpResponseInfo* response, const CompletionCallback& callback) {
   CHECK(ContainsKey(stream_info_map_, pipeline_id));
   CHECK_EQ(stream_info_map_[pipeline_id].state, STREAM_BOUND);
   if (!usable_) {
     return ERR_PIPELINE_EVICTION;
   }
 
   PendingSendRequest* send_request = new PendingSendRequest;
   send_request->pipeline_id = pipeline_id;
   send_request->request_line = request_line;
   send_request->headers = headers;
@@ skipping 82 matching lines @@
   return OK;
 }
 
 int HttpPipelinedConnectionImpl::DoSendActiveRequest(int result) {
   CHECK(stream_info_map_[active_send_request_->pipeline_id].parser.get());
   int rv = stream_info_map_[active_send_request_->pipeline_id].parser->
       SendRequest(active_send_request_->request_line,
                   active_send_request_->headers,
                   active_send_request_->request_body,
                   active_send_request_->response,
-                  &send_io_callback_);
+                  base::Bind(&HttpPipelinedConnectionImpl::OnSendIOCallback,
+                             base::Unretained(this)));
   stream_info_map_[active_send_request_->pipeline_id].state = STREAM_SENDING;
   send_next_state_ = SEND_STATE_COMPLETE;
   return rv;
 }
 
 int HttpPipelinedConnectionImpl::DoSendComplete(int result) {
   CHECK(active_send_request_.get());
   CHECK_EQ(STREAM_SENDING,
            stream_info_map_[active_send_request_->pipeline_id].state);
 
@@ skipping 26 matching lines @@
   }
 
   return result;
 }
 
 int HttpPipelinedConnectionImpl::DoEvictPendingSendRequests(int result) {
   while (!pending_send_request_queue_.empty()) {
     scoped_ptr<PendingSendRequest> evicted_send(
         pending_send_request_queue_.front());
     pending_send_request_queue_.pop();
-    if (stream_info_map_[evicted_send->pipeline_id].state != STREAM_CLOSED) {
-      evicted_send->callback->Run(ERR_PIPELINE_EVICTION);
-    }
+    if (stream_info_map_[evicted_send->pipeline_id].state != STREAM_CLOSED)
+      evicted_send->callback.Run(ERR_PIPELINE_EVICTION);
   }
   send_next_state_ = SEND_STATE_NONE;
   return result;
 }
 
 int HttpPipelinedConnectionImpl::ReadResponseHeaders(
-    int pipeline_id,
-    OldCompletionCallback* callback) {
+    int pipeline_id, const CompletionCallback& callback) {
   CHECK(ContainsKey(stream_info_map_, pipeline_id));
   CHECK_EQ(STREAM_SENT, stream_info_map_[pipeline_id].state);
-  CHECK(!stream_info_map_[pipeline_id].read_headers_callback);
+  CHECK(stream_info_map_[pipeline_id].read_headers_callback.is_null());
 
-  if (!usable_) {
+  if (!usable_)
     return ERR_PIPELINE_EVICTION;
-  }
 
   stream_info_map_[pipeline_id].state = STREAM_READ_PENDING;
   stream_info_map_[pipeline_id].read_headers_callback = callback;
   if (read_next_state_ == READ_STATE_NONE &&
       pipeline_id == request_order_.front()) {
     read_next_state_ = READ_STATE_START_IMMEDIATELY;
     return DoReadHeadersLoop(OK);
   }
   return ERR_IO_PENDING;
 }
@@ skipping 101 matching lines @@
 
   return OK;
 }
 
 int HttpPipelinedConnectionImpl::DoReadHeaders(int result) {
   CHECK(active_read_id_);
   CHECK(ContainsKey(stream_info_map_, active_read_id_));
   CHECK_EQ(STREAM_READ_PENDING, stream_info_map_[active_read_id_].state);
   stream_info_map_[active_read_id_].state = STREAM_ACTIVE;
   int rv = stream_info_map_[active_read_id_].parser->ReadResponseHeaders(
-      &read_io_callback_);
+      base::Bind(&HttpPipelinedConnectionImpl::OnReadIOCallback,
+                 base::Unretained(this)));
   read_next_state_ = READ_STATE_READ_HEADERS_COMPLETE;
   return rv;
 }
 
 int HttpPipelinedConnectionImpl::DoReadHeadersComplete(int result) {
   CHECK(active_read_id_);
   CHECK(ContainsKey(stream_info_map_, active_read_id_));
   CHECK_EQ(STREAM_ACTIVE, stream_info_map_[active_read_id_].state);
 
   read_next_state_ = READ_STATE_WAITING_FOR_CLOSE;
@@ skipping 26 matching lines @@
   CHECK_EQ(stream_info_map_[active_read_id_].state, STREAM_CLOSED);
   active_read_id_ = 0;
   if (!usable_) {
     // TODO(simonjam): Don't wait this long to evict.
     read_next_state_ = READ_STATE_EVICT_PENDING_READS;
     return OK;
   }
   completed_one_request_ = true;
   MessageLoop::current()->PostTask(
       FROM_HERE,
-      method_factory_.NewRunnableMethod(
-          &HttpPipelinedConnectionImpl::StartNextDeferredRead));
+      base::Bind(&HttpPipelinedConnectionImpl::StartNextDeferredRead,
+                 weak_factory_.GetWeakPtr()));
   read_next_state_ = READ_STATE_NONE;
   return OK;
 }
 
 int HttpPipelinedConnectionImpl::DoEvictPendingReadHeaders(int result) {
   while (!request_order_.empty()) {
     int evicted_id = request_order_.front();
     request_order_.pop();
     if (!ContainsKey(stream_info_map_, evicted_id)) {
       continue;
@@ skipping 60 matching lines @@
       // TODO(simonjam): Why is Close() sometimes called twice?
       break;
 
     default:
       CHECK(false);
       break;
   }
 }
 
 int HttpPipelinedConnectionImpl::ReadResponseBody(
-    int pipeline_id,
-    IOBuffer* buf,
-    int buf_len,
-    OldCompletionCallback* callback) {
+    int pipeline_id, IOBuffer* buf, int buf_len,
+    const CompletionCallback& callback) {
   CHECK(ContainsKey(stream_info_map_, pipeline_id));
   CHECK_EQ(active_read_id_, pipeline_id);
   CHECK(stream_info_map_[pipeline_id].parser.get());
   return stream_info_map_[pipeline_id].parser->ReadResponseBody(
       buf, buf_len, callback);
 }
 
 uint64 HttpPipelinedConnectionImpl::GetUploadProgress(int pipeline_id) const {
   CHECK(ContainsKey(stream_info_map_, pipeline_id));
   CHECK(stream_info_map_.find(pipeline_id)->second.parser.get());
@@ skipping 39 matching lines @@
 
 void HttpPipelinedConnectionImpl::SetConnectionReused(int pipeline_id) {
   CHECK(ContainsKey(stream_info_map_, pipeline_id));
   connection_->set_is_reused(true);
 }
 
 void HttpPipelinedConnectionImpl::GetSSLInfo(int pipeline_id,
                                              SSLInfo* ssl_info) {
   CHECK(ContainsKey(stream_info_map_, pipeline_id));
   CHECK(stream_info_map_[pipeline_id].parser.get());
-  return stream_info_map_[pipeline_id].parser->GetSSLInfo(ssl_info);
+  stream_info_map_[pipeline_id].parser->GetSSLInfo(ssl_info);
 }
 
 void HttpPipelinedConnectionImpl::GetSSLCertRequestInfo(
     int pipeline_id,
     SSLCertRequestInfo* cert_request_info) {
   CHECK(ContainsKey(stream_info_map_, pipeline_id));
   CHECK(stream_info_map_[pipeline_id].parser.get());
-  return stream_info_map_[pipeline_id].parser->GetSSLCertRequestInfo(
+  stream_info_map_[pipeline_id].parser->GetSSLCertRequestInfo(
       cert_request_info);
 }
 
 void HttpPipelinedConnectionImpl::Drain(HttpPipelinedStream* stream,
                                         HttpNetworkSession* session) {
   HttpResponseHeaders* headers = stream->GetResponseInfo()->headers;
   if (!stream->CanFindEndOfResponse() || headers->IsChunkEncoded() ||
       !usable_) {
     // TODO(simonjam): Drain chunk-encoded responses if they're relatively
     // common.
@@ skipping 32 matching lines @@
   if (!info->headers->IsKeepAlive() || !CanFindEndOfResponse(pipeline_id)) {
     usable_ = false;
     delegate_->OnPipelineFeedback(this, MUST_CLOSE_CONNECTION);
     return;
   }
   // TODO(simonjam): We should also check for, and work around, authentication.
   delegate_->OnPipelineFeedback(this, OK);
 }
 
 void HttpPipelinedConnectionImpl::QueueUserCallback(
-    int pipeline_id,
-    OldCompletionCallback* callback,
-    int rv,
+    int pipeline_id, const CompletionCallback& callback, int rv,
     const tracked_objects::Location& from_here) {
-  CHECK(!stream_info_map_[pipeline_id].pending_user_callback);
+  CHECK(stream_info_map_[pipeline_id].pending_user_callback.is_null());
   stream_info_map_[pipeline_id].pending_user_callback = callback;
   MessageLoop::current()->PostTask(
       from_here,
-      method_factory_.NewRunnableMethod(
-          &HttpPipelinedConnectionImpl::FireUserCallback,
-          pipeline_id,
-          rv));
+      base::Bind(&HttpPipelinedConnectionImpl::FireUserCallback,
+                 weak_factory_.GetWeakPtr(), pipeline_id, rv));
 }
 
 void HttpPipelinedConnectionImpl::FireUserCallback(int pipeline_id,
                                                    int result) {
   if (ContainsKey(stream_info_map_, pipeline_id)) {
-    CHECK(stream_info_map_[pipeline_id].pending_user_callback);
-    OldCompletionCallback* callback =
+    CHECK(!stream_info_map_[pipeline_id].pending_user_callback.is_null());
+    CompletionCallback callback =
         stream_info_map_[pipeline_id].pending_user_callback;
-    stream_info_map_[pipeline_id].pending_user_callback = NULL;
-    callback->Run(result);
+    stream_info_map_[pipeline_id].pending_user_callback.Reset();
+    callback.Run(result);
   }
 }
 
 int HttpPipelinedConnectionImpl::depth() const {
   return stream_info_map_.size();
 }
 
 bool HttpPipelinedConnectionImpl::usable() const {
   return usable_;
 }
@@ skipping 18 matching lines @@
   return was_npn_negotiated_;
 }
 
 HttpPipelinedConnectionImpl::PendingSendRequest::PendingSendRequest() {
 }
 
 HttpPipelinedConnectionImpl::PendingSendRequest::~PendingSendRequest() {
 }
 
 HttpPipelinedConnectionImpl::StreamInfo::StreamInfo()
-    : read_headers_callback(NULL),
-      pending_user_callback(NULL),
-      state(STREAM_CREATED) {
+    : state(STREAM_CREATED) {
 }
 
 HttpPipelinedConnectionImpl::StreamInfo::~StreamInfo() {
 }
 
 }  // namespace net