Add chunked uploads support to SPDY

chrome/common/net/url_fetcher.cc

 // 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.
 
 #include "chrome/common/net/url_fetcher.h"
 
 #include <set>
 
 #include "base/compiler_specific.h"
 #include "base/lazy_instance.h"
@@ skipping 83 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 CompleteAddingUploadDataChunk(const std::string& data);
+  void CompleteAddingUploadDataChunk(const std::string& data,
+                                     bool is_last_chunk);
 
   // Adds a block of data to be uploaded in a POST body. This can only be called
   // after Start().
-  void AppendChunkToUpload(const std::string& data);
+  void AppendChunkToUpload(const std::string& data, bool is_last_chunk);
 
   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_;
@@ skipping 165 matching lines @@
   // 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::CompleteAddingUploadDataChunk(
-    const std::string& content) {
+    const std::string& content, bool is_last_chunk) {
   DCHECK(is_chunked_upload_);
   DCHECK(request_.get());
-  if (content.length()) {
-    request_->AppendChunkToUpload(content.data(),
-                                  static_cast<int>(content.length()));
-  } else {
-    request_->MarkEndOfChunks();
-  }
+  DCHECK(!content.empty());
+  request_->AppendChunkToUpload(content.data(),
+                                static_cast<int>(content.length()),
+                                is_last_chunk);
 }
 
-void URLFetcher::Core::AppendChunkToUpload(const std::string& content) {
+void URLFetcher::Core::AppendChunkToUpload(const std::string& content,
+                                           bool is_last_chunk) {
   DCHECK(delegate_loop_proxy_);
   CHECK(io_message_loop_proxy_.get());
   io_message_loop_proxy_->PostTask(
       FROM_HERE,
-      NewRunnableMethod(this, &Core::CompleteAddingUploadDataChunk, content));
+      NewRunnableMethod(this, &Core::CompleteAddingUploadDataChunk, content,
+                        is_last_chunk));
 }
 
 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_);
@@ skipping 192 matching lines @@
 
 void URLFetcher::set_chunked_upload(const std::string& content_type) {
   DCHECK(core_->is_chunked_upload_ ||
          (core_->upload_content_type_.empty() &&
           core_->upload_content_.empty()));
   core_->upload_content_type_ = content_type;
   core_->upload_content_.clear();
   core_->is_chunked_upload_ = true;
 }
 
-void URLFetcher::AppendChunkToUpload(const std::string& data) {
+void URLFetcher::AppendChunkToUpload(const std::string& data,
+                                     bool is_last_chunk) {
   DCHECK(data.length());
-  core_->AppendChunkToUpload(data);
-}
-
-void URLFetcher::MarkEndOfChunks() {
-  core_->AppendChunkToUpload(std::string());
+  core_->AppendChunkToUpload(data, is_last_chunk);
 }
 
 const std::string& URLFetcher::upload_data() const {
   return core_->upload_content_;
 }
 
 void URLFetcher::set_referrer(const std::string& referrer) {
   core_->referrer_ = referrer;
 }
 
@@ skipping 37 matching lines @@
 }
 
 // static
 void URLFetcher::CancelAll() {
   Core::CancelAll();
 }
 
 URLFetcher::Delegate* URLFetcher::delegate() const {
   return core_->delegate();
 }