Split net::UploadData into two: for IPC and for upload handling

content/common/resource_dispatcher.cc

 // Copyright (c) 2012 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.
 
 // See http://dev.chromium.org/developers/design-documents/multi-process-resource-loading
 
 #include "content/common/resource_dispatcher.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/file_path.h"
 #include "base/message_loop.h"
 #include "base/shared_memory.h"
 #include "base/string_util.h"
 #include "content/common/inter_process_time_ticks_converter.h"
 #include "content/common/request_extra_data.h"
 #include "content/common/resource_messages.h"
 #include "content/public/common/resource_dispatcher_delegate.h"
 #include "content/public/common/resource_response.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
-#include "net/base/upload_data.h"
 #include "net/http/http_response_headers.h"
+#include "webkit/glue/resource_request_body.h"
 #include "webkit/glue/resource_type.h"
 
 using webkit_glue::ResourceLoaderBridge;
+using webkit_glue::ResourceRequestBody;
 using webkit_glue::ResourceResponseInfo;
 
 namespace content {
 
 // Each resource request is assigned an ID scoped to this process.
 static int MakeRequestID() {
   // NOTE: The resource_dispatcher_host also needs probably unique
   // request_ids, so they count down from -2 (-1 is a special we're
   // screwed value), while the renderer process counts up.
   static int next_request_id = 0;
   return next_request_id++;
 }
 
 // ResourceLoaderBridge implementation ----------------------------------------
 
 class IPCResourceLoaderBridge : public ResourceLoaderBridge {
  public:
   IPCResourceLoaderBridge(ResourceDispatcher* dispatcher,
       const ResourceLoaderBridge::RequestInfo& request_info);
   virtual ~IPCResourceLoaderBridge();
 
   // ResourceLoaderBridge
-  virtual void AppendDataToUpload(const char* data, int data_len);
-  virtual void AppendFileRangeToUpload(
-      const FilePath& path,
-      uint64 offset,
-      uint64 length,
-      const base::Time& expected_modification_time);
-  virtual void AppendBlobToUpload(const GURL& blob_url);
-  virtual void SetUploadIdentifier(int64 identifier);
+  virtual void SetRequestBody(ResourceRequestBody* request_body);
   virtual bool Start(Peer* peer);
   virtual void Cancel();
   virtual void SetDefersLoading(bool value);
   virtual void SyncLoad(SyncLoadResponse* response);
 
  private:
   ResourceLoaderBridge::Peer* peer_;
 
   // The resource dispatcher for this loader.  The bridge doesn't own it, but
   // it's guaranteed to outlive the bridge.
@@ skipping 67 matching lines @@
     // removed us when the renderer sends the ReceivedAllData message.
     dispatcher_->RemovePendingRequest(request_id_);
 
     if (request_.download_to_file) {
       dispatcher_->message_sender()->Send(
           new ResourceHostMsg_ReleaseDownloadedFile(request_id_));
     }
   }
 }
 
-void IPCResourceLoaderBridge::AppendDataToUpload(const char* data,
-                                                 int data_len) {
+void IPCResourceLoaderBridge::SetRequestBody(
+    ResourceRequestBody* request_body) {
   DCHECK(request_id_ == -1) << "request already started";
-
-  // don't bother appending empty data segments
-  if (data_len == 0)
-    return;
-
-  if (!request_.upload_data)
-    request_.upload_data = new net::UploadData();
-  request_.upload_data->AppendBytes(data, data_len);
-}
-
-void IPCResourceLoaderBridge::AppendFileRangeToUpload(
-    const FilePath& path, uint64 offset, uint64 length,
-    const base::Time& expected_modification_time) {
-  DCHECK(request_id_ == -1) << "request already started";
-
-  if (!request_.upload_data)
-    request_.upload_data = new net::UploadData();
-  request_.upload_data->AppendFileRange(path, offset, length,
-                                        expected_modification_time);
-}
-
-void IPCResourceLoaderBridge::AppendBlobToUpload(const GURL& blob_url) {
-  DCHECK(request_id_ == -1) << "request already started";
-
-  if (!request_.upload_data)
-    request_.upload_data = new net::UploadData();
-  request_.upload_data->AppendBlob(blob_url);
-}
-
-void IPCResourceLoaderBridge::SetUploadIdentifier(int64 identifier) {
-  DCHECK(request_id_ == -1) << "request already started";
-
-  if (!request_.upload_data)
-    request_.upload_data = new net::UploadData();
-  request_.upload_data->set_identifier(identifier);
+  request_.request_body = request_body;
 }
 
 // Writes a footer on the message and sends it
 bool IPCResourceLoaderBridge::Start(Peer* peer) {
   if (request_id_ != -1) {
     NOTREACHED() << "Starting a request twice";
     return false;
   }
 
   peer_ = peer;
@@ skipping 511 matching lines @@
 void ResourceDispatcher::ReleaseResourcesInMessageQueue(MessageQueue* queue) {
   while (!queue->empty()) {
     IPC::Message* message = queue->front();
     ReleaseResourcesInDataMessage(*message);
     queue->pop_front();
     delete message;
   }
 }
 
 }  // namespace content