Prototype of chunked transfer encoded POST.

chrome/common/net/url_fetcher.cc

 // 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.
 
 #include "chrome/common/net/url_fetcher.h"
 
 #include <set>
 
 #include "base/compiler_specific.h"
 #include "base/lazy_instance.h"
@@ skipping 84 matching lines @@
   void NotifyMalformedContent();
 
   // Deletes the request, removes it from the registry, and removes the
   // destruction observer.
   void ReleaseRequest();
 
   // Returns the max value of exponential back-off release time for
   // |original_url_| and |url_|.
   base::TimeTicks GetBackoffReleaseTime();
 
+  void AddUploadDataChunkInThread(const std::string& data);
+
+  // Adds a block of data to be uploaded in a POST body. This can be called
+  // before or after Start() is called.
+  void AppendChunkToUpload(const std::string& data);
+  void MarkEndOfChunks();
+
   URLFetcher* fetcher_;              // Corresponding fetcher object
   GURL original_url_;                // The URL we were asked to fetch
   GURL url_;                         // The URL we eventually wound up at
   RequestType request_type_;         // What type of request is this?
   URLFetcher::Delegate* delegate_;   // Object to notify on completion
   scoped_refptr<base::MessageLoopProxy> delegate_loop_proxy_;
                                      // Message loop proxy of the creating
                                      // thread.
   scoped_refptr<base::MessageLoopProxy> io_message_loop_proxy_;
                                      // The message loop proxy for the thread
                                      // on which the request IO happens.
   scoped_ptr<net::URLRequest> request_;   // The actual request this wraps
   int load_flags_;                   // Flags for the load operation
   int response_code_;                // HTTP status code for the request
   std::string data_;                 // Results of the request
   scoped_refptr<net::IOBuffer> buffer_;
                                      // Read buffer
   scoped_refptr<URLRequestContextGetter> request_context_getter_;
                                      // Cookie/cache info for the request
   ResponseCookies cookies_;          // Response cookies
   net::HttpRequestHeaders extra_request_headers_;
   scoped_refptr<net::HttpResponseHeaders> response_headers_;
 
   std::string upload_content_;       // HTTP POST payload
   std::string upload_content_type_;  // MIME type of POST payload
+  bool upload_in_chunks_;            // True if using chunked transfer encoding
 
   // Used to determine how long to wait before making a request or doing a
   // retry.
   // Both of them can only be accessed on the IO thread.
   // We need not only the throttler entry for |original_URL|, but also the one
   // for |url|. For example, consider the case that URL A redirects to URL B,
   // for which the server returns a 500 response. In this case, the exponential
   // back-off release time of URL A won't increase. If we retry without
   // considering the back-off constraint of URL B, we may send out too many
   // requests for URL A in a short period of time.
@@ skipping 75 matching lines @@
     : fetcher_(fetcher),
       original_url_(original_url),
       request_type_(request_type),
       delegate_(d),
       delegate_loop_proxy_(base::MessageLoopProxy::CreateForCurrentThread()),
       request_(NULL),
       load_flags_(net::LOAD_NORMAL),
       response_code_(-1),
       buffer_(new net::IOBuffer(kBufferSize)),
       num_retries_(0),
+      upload_in_chunks_(false),
       was_cancelled_(false) {
 }
 
 URLFetcher::Core::~Core() {
   // |request_| should be NULL.  If not, it's unsafe to delete it here since we
   // may not be on the IO thread.
   DCHECK(!request_.get());
 }
 
 void URLFetcher::Core::Start() {
@@ skipping 40 matching lines @@
   int bytes_read = 0;
   // Some servers may treat HEAD requests as GET requests.  To free up the
   // network connection as soon as possible, signal that the request has
   // completed immediately, without trying to read any data back (all we care
   // about is the response code and headers, which we already have).
   if (request_->status().is_success() && (request_type_ != HEAD))
     request_->Read(buffer_, kBufferSize, &bytes_read);
   OnReadCompleted(request_.get(), bytes_read);
 }
 
