Prototype of chunked transfer encoded POST.

net/base/upload_data.h

 // 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.
 
 #ifndef NET_BASE_UPLOAD_DATA_H_
 #define NET_BASE_UPLOAD_DATA_H_
 #pragma once
 
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/file_path.h"
 #include "base/gtest_prod_util.h"
 #include "base/ref_counted.h"
 #include "googleurl/src/gurl.h"
+#include "net/base/completion_callback.h"
 #include "base/time.h"
 
 namespace net {
 
 class FileStream;
 
 class UploadData : public base::RefCounted<UploadData> {
  public:
   enum Type {
     TYPE_BYTES,
+    TYPE_CHUNK,  // More data is to come and this should be sent immediately.

[wtc, 2011/01/14 03:09:31]

The comment should say:
  The data should be sent in chunked encoding immediately,
  without waiting for the other data.

"More data is to come" is confusing because it can be said
of the other types of data.  For example, SetToBytes can be
called multiple times, which means after each SetToBytes
call, more data is to come.

[Satish, 2011/01/14 18:09:29]

Done.

     TYPE_FILE,
     TYPE_BLOB
   };
 
+  // Interface implemented by callers who require callbacks when new chunks
+  // of data are received.

[vandebo (ex-Chrome), 2011/01/14 05:53:44]

Note, applies only for TYPE_CHUNK.

+  class ChunkCallback {
+   public:
+    // Invoked when a new data chunk was given for a chunked transfer upload.
+    virtual void OnChunkAvailable() = 0;
+
+   protected:
+    virtual ~ChunkCallback() {}

[vandebo (ex-Chrome), 2011/01/14 05:53:44]

Does this need an implementation?  If so, shouldn't it be in the .cc file?

+  };
+
   class Element {
    public:
     Element();
     ~Element();
 
     Type type() const { return type_; }
     const std::vector<char>& bytes() const { return bytes_; }
     const FilePath& file_path() const { return file_path_; }
     uint64 file_range_offset() const { return file_range_offset_; }
     uint64 file_range_length() const { return file_range_length_; }
@@ skipping 25 matching lines @@
       expected_file_modification_time_ = expected_modification_time;
     }
 
     // TODO(jianli): UploadData should not contain any blob reference. We need
     // to define another structure to represent WebKit::WebHTTPBody.
     void SetToBlobUrl(const GURL& blob_url) {
       type_ = TYPE_BLOB;
       blob_url_ = blob_url;
     }
 
+    // Though similar to bytes, a chunk indicates that the stream has more such
+    // items after this item.

[wtc, 2011/01/14 03:09:31]

Again, the difference is that a chunk should be sent in
chunked encoding, and without waiting for the other chunks.

The fact that the stream has more such items after this item
is also true of bytes.

[Satish, 2011/01/14 18:09:29]

Done.

+    void SetToChunk(const char* bytes, int bytes_len);
+
+    // Identifies this element as the last item in a series of chunks.
+    void SetToLastChunk();
+
     // Returns the byte-length of the element.  For files that do not exist, 0
     // is returned.  This is done for consistency with Mozilla.
     // Once called, this function will always return the same value.
     uint64 GetContentLength();
 
     // Returns a FileStream opened for reading for this element, positioned at
     // |file_range_offset_|.  The caller gets ownership and is responsible
     // for cleaning up the FileStream. Returns NULL if this element is not of
     // type TYPE_FILE or if the file is not openable.
     FileStream* NewFileStreamForReading();
@@ skipping 27 matching lines @@
   void AppendBytes(const char* bytes, int bytes_len);
 
   void AppendFile(const FilePath& file_path);
 
   void AppendFileRange(const FilePath& file_path,
                        uint64 offset, uint64 length,
                        const base::Time& expected_modification_time);
 
   void AppendBlob(const GURL& blob_url);
 
+  void AppendChunk(const char* bytes, int bytes_len);
+
+  // Sets the callback to be invoked when a new chunk is available to upload.
+  void set_chunk_callback(ChunkCallback* callback);
+
+  // Iniitalizes the object to receive chunks of upload data over time rather
+  // than all at once.
+  void set_is_chunked(bool set) { is_chunked_ = set; }
+  bool is_chunked() { return is_chunked_; }

[wtc, 2011/01/14 03:09:31]

Nit: mark this method 'const'.

[Satish, 2011/01/14 18:09:29]

Done.

+
   // Returns the total size in bytes of the data to upload.
   uint64 GetContentLength();
 
   std::vector<Element>* elements() {
     return &elements_;
   }
 
   void SetElements(const std::vector<Element>& elements);
 
   void swap_elements(std::vector<Element>* elements) {
     elements_.swap(*elements);
   }
 
   // Identifies a particular upload instance, which is used by the cache to
   // formulate a cache key.  This value should be unique across browser
   // sessions.  A value of 0 is used to indicate an unspecified identifier.
   void set_identifier(int64 id) { identifier_ = id; }
   int64 identifier() const { return identifier_; }
 
  private:
   friend class base::RefCounted<UploadData>;
 
   ~UploadData();
 
   std::vector<Element> elements_;
   int64 identifier_;
+  ChunkCallback* chunk_callback_;
+  bool is_chunked_;
 
   DISALLOW_COPY_AND_ASSIGN(UploadData);
 };
 
 #if defined(UNIT_TEST)
 inline bool operator==(const UploadData::Element& a,
                        const UploadData::Element& b) {
   if (a.type() != b.type())
     return false;
   if (a.type() == UploadData::TYPE_BYTES)
@@ skipping 12 matching lines @@
 
 inline bool operator!=(const UploadData::Element& a,
                        const UploadData::Element& b) {
   return !(a == b);
 }
 #endif  // defined(UNIT_TEST)
 
 }  // namespace net
 
 #endif  // NET_BASE_UPLOAD_DATA_H_