Prototype of chunked transfer encoded POST.

net/url_request/url_request.h

 // Copyright (c) 2011 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_URL_REQUEST_URL_REQUEST_H_
 #define NET_URL_REQUEST_URL_REQUEST_H_
 #pragma once
 
 #include <map>
 #include <string>
@@ skipping 294 matching lines @@
   // check if the underlying file has been changed or not. The granularity of
   // the time comparison is 1 second since time_t precision is used in WebKit.
   void AppendBytesToUpload(const char* bytes, int bytes_len);  // takes a copy
   void AppendFileRangeToUpload(const FilePath& file_path,
                                uint64 offset, uint64 length,
                                const base::Time& expected_modification_time);
   void AppendFileToUpload(const FilePath& file_path) {
     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);
 
   // Get the upload data directly.
   net::UploadData* get_upload();
 
   // Returns true if the request has a non-empty message body to upload.
   bool has_upload() const;
 
   // Set an extra request header by ID or name.  These methods may only be
@@ skipping 97 matching lines @@
   // called.  For non-HTTP requests, this method returns -1.
   int GetResponseCode();
 
   // Get the HTTP response info in its entirety.
   const net::HttpResponseInfo& response_info() const { return response_info_; }
 
   // Access the net::LOAD_* flags modifying this request (see load_flags.h).
   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_; }
 
   // Returns the error status of the request.
   const net::URLRequestStatus& status() const { return status_; }
 
   // This method is called to start the request.  The delegate will receive
   // a OnResponseStarted callback when the request is started.
   void Start();
@@ skipping 177 matching lines @@
   // whether the job is active.
   bool is_pending_;
 
   // Externally-defined data accessible by key
   typedef std::map<const void*, linked_ptr<UserData> > UserDataMap;
   UserDataMap user_data_;
 
   // 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_;
 
   // Cached value for use after we've orphaned the job handling the
   // first transaction in a request involving redirects.
   uint64 final_upload_progress_;
 
   // The priority level for this request.  Objects like ClientSocketPool use
   // this to determine which URLRequest to allocate sockets to first.
   net::RequestPriority priority_;
 
   base::debug::LeakTracker<URLRequest> leak_tracker_;
 
   DISALLOW_COPY_AND_ASSIGN(URLRequest);
 };
 
 }  // namespace net
 
 #endif  // NET_URL_REQUEST_URL_REQUEST_H_