+void URLFetcher::Core::AddUploadDataChunkInThread(const std::string& content) {
+  DCHECK(upload_in_chunks_);
+  DCHECK(request_.get());
+  if (content.length() > 0) {
+    request_->AppendChunkToUpload(content.data(),
+                                  static_cast<int>(content.size()));
+  } else {
+    request_->MarkEndOfChunks();
+  }
+}
+
+void URLFetcher::Core::AppendChunkToUpload(const std::string& content) {
+  DCHECK(content.length() > 0);
+  DCHECK(delegate_loop_proxy_);
+  CHECK(io_message_loop_proxy_.get());
+  io_message_loop_proxy_->PostTask(
+      FROM_HERE,
+      NewRunnableMethod(this, &Core::AddUploadDataChunkInThread, content));
+}
+
+void URLFetcher::Core::MarkEndOfChunks() {
+  DCHECK(delegate_loop_proxy_);
+  CHECK(io_message_loop_proxy_.get());
+  std::string empty;
+  io_message_loop_proxy_->PostTask(
+      FROM_HERE,
+      NewRunnableMethod(this, &Core::AddUploadDataChunkInThread, empty));
+}
+
 void URLFetcher::Core::OnReadCompleted(net::URLRequest* request,
                                        int bytes_read) {
   DCHECK(request == request_);
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
 
   url_ = request->url();
   url_throttler_entry_ =
       net::URLRequestThrottlerManager::GetInstance()->RegisterRequestUrl(url_);
 
   do {
@@ skipping 32 matching lines @@
 
   CHECK(request_context_getter_);
   DCHECK(!request_.get());
 
   g_registry.Get().AddURLFetcherCore(this);
   request_.reset(new net::URLRequest(original_url_, this));
   int flags = request_->load_flags() | load_flags_;
   if (!g_interception_enabled) {
     flags = flags | net::LOAD_DISABLE_INTERCEPT;
   }
+  if (upload_in_chunks_)
+    request_->set_chunked_transfer_upload();
   request_->set_load_flags(flags);
   request_->set_context(request_context_getter_->GetURLRequestContext());
 
   switch (request_type_) {
     case GET:
       break;
 
     case POST:
-      DCHECK(!upload_content_.empty());
+      DCHECK(!upload_content_.empty() || upload_in_chunks_);
       DCHECK(!upload_content_type_.empty());
 
       request_->set_method("POST");
       extra_request_headers_.SetHeader(net::HttpRequestHeaders::kContentType,
                                        upload_content_type_);
-      request_->AppendBytesToUpload(upload_content_.data(),
-                                    static_cast<int>(upload_content_.size()));
+      if (!upload_content_.empty()) {
+        request_->AppendBytesToUpload(upload_content_.data(),
+                                      static_cast<int>(upload_content_.size()));
+      }
       break;
 
     case HEAD:
       request_->set_method("HEAD");
       break;
 
     default:
       NOTREACHED();
   }
 
@@ skipping 104 matching lines @@
   }
 
   return original_url_backoff > destination_url_backoff ?
       original_url_backoff : destination_url_backoff;
 }
 
 void URLFetcher::set_upload_data(const std::string& upload_content_type,
                                  const std::string& upload_content) {
   core_->upload_content_type_ = upload_content_type;
   core_->upload_content_ = upload_content;
+  core_->upload_in_chunks_ = false;
+}
+
+void URLFetcher::set_chunked_transfer_upload(const std::string& content_type) {
+  core_->upload_content_type_ = content_type;
+  core_->upload_in_chunks_ = true;
+}
+
+void URLFetcher::AppendChunkToUpload(const std::string& data) {
+  core_->AppendChunkToUpload(data);
+}
+
+void URLFetcher::MarkEndOfChunks() {
+  core_->MarkEndOfChunks();
 }
 
 const std::string& URLFetcher::upload_data() const {
   return core_->upload_content_;
 }
 
 void URLFetcher::set_load_flags(int load_flags) {
   core_->load_flags_ = load_flags;
 }
 
@@ skipping 33 matching lines @@
 }
 
 // static
 void URLFetcher::CancelAll() {
   Core::CancelAll();
 }
 
 URLFetcher::Delegate* URLFetcher::delegate() const {
   return core_->delegate();
 }