Prototype of chunked transfer encoded POST.

net/url_request/url_request.h

Index: net/url_request/url_request.h
diff --git a/net/url_request/url_request.h b/net/url_request/url_request.h
index 3561a294624dccccc8eeb5d653a794eb13b10034..0b669cd4085d6a3a290dc02d74eda4893821cd89 100644
--- a/net/url_request/url_request.h
+++ b/net/url_request/url_request.h
@@ -312,6 +312,18 @@ class URLRequest : public base::NonThreadSafe {
     AppendFileRangeToUpload(file_path, 0, kuint64max, base::Time());
   }
 
+  // Appends the given bytes to the requests's POST data to be sent immediately
+  // and indicates that more data is yet to come. This is useful when the POST
+  // data is not available upfront when establishing the connection and as the
+  // data becomes available it can be sent to the server.

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

Nit: change "POST data" to "upload data" (two occurrences) in
this comment.

It seems that the main reason for chunked upload is that the
data is not available upfront, but rather that we want to
avoid the delay of buffering all the data.  If delay is not
an issue, you can accumulate all the data and then upload
it the old way.

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

Done.

+  //
+  // This method can be called only after a call to |set_chunked_upload(true)|

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

Typo: your set_chunked_upload method takes no argument.

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

Done.

+  // and |Start()|.
+  void AppendChunkToUpload(const char* bytes, int bytes_len);

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

This method seems different than the other AppendFoo methods.  Maybe different
enough that its name should not imply that it is the same as them?

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

Looking at the implementation I don't see why this method is very different from
the rest. Could you clarify?

+
+  // Indicate the end of a chunked-transfer encoded request body.

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

Nit: Indicate => Indicates

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

Done.

+  void MarkEndOfChunks();

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

Is it really worthwhile to provide this method?  Why not just note in the
comments for AppendChunkToUpload that a zero length chunk is needed to signal
the end of chunked-transfer?

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

The consumers of this class don't have to know about the chunked-transfer format
itself. Asking them to set 2 parameters to a magic value doesn't seem like a
good choice and brings memories of similar win32 apis :/ I could inline this
method if required so there is no change in terms of generated code.

+
   // Set the upload data directly.
   void set_upload(net::UploadData* upload);
 
@@ -429,6 +441,10 @@ class URLRequest : public base::NonThreadSafe {
   int load_flags() const { return load_flags_; }
   void set_load_flags(int flags) { load_flags_ = flags; }
 
+  // Indicates that the request body should be sent using Chunked-Transfer
+  // encoding.
+  void set_chunked_upload() { is_chunked_upload_ = true; }

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

Nit: set_chunked_upload => enable_chunked_upload
                        or set_is_chunked_upload

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

It seems that this logically belongs with the other AppendFoo methods. i.e. it
must be called before start.  Also, it seems that it should not be combined with
them?  If so, that should be noted.

While it is a simple setter, the affect on the underlying system is such that
maybe it shouldn't be named like a simple setter?

Should this also do the following, like the other AppendFoo methods?

  if (!upload_)
    upload_ = new UploadData();

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

Renamed to EnableChunkedUpload(), moved to .cc file and created UploadData in
there as suggested. This also meant I could remove the 'is_chunked_upload_' flag
now.

+
   // Returns true if the request is "pending" (i.e., if Start() has been called,
   // and the response has not yet been called).
   bool is_pending() const { return is_pending_; }
@@ -626,6 +642,10 @@ class URLRequest : public base::NonThreadSafe {
   // Whether to enable performance profiling on the job serving this request.
   bool enable_profiling_;
 
+  // Whether the upload data contains chunks of data (sent via
+  // Chunked-Transfer encoding).
+  bool is_chunked_upload_;
+
   // Number of times we're willing to redirect.  Used to guard against
   // infinite redirects.
   int redirect_limit_;