net: Make UploadDataStream::Read() asynchronous

net/base/upload_data_stream.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/base/upload_data_stream.h"
 
 #include "base/logging.h"
+#include "base/message_loop.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/base/upload_element_reader.h"
 
 namespace net {
 
 bool UploadDataStream::merge_chunks_ = true;
 
 // static
 void UploadDataStream::ResetMergeChunks() {
@@ skipping 37 matching lines @@
     if (result != OK) {
       element_readers_.clear();
       return result;
     }
   }
 
   FinalizeInitialization();
   return OK;
 }
 
-int UploadDataStream::Read(IOBuffer* buf, int buf_len) {
+int UploadDataStream::Read(IOBuffer* buf,
+                           int buf_len,
+                           const CompletionCallback& callback) {
+  DCHECK(initialized_successfully_);
+
+  // Use fast path when all data is in memory, chunked data is also processed
+  // with ReadSync() since it requires special logic.
+  if (IsInMemory() || is_chunked())
+    return ReadSync(buf, buf_len);
+
+  const bool invoked_asynchronously = false;
+  return ReadInternal(buf, buf_len, 0, invoked_asynchronously, callback, 0);
+}
+
+int UploadDataStream::ReadSync(IOBuffer* buf, int buf_len) {
   DCHECK(initialized_successfully_);
 
   // Initialize readers for newly appended chunks.
   if (is_chunked()) {
     const std::vector<UploadElement>& elements = *upload_data_->elements();
     DCHECK_LE(element_readers_.size(), elements.size());
 
     for (size_t i = element_readers_.size(); i < elements.size(); ++i) {
       const UploadElement& element = elements[i];
       DCHECK_EQ(UploadElement::TYPE_BYTES, element.type());

[mmenke, 2012/10/11 18:05:40]

Wait...so we allow TYPE_BYTES to be added after construction, but not TYPE_FILE?
 Why?  Doesn't doing this mess up any total_size_ guarantee?  The header only
suggests total_size may be an overestimate, not an underestimate.  Do we have
integration tests for this?

[hashimoto, 2012/10/12 07:36:56]

We allow adding data after construction only if the data is chunked.
Since chunked data is always TYPE_BYTES, we DCHECK it here.
total_size_ is forced to be zero when the data is chunked.
We check this in UploadDataStreamTest.Chunk and other chunked data upload
realted tests.

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

None of this is documented anywhere.  Could we fix that?

I've inlined suggested places to mention the size behavior.  Also, in
upload_data.h, please mention that chunked upload data cannot include TYPE_FILE.
 Please also add a comment to that effect here, too.

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

Thank you for your kind suggestion.
Added comments for all mentioned places.

       UploadElementReader* reader = UploadElementReader::Create(element);
 
       const int rv = reader->InitSync();
       DCHECK_EQ(rv, OK);
       element_readers_.push_back(reader);
     }
   }
 
   int bytes_copied = 0;
   while (bytes_copied < buf_len && element_index_ < element_readers_.size()) {
     UploadElementReader* reader = element_readers_[element_index_];
-    bytes_copied += reader->ReadSync(buf->data() + bytes_copied,
-                                     buf_len - bytes_copied);
+    scoped_refptr<DrainableIOBuffer> sub_buffer =
+        new DrainableIOBuffer(buf, buf_len);
+    sub_buffer->SetOffset(bytes_copied);
+    bytes_copied += reader->ReadSync(sub_buffer, sub_buffer->BytesRemaining());
     if (reader->BytesRemaining() == 0)
       ++element_index_;
 
     if (is_chunked() && !merge_chunks_)
       break;
   }
 
   current_position_ += bytes_copied;
   if (is_chunked() && !IsEOF() && bytes_copied == 0)
     return ERR_IO_PENDING;
@@ skipping 73 matching lines @@
     uint64 total_size = 0;
     for (size_t i = 0; i < element_readers_.size(); ++i) {
       UploadElementReader* reader = element_readers_[i];
       total_size += reader->GetContentLength();
     }
     total_size_ = total_size;
   }
   initialized_successfully_ = true;
 }
 
+int UploadDataStream::ReadInternal(scoped_refptr<IOBuffer> buf,
+                                   int buf_len,
+                                   int bytes_copied,
+                                   bool invoked_asynchronously,
+                                   const CompletionCallback& callback,
+                                   int previous_result) {
+  DCHECK(initialized_successfully_);
+  DCHECK_GE(previous_result, 0);
+
+  // Add the last result.
+  bytes_copied += previous_result;
+
+  while (bytes_copied < buf_len && element_index_ < element_readers_.size()) {
+    UploadElementReader* reader = element_readers_[element_index_];
+
+    if (reader->BytesRemaining() == 0) {
+      ++element_index_;
+      continue;
+    }
+    scoped_refptr<DrainableIOBuffer> sub_buffer =
+        new DrainableIOBuffer(buf, buf_len);
+    sub_buffer->SetOffset(bytes_copied);
+    const int result = reader->Read(
+        sub_buffer,
+        sub_buffer->BytesRemaining(),
+        base::Bind(base::IgnoreResult(&UploadDataStream::ReadInternal),
+                   weak_ptr_factory_.GetWeakPtr(),
+                   buf,
+                   buf_len,
+                   bytes_copied,
+                   true,  // invoked_asynchronously
+                   callback));
+    if (result == ERR_IO_PENDING)
+      return ERR_IO_PENDING;
+
+    DCHECK_GE(bytes_copied, 0);
+    bytes_copied += result;
+  }
+  current_position_ += bytes_copied;
+
+  // When invoked asynchronously, callback is the only way to return the result.
+  if (invoked_asynchronously)
+    callback.Run(bytes_copied);
+  return bytes_copied;
+}
+
 }  // namespace net