net: Change argument of URLRequest::set_upload from UploadData to UploadDataStream

webkit/glue/resource_request_body.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.
 
 #include "webkit/glue/resource_request_body.h"
 
 #include "base/logging.h"
-#include "net/base/upload_data.h"
+#include "net/base/upload_bytes_element_reader.h"
+#include "net/base/upload_data_stream.h"
+#include "net/base/upload_file_element_reader.h"
 #include "webkit/blob/blob_storage_controller.h"
 
 using webkit_blob::BlobData;
 using webkit_blob::BlobStorageController;
 
 namespace webkit_glue {
 
+namespace {
+
+// A subclass of net::UploadBytesElementReader which owns ResourceRequestBody.
+class BytesElementReader : public net::UploadBytesElementReader {
+ public:
+  BytesElementReader(ResourceRequestBody* resource_request_body,
+                     const ResourceRequestBody::Element& element)
+      : net::UploadBytesElementReader(element.bytes(), element.length()),
+        resource_request_body_(resource_request_body) {
+    DCHECK_EQ(ResourceRequestBody::Element::TYPE_BYTES, element.type());
+  }
+
+  virtual ~BytesElementReader() {}
+
+ private:
+  scoped_refptr<ResourceRequestBody> resource_request_body_;
+
+  DISALLOW_COPY_AND_ASSIGN(BytesElementReader);
+};
+
+// A subclass of net::UploadFileElementReader which owns ResourceRequestBody.
+// This class is necessary to ensure the BlobData and any attached shareable
+// files survive until upload completion.
+class FileElementReader : public net::UploadFileElementReader {
+ public:
+  FileElementReader(ResourceRequestBody* resource_request_body,
+                    const ResourceRequestBody::Element& element)
+      : net::UploadFileElementReader(element.path(),
+                                     element.offset(),
+                                     element.length(),
+                                     element.expected_modification_time()),
+        resource_request_body_(resource_request_body) {
+    DCHECK_EQ(ResourceRequestBody::Element::TYPE_FILE, element.type());
+  }
+
+  virtual ~FileElementReader() {}
+
+ private:
+  scoped_refptr<ResourceRequestBody> resource_request_body_;
+
+  DISALLOW_COPY_AND_ASSIGN(FileElementReader);
+};
+
+}  // namespace
+
 ResourceRequestBody::ResourceRequestBody() : identifier_(0) {}
 
 void ResourceRequestBody::AppendBytes(const char* bytes, int bytes_len) {
   if (bytes_len > 0) {
     elements_.push_back(Element());
     elements_.back().SetToBytes(bytes, bytes_len);
   }
 }
 
 void ResourceRequestBody::AppendFileRange(
@@ skipping 11 matching lines @@
 }
 
 void ResourceRequestBody::AppendFileSystemFileRange(
     const GURL& url, uint64 offset, uint64 length,
     const base::Time& expected_modification_time) {
   elements_.push_back(Element());
   elements_.back().SetToFileSystemUrlRange(url, offset, length,
                                            expected_modification_time);
 }
 
-net::UploadData* ResourceRequestBody::ResolveElementsAndCreateUploadData(
+net::UploadDataStream*
+ResourceRequestBody::ResolveElementsAndCreateUploadDataStream(
     BlobStorageController* blob_controller) {
   // Resolve all blob elements.
   std::vector<const Element*> resolved_elements;
   for (size_t i = 0; i < elements_.size(); ++i) {
     const Element& element = elements_[i];
     if (element.type() == Element::TYPE_BLOB) {
       ResolveBlobReference(blob_controller, element.url(), &resolved_elements);
     } else {
       // No need to resolve, just append the element.
       resolved_elements.push_back(&element);
     }
   }
 
-  net::UploadData* upload_data = new net::UploadData;
-  // We attach 'this' to UploadData so that we do not need to copy
-  // bytes for TYPE_BYTES.
-  upload_data->SetUserData(
-      this, new base::UserDataAdapter<ResourceRequestBody>(this));
-  ScopedVector<net::UploadElement>* elements =
-      upload_data->elements_mutable();
+  ScopedVector<net::UploadElementReader> element_readers;
   for (size_t i = 0; i < resolved_elements.size(); ++i) {
     const Element& element = *resolved_elements[i];
     switch (element.type()) {
       case Element::TYPE_BYTES:
-        elements->push_back(new net::UploadElement());
-        elements->back()->SetToSharedBytes(element.bytes(), element.length());
+        element_readers.push_back(new BytesElementReader(this, element));
         break;
       case Element::TYPE_FILE:
-        elements->push_back(new net::UploadElement());
-        elements->back()->SetToFilePathRange(
-            element.path(),
-            element.offset(),
-            element.length(),
-            element.expected_modification_time());
+        element_readers.push_back(new FileElementReader(this, element));
         break;
       case Element::TYPE_FILE_FILESYSTEM:
         // TODO(kinuko): Resolve FileSystemURL before creating UploadData.
         NOTREACHED();
         break;
       case Element::TYPE_BLOB:
         // Blob elements should be resolved beforehand.
         NOTREACHED();
         break;
       case Element::TYPE_UNKNOWN:
         NOTREACHED();
         break;
     }
   }
-  upload_data->set_identifier(identifier_);
-  return upload_data;
+  return new net::UploadDataStream(&element_readers, identifier_);
 }
 
 ResourceRequestBody::~ResourceRequestBody() {}
 
 void ResourceRequestBody::ResolveBlobReference(
     webkit_blob::BlobStorageController* blob_controller,
     const GURL& blob_url,
     std::vector<const Element*>* resolved_elements) {
   DCHECK(blob_controller);
   BlobData* blob_data = blob_controller->GetBlobDataFromUrl(blob_url);
@@ skipping 11 matching lines @@
 
   // Append the elements in the referred blob data.
   for (size_t i = 0; i < blob_data->items().size(); ++i) {
     const BlobData::Item& item = blob_data->items().at(i);
     DCHECK_NE(BlobData::Item::TYPE_BLOB, item.type());
     resolved_elements->push_back(&item);
   }
 }
 
 }  // namespace webkit_glue