Add chunked uploads support to SPDY

net/base/upload_data_stream.cc

 // Copyright (c) 2010 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/file_util.h"
 #include "base/logging.h"
 #include "net/base/file_stream.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 
 namespace net {
 
+bool UploadDataStream::merge_chunks_ = true;
+
 UploadDataStream::~UploadDataStream() {
 }
 
 UploadDataStream* UploadDataStream::Create(UploadData* data, int* error_code) {
   scoped_ptr<UploadDataStream> stream(new UploadDataStream(data));
   int rv = stream->FillBuf();
   if (error_code)
     *error_code = rv;
   if (rv != OK)
     return NULL;
@@ skipping 37 matching lines @@
     UploadData::Element& element = elements[next_element_];
 
     size_t size_remaining = kBufSize - buf_len_;
     if (element.type() == UploadData::TYPE_BYTES ||
         element.type() == UploadData::TYPE_CHUNK) {
       const std::vector<char>& d = element.bytes();
       size_t count = d.size() - next_element_offset_;
 
       size_t bytes_copied = std::min(count, size_remaining);
 
-      memcpy(buf_->data() + buf_len_, &d[next_element_offset_], bytes_copied);
-      buf_len_ += bytes_copied;
+      // Check if we have anything to copy first, because we are getting the
+      // address of an element in |d| and that will throw an exception if |d|
+      // is an empty vector.
+      if (bytes_copied) {
+        memcpy(buf_->data() + buf_len_, &d[next_element_offset_], bytes_copied);
+        buf_len_ += bytes_copied;
+      }
 
       if (bytes_copied == count) {
         advance_to_next_element = true;
       } else {
         next_element_offset_ += bytes_copied;
       }
     } else {
       DCHECK(element.type() == UploadData::TYPE_FILE);
 
       if (!next_element_remaining_) {
@@ skipping 35 matching lines @@
         next_element_remaining_ -= rv;
       }
     }
 
     if (advance_to_next_element) {
       ++next_element_;
       next_element_offset_ = 0;
       next_element_remaining_ = 0;
       next_element_stream_.reset();
     }
+
+    if (is_chunked() && !merge_chunks_)
+      break;
   }
 
   if (next_element_ == elements.size() && !buf_len_) {
     if (!data_->is_chunked() ||
         (!elements.empty() && elements.back().is_last_chunk())) {
       eof_ = true;
     }
   }
 
   return OK;
 }
 
+bool UploadDataStream::IsOnLastChunk() const {
+  const std::vector<UploadData::Element>& elements = *data_->elements();
+  DCHECK(data_->is_chunked());
+  return (eof_ ||
+          (!elements.empty() &&
+           next_element_ == elements.size() &&

[willchan no longer on Chromium, 2011/03/03 23:42:32]

What's going on here? Did we catch a bug? It's not immediately obvious what this
change is for.

[Satish, 2011/03/03 23:50:59]

Sorry I missed this. Yes I found a bug when testing with 16k sized chunks. This
method should return true only after the whole chunk data was copied over to the
IOBuffer. Since we no longer have the old zero-size chunk to indicate the end
and instead have the flag on the last valid chunk, next_element_ should have
gone past all chunks once the last chunk was read into the IOBuffer.

+           elements.back().is_last_chunk()));
+}
+
 }  // namespace net