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"

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

This header isn't needed.

 #include "base/time.h"
 
 namespace net {
 
 class FileStream;
 
 class UploadData : public base::RefCounted<UploadData> {
  public:
   enum Type {
     TYPE_BYTES,
     TYPE_FILE,
-    TYPE_BLOB
+    TYPE_BLOB,
+
+    // A block of bytes to be sent in chunked encoding immediately, without
+    // waiting for rest of the data.
+    TYPE_CHUNK,
+  };
+
+  // Interface implemented by callers who require callbacks when new chunks
+  // of data are received.

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

Nit: received => added

Make the same change to upload_data_stream.h.

+  class ChunkCallback {

[willchan no longer on Chromium, 2011/01/20 08:51:04]

I don't understand this. Why don't you just typedef Callback0::Type to
ChunkCallback? Then you could also use ScopedCallbackFactory to make the
callback cancelation safe. This seems like it could be dangerous if it lives
longer than the UploadDataStream.

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

I used a callback initially and was suggested an interface was more suitable
here. I do agree on the live-longer-than-ChunkCallback part. @wtc, would you be
ok if I switched to a Callback as willchan suggests?

[vandebo (ex-Chrome), 2011/01/21 18:08:41]

Will implied that using Callback0::Type would would be safer in some ways.  Was
this resolved out of band?

[willchan no longer on Chromium, 2011/01/21 18:16:19]

Callback0::Type by itself isn't safer. But ScopedCallbackFactory will produce
callbacks of type Callback0::Type, so switching to Callback0::Type lets us use
ScopedCallbackFactory in UploadDataStream. The problem is, if UploadDataStream
is destroyed before UploadData is (it's not immediately clear to me the lifetime
semantics since this is refcounted), then calling into the chunk callback may
call into a dead object.

That said, it occurs to me now that that would require the callback to be heap
allocated, so UploadData would have to own the callback. Perhaps it's simply
better for UploadDataStream to call set_callback(NULL).

+   public:
+    // Invoked when a new data chunk was given for a chunked transfer upload.
+    virtual void OnChunkAvailable() = 0;
+
+   protected:
+    virtual ~ChunkCallback() {}
   };
 
   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_; }
@@ skipping 27 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 is sent via

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

Nit: stream => element

+    // chunked transfer encoding and not buffered until the full upload data
+    // is available.
+    void SetToChunk(const char* bytes, int bytes_len);
+
+    void SetToEndOfChunksMarker();
+
     // 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

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

Nit: receive => send ?

+  // than all at once.
+  void set_is_chunked(bool set) { is_chunked_ = set; }
+  bool is_chunked() const { return is_chunked_; }
+
   // 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_