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

net/spdy/spdy_http_stream.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/spdy/spdy_http_stream.h"
 
 #include <algorithm>
 #include <list>
 #include <string>
 
@@ skipping 13 matching lines @@
 namespace net {
 
 SpdyHttpStream::SpdyHttpStream(SpdySession* spdy_session,
                                bool direct)
     : ALLOW_THIS_IN_INITIALIZER_LIST(read_callback_factory_(this)),
       stream_(NULL),
       spdy_session_(spdy_session),
       response_info_(NULL),
       download_finished_(false),
       response_headers_received_(false),
-      user_callback_(NULL),
       user_buffer_len_(0),
       buffered_read_callback_pending_(false),
       more_read_data_pending_(false),
       direct_(direct) { }
 
 void SpdyHttpStream::InitializeWithExistingStream(SpdyStream* spdy_stream) {
   stream_ = spdy_stream;
   stream_->SetDelegate(this);
   response_headers_received_ = true;
 }
 
 SpdyHttpStream::~SpdyHttpStream() {
   if (stream_)
     stream_->DetachDelegate();
 }
 
 int SpdyHttpStream::InitializeStream(const HttpRequestInfo* request_info,
                                      const BoundNetLog& stream_net_log,
-                                     OldCompletionCallback* callback) {
+                                     const CompletionCallback& callback) {
   DCHECK(!stream_.get());
   if (spdy_session_->IsClosed())
    return ERR_CONNECTION_CLOSED;
 
   request_info_ = request_info;
   if (request_info_->method == "GET") {
     int error = spdy_session_->GetPushStream(request_info_->url, &stream_,
                                              stream_net_log);
     if (error != OK)
       return error;
@@ skipping 11 matching lines @@
   return response_info_;
 }
 
 uint64 SpdyHttpStream::GetUploadProgress() const {
   if (!request_body_stream_.get())
     return 0;
 
   return request_body_stream_->position();
 }
 
-int SpdyHttpStream::ReadResponseHeaders(OldCompletionCallback* callback) {
-  CHECK(callback);
+int SpdyHttpStream::ReadResponseHeaders(const CompletionCallback& callback) {
+  CHECK(!callback.is_null());
   CHECK(!stream_->cancelled());
 
   if (stream_->closed())
     return stream_->response_status();
 
   // Check if we already have the response headers. If so, return synchronously.
   if(stream_->response_received()) {
     CHECK(stream_->is_idle());
     return OK;
   }
 
   // Still waiting for the response, return IO_PENDING.
-  CHECK(!user_callback_);
-  user_callback_ = callback;
+  CHECK(callback_.is_null());
+  callback_ = callback;
   return ERR_IO_PENDING;
 }
 
 int SpdyHttpStream::ReadResponseBody(
-    IOBuffer* buf, int buf_len, OldCompletionCallback* callback) {
+    IOBuffer* buf, int buf_len, const CompletionCallback& callback) {
   CHECK(stream_->is_idle());
   CHECK(buf);
   CHECK(buf_len);
-  CHECK(callback);
+  CHECK(!callback.is_null());
 
   // If we have data buffered, complete the IO immediately.
   if (!response_body_.empty()) {
     int bytes_read = 0;
     while (!response_body_.empty() && buf_len > 0) {
       scoped_refptr<IOBufferWithSize> data = response_body_.front();
       const int bytes_to_copy = std::min(buf_len, data->size());
       memcpy(&(buf->data()[bytes_read]), data->data(), bytes_to_copy);
       buf_len -= bytes_to_copy;
       if (bytes_to_copy == data->size()) {
         response_body_.pop_front();
       } else {
         const int bytes_remaining = data->size() - bytes_to_copy;
         IOBufferWithSize* new_buffer = new IOBufferWithSize(bytes_remaining);
         memcpy(new_buffer->data(), &(data->data()[bytes_to_copy]),
                bytes_remaining);
         response_body_.pop_front();
         response_body_.push_front(make_scoped_refptr(new_buffer));
       }
       bytes_read += bytes_to_copy;
     }
     if (spdy_session_ && spdy_session_->is_flow_control_enabled())
       stream_->IncreaseRecvWindowSize(bytes_read);
     return bytes_read;
   } else if (stream_->closed()) {
     return stream_->response_status();
   }
 
-  CHECK(!user_callback_);
+  CHECK(callback_.is_null());
   CHECK(!user_buffer_);
   CHECK_EQ(0, user_buffer_len_);
 
-  user_callback_ = callback;
+  callback_ = callback;
   user_buffer_ = buf;
   user_buffer_len_ = buf_len;
   return ERR_IO_PENDING;
 }
 
 void SpdyHttpStream::Close(bool not_reusable) {
   // Note: the not_reusable flag has no meaning for SPDY streams.
 
   Cancel();
 }
@@ skipping 30 matching lines @@
 }
 
 void SpdyHttpStream::set_chunk_callback(ChunkCallback* callback) {
   if (request_body_stream_ != NULL)
     request_body_stream_->set_chunk_callback(callback);
 }
 
 int SpdyHttpStream::SendRequest(const HttpRequestHeaders& request_headers,
                                 UploadDataStream* request_body,
                                 HttpResponseInfo* response,
-                                OldCompletionCallback* callback) {
+                                const CompletionCallback& callback) {
   base::Time request_time = base::Time::Now();
   CHECK(stream_.get());
 
   stream_->SetDelegate(this);
 
   linked_ptr<spdy::SpdyHeaderBlock> headers(new spdy::SpdyHeaderBlock);
   CreateSpdyHeadersFromHttpRequest(*request_info_, request_headers,
                                    headers.get(), direct_);
   stream_->set_spdy_headers(headers);
 
   stream_->SetRequestTime(request_time);
   // This should only get called in the case of a request occurring
   // during server push that has already begun but hasn't finished,
   // so we set the response's request time to be the actual one
   if (response_info_)
     response_info_->request_time = request_time;
 
   CHECK(!request_body_stream_.get());
   if (request_body) {
     if (request_body->size() || request_body->is_chunked())
       request_body_stream_.reset(request_body);
     else
       delete request_body;
   }
 
-  CHECK(callback);
+  CHECK(!callback.is_null());
   CHECK(!stream_->cancelled());
   CHECK(response);
 
   if (!stream_->pushed() && stream_->closed()) {
     if (stream_->response_status() == OK)
       return ERR_FAILED;
     else
       return stream_->response_status();
   }
 
@@ skipping 15 matching lines @@
   // Put the peer's IP address and port into the response.
   AddressList address;
   int result = stream_->GetPeerAddress(&address);
   if (result != OK)
     return result;
   response_info_->socket_address = HostPortPair::FromAddrInfo(address.head());
 
   bool has_upload_data = request_body_stream_.get() != NULL;
   result = stream_->SendRequest(has_upload_data);
   if (result == ERR_IO_PENDING) {
-    CHECK(!user_callback_);
-    user_callback_ = callback;
+    CHECK(callback_.is_null());
+    callback_ = callback;
   }
   return result;
 }
 
 void SpdyHttpStream::Cancel() {
   if (spdy_session_)
     spdy_session_->CancelPendingCreateStreams(&stream_);
-  user_callback_ = NULL;
+  callback_.Reset();
   if (stream_)
     stream_->Cancel();
 }
 
 bool SpdyHttpStream::OnSendHeadersComplete(int status) {
-  if (user_callback_)
+  if (!callback_.is_null())
     DoCallback(status);
   return request_body_stream_.get() == NULL;
 }
 
 int SpdyHttpStream::OnSendBody() {
   CHECK(request_body_stream_.get());
 
   int buf_len = static_cast<int>(request_body_stream_->buf_len());
   if (!buf_len)
     return OK;
@@ skipping 51 matching lines @@
   // will take care of that part.
   SSLInfo ssl_info;
   stream_->GetSSLInfo(&ssl_info,
                       &response_info_->was_npn_negotiated);
   response_info_->request_time = stream_->GetRequestTime();
   response_info_->vary_data.Init(*request_info_, *response_info_->headers);
   // TODO(ahendrickson): This is recorded after the entire SYN_STREAM control
   // frame has been received and processed.  Move to framer?
   response_info_->response_time = response_time;
 
-  if (user_callback_)
+  if (!callback_.is_null())
     DoCallback(status);
+
   return status;
 }
 
 void SpdyHttpStream::OnDataReceived(const char* data, int length) {
   // SpdyStream won't call us with data if the header block didn't contain a
   // valid set of headers.  So we don't expect to not have headers received
   // here.
   DCHECK(response_headers_received_);
 
   // Note that data may be received for a SpdyStream prior to the user calling
@@ skipping 19 matching lines @@
   // so it is never called.
   NOTREACHED();
 }
 
 void SpdyHttpStream::OnClose(int status) {
   bool invoked_callback = false;
   if (status == net::OK) {
     // We need to complete any pending buffered read now.
     invoked_callback = DoBufferedReadCallback();
   }
-  if (!invoked_callback && user_callback_)
+  if (!invoked_callback && !callback_.is_null())
     DoCallback(status);
 }
 
 void SpdyHttpStream::ScheduleBufferedReadCallback() {
   // If there is already a scheduled DoBufferedReadCallback, don't issue
   // another one.  Mark that we have received more data and return.
   if (buffered_read_callback_pending_) {
     more_read_data_pending_ = true;
     return;
   }
@@ skipping 35 matching lines @@
   // When more_read_data_pending_ is true, it means that more data has
   // arrived since we started waiting.  Wait a little longer and continue
   // to buffer.
   if (more_read_data_pending_ && ShouldWaitForMoreBufferedData()) {
     ScheduleBufferedReadCallback();
     return false;
   }
 
   int rv = 0;
   if (user_buffer_) {
-    rv = ReadResponseBody(user_buffer_, user_buffer_len_, user_callback_);
+    rv = ReadResponseBody(user_buffer_, user_buffer_len_, callback_);
     CHECK_NE(rv, ERR_IO_PENDING);
     user_buffer_ = NULL;
     user_buffer_len_ = 0;
     DoCallback(rv);
     return true;
   }
   return false;
 }
 
 void SpdyHttpStream::DoCallback(int rv) {
   CHECK_NE(rv, ERR_IO_PENDING);
-  CHECK(user_callback_);
+  CHECK(!callback_.is_null());
 
   // Since Run may result in being called back, clear user_callback_ in advance.
-  OldCompletionCallback* c = user_callback_;
-  user_callback_ = NULL;
-  c->Run(rv);
+  CompletionCallback c = callback_;
+  callback_.Reset();
+  c.Run(rv);
 }
 
 void SpdyHttpStream::GetSSLInfo(SSLInfo* ssl_info) {
   DCHECK(stream_);
   bool using_npn;
   stream_->GetSSLInfo(ssl_info, &using_npn);
 }
 
 void SpdyHttpStream::GetSSLCertRequestInfo(
     SSLCertRequestInfo* cert_request_info) {
   DCHECK(stream_);
   stream_->GetSSLCertRequestInfo(cert_request_info);
 }
 
 bool SpdyHttpStream::IsSpdyHttpStream() const {
   return true;
 }
 
 void SpdyHttpStream::Drain(HttpNetworkSession* session) {
   Close(false);
   delete this;
 }
 
 }  // namespace net