net: Make UploadDataStream::Read() asynchronous

net/http/http_stream_parser.cc

 // Copyright (c) 2012 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/bind.h"
 #include "base/compiler_specific.h"
 #include "base/metrics/histogram.h"
 #include "base/string_util.h"
@@ skipping 242 matching lines @@
     // We'll repurpose |request_headers_| to store the merged headers and
     // body.
     request_headers_ = new DrainableIOBuffer(
         merged_request_headers_and_body, merged_size);
 
     memcpy(request_headers_->data(), request.data(), request.size());
     request_headers_->DidConsume(request.size());
 
     size_t todo = request_body_->size();
     while (todo) {
-      int consumed = request_body_->Read(request_headers_, todo);
+      int consumed = request_body_->ReadSync(request_headers_, todo);
       DCHECK_GT(consumed, 0);  // Read() won't fail if not chunked.
       request_headers_->DidConsume(consumed);
       todo -= consumed;
     }
     DCHECK(request_body_->IsEOF());
     // Reset the offset, so the buffer can be read from the beginning.
     request_headers_->SetOffset(0);
     did_merge = true;
 
     net_log_.AddEvent(
@@ skipping 209 matching lines @@
     return connection_->socket()->Write(request_body_buf_,
                                         request_body_buf_->BytesRemaining(),
                                         io_callback_);
   }
 
   if (sent_last_chunk_) {
     io_state_ = STATE_REQUEST_SENT;
     return OK;
   }
 
-  const int consumed = request_body_->Read(chunk_buf_, chunk_buf_->size());
+  const int consumed = request_body_->ReadSync(chunk_buf_, chunk_buf_->size());
   if (consumed == 0) {  // Reached the end.
     DCHECK(request_body_->IsEOF());
     request_body_buf_->Clear();
     const int chunk_length = EncodeChunk(base::StringPiece(),
                                          request_body_buf_->data(),
                                          request_body_buf_->capacity());
     request_body_buf_->DidAppend(chunk_length);
     sent_last_chunk_ = true;
   } else if (consumed > 0) {
     // Encode and send the buffer as 1 chunk.
@@ skipping 23 matching lines @@
 
   // Send the remaining data in the request body buffer.
   request_body_buf_->DidConsume(result);
   if (request_body_buf_->BytesRemaining() > 0) {
     return connection_->socket()->Write(request_body_buf_,
                                         request_body_buf_->BytesRemaining(),
                                         io_callback_);
   }
 
   request_body_buf_->Clear();
-  const int consumed = request_body_->Read(request_body_buf_,
-                                           request_body_buf_->capacity());
+  const int consumed = request_body_->ReadSync(request_body_buf_,
+                                               request_body_buf_->capacity());
   if (consumed == 0) {  // Reached the end.
     io_state_ = STATE_REQUEST_SENT;
   } else if (consumed > 0) {
     request_body_buf_->DidAppend(consumed);
     result = connection_->socket()->Write(request_body_buf_,
                                           request_body_buf_->BytesRemaining(),
                                           io_callback_);
   } else {
     // UploadDataStream::Read() won't fail if not chunked.
     NOTREACHED();
@@ skipping 356 matching lines @@
       // If response_body_length_ is still -1, then we have to wait
       // for the server to close the connection.
     }
   }
 }
 
 UploadProgress HttpStreamParser::GetUploadProgress() const {
   if (!request_body_.get())
     return UploadProgress();
 
   return UploadProgress(request_body_->position(), request_body_->size());

[mmenke, 2012/10/12 21:30:29]

size will be 0 for chunked uploads, but position will not be.  This should be
mentioned either in UploadProgress or in the header files (Both the stream
parsers's and in URLRequest's).

[hashimoto, 2012/10/15 11:21:37]

Done for both HttpStreamParser and URLRequest.

 }
 
 HttpResponseInfo* HttpStreamParser::GetResponseInfo() {
   return response_;
 }
 
 bool HttpStreamParser::IsResponseBodyComplete() const {
   if (chunked_decoder_.get())
     return chunked_decoder_->reached_eof();
   if (response_body_length_ != -1)
@@ skipping 74 matching lines @@
       request_body->IsInMemory() &&
       request_body->size() > 0) {
     size_t merged_size = request_headers.size() + request_body->size();
     if (merged_size <= kMaxMergedHeaderAndBodySize)
       return true;
   }
   return false;
 }
 
 }  // namespace net