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 and adds an indication
+  // that more is to come. This is useful when the POST data is not available

[wtc, 2011/01/12 02:39:02]

I think "more is to come" is less useful info than "send the
chunk to the server immediately", so this comment could be
improved.

Document the MarkEndOfChunks method.  Alternatively, just
use a AppendChunkToUpload(NULL, 0) call to mark the end of
chunks.

Compared with the AppendXXXToUpload methods above, it's
important to point out that AppendChunkToUpload may only
be called after Start() is called.

Also, since you have a chunked_transfer_upload_ mode, why
don't you just reuse the existing AppendBytesToUpload method
to append a chunk?

[Satish, 2011/01/13 17:43:27]

Done
Documented. I prefer to not reuse AppendChunkToUpload with those magic values
since that requires the caller to know how the POST body is encoded.
Done
UploadData is the one which does the encoding of the chunks, prefixing them with
length+cr+lf and appending them with cr+lf. I've kept all other classes as
agnostic to the POST body format as possible.

+  // upfront when establishing the connection and as the data becomes available
+  // it can be sent to the server.
+  // This method should be called ONLY after calling Start().
+  void AppendChunkToUpload(const char* bytes, int bytes_len);
+  void MarkEndOfChunks();
+
   // 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; }
 
+  void set_chunked_transfer_upload() { chunked_transfer_upload_ = true; }
+
   // 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 chunked_transfer_upload_;

[wtc, 2011/01/12 02:39:02]

Nit: shorten this to chunked_upload_ (and the setter to
set_chunked_upload).

[Satish, 2011/01/13 17:43:27]

Done.

+
   // 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_