Prototype of chunked transfer encoded POST.

net/base/upload_data.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.h"
 
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "net/base/file_stream.h"
+#include "base/string_util.h"

[wtc, 2011/01/20 00:29:47]

Nit: list this header in alphabetical order.

 #include "net/base/net_errors.h"
 
 namespace net {
 
 UploadData::Element::Element()
     : type_(TYPE_BYTES),
       file_range_offset_(0),
       file_range_length_(kuint64max),
       override_content_length_(false),
       content_length_computed_(false),
       content_length_(-1),
       file_stream_(NULL) {
 }
 
 UploadData::Element::~Element() {
   // In the common case |file__stream_| will be null.
   delete file_stream_;
 }
 
 uint64 UploadData::Element::GetContentLength() {
   if (override_content_length_ || content_length_computed_)
     return content_length_;
 
-  if (type_ == TYPE_BYTES)
+  if (type_ == TYPE_BYTES || type_ == TYPE_CHUNK)
     return static_cast<uint64>(bytes_.size());
   else if (type_ == TYPE_BLOB)
     // The blob reference will be resolved later.
     return 0;
 
   DCHECK_EQ(TYPE_FILE, type_);
   DCHECK(!file_stream_);
 
   // TODO(darin): This size calculation could be out of sync with the state of
   // the file when we get around to reading it.  We should probably find a way
@@ skipping 14 matching lines @@
     return 0;
 
   if (file_range_offset_ >= static_cast<uint64>(length))
     return 0;  // range is beyond eof
 
   // compensate for the offset and clip file_range_length_ to eof
   content_length_ =  std::min(length - file_range_offset_, file_range_length_);
   return content_length_;
 }
 
+void UploadData::Element::SetToChunk(const char* bytes, int bytes_len) {
+  std::string chunk_length = StringPrintf("%X\r\n", bytes_len);
+  bytes_.clear();
+  bytes_.insert(bytes_.end(), chunk_length.c_str(),
+                chunk_length.c_str() + chunk_length.length());

[wtc, 2011/01/20 00:29:47]

Nit: c_str() => data()

+  bytes_.insert(bytes_.end(), bytes, bytes + bytes_len);
+  const char* crlf = "\r\n";
+  bytes_.insert(bytes_.end(), crlf, crlf + 2);
+  type_ = TYPE_CHUNK;
+}
+
+void UploadData::Element::SetToEndOfChunksMarker() {
+  bytes_.clear();
+  type_ = TYPE_CHUNK;
+}
+
 FileStream* UploadData::Element::NewFileStreamForReading() {
   // In common usage GetContentLength() will call this first and store the
   // result into |file_| and a subsequent call (from UploadDataStream) will
   // get the cached open FileStream.
   if (file_stream_) {
     FileStream* file = file_stream_;
     file_stream_ = NULL;
     return file;
   }
 
@@ skipping 12 matching lines @@
       DLOG(WARNING) << "Failed to seek \"" << file_path_.value()
                     << "\" to offset: " << file_range_offset_ << " (" << rv
                     << ")";
       return NULL;
     }
   }
 
   return file.release();
 }
 
-UploadData::UploadData() : identifier_(0) {
+UploadData::UploadData()
+    : identifier_(0),
+      chunk_callback_(NULL),
+      is_chunked_(false) {
 }
 
 void UploadData::AppendBytes(const char* bytes, int bytes_len) {
+  DCHECK(!is_chunked_);
   if (bytes_len > 0) {
     elements_.push_back(Element());
     elements_.back().SetToBytes(bytes, bytes_len);
   }
 }
 
 void UploadData::AppendFile(const FilePath& file_path) {
+  DCHECK(!is_chunked_);
   elements_.push_back(Element());
   elements_.back().SetToFilePath(file_path);
 }
 
 void UploadData::AppendFileRange(const FilePath& file_path,
                                  uint64 offset, uint64 length,
                                  const base::Time& expected_modification_time) {
+  DCHECK(!is_chunked_);
   elements_.push_back(Element());
   elements_.back().SetToFilePathRange(file_path, offset, length,
                                       expected_modification_time);
 }
 
 void UploadData::AppendBlob(const GURL& blob_url) {
+  DCHECK(!is_chunked_);
   elements_.push_back(Element());
   elements_.back().SetToBlobUrl(blob_url);
 }
 
+void UploadData::AppendChunk(const char* bytes, int bytes_len) {
+  DCHECK(is_chunked_);
+  elements_.push_back(Element());
+  elements_.back().SetToChunk(bytes, bytes_len);
+  if (!bytes_len) {

[vandebo (ex-Chrome), 2011/01/18 21:51:17]

nit: This uses two Elements to represent the last chunk.  It might be more
intuitive to add a last chunk bool to Element.

[Satish, 2011/01/20 18:02:36]

I avoided doing that because it would take up unwanted space in each element,
whether or not chunked encoding was used. Almost all uses of this class would be
for non-chunked encoded data and when chunked encoding is used in speech we
might typically have dozens of chunks for a few seconds of audio. All of these
will have this flag set to false which seems like a waste of space.

[vandebo (ex-Chrome), 2011/01/20 20:48:45]

There are already several bools in the Element class.  Adding one more is
unlikely to change the storage size because compilers align fields in
structures.  If this was your only concern, then please consider changing it.

+    // End of chunked stream is marked by a chunk with an empty |bytes_|.

[wtc, 2011/01/20 00:29:47]

Nit: chunked stream => chunks

+    elements_.push_back(Element());
+    elements_.back().SetToEndOfChunksMarker();
+  }
+  if (chunk_callback_)
+    chunk_callback_->OnChunkAvailable();
+}
+
+void UploadData::set_chunk_callback(ChunkCallback* callback) {
+  DCHECK(!chunk_callback_);

[wtc, 2011/01/20 00:29:47]

IMPORTANT: I believe this DCHECK is too strong.  When you
rewind an upload data stream, you actually create a new
UploadDataStream object, which will call data_->set_chunk_callback
with a different 'callback' argument.

+  chunk_callback_ = callback;
+}
+
 uint64 UploadData::GetContentLength() {
+  DCHECK(!is_chunked_);
   uint64 len = 0;
   std::vector<Element>::iterator it = elements_.begin();
   for (; it != elements_.end(); ++it)
     len += (*it).GetContentLength();
   return len;
 }
 
 void UploadData::SetElements(const std::vector<Element>& elements) {
   elements_ = elements;
 }
 
 UploadData::~UploadData() {
 }
 
 }  // namespace net