net: Make UploadDataStream independent from UploadData

Change argument of UploadDataStream's ctor from UploadData to ScopedVector<UploadElementReader>
Move chunk related logic from UploadData to UploadDataStream.
Move UploadElementReader creation code from UploadElementReader::Create to URLRequest::set_upload. (this code will soon be moved again to src/webkit/glue/resource_request_body.cc)

BUG=156574
TEST=net_unittests
TBR=jam@chromium.org for chrome/browser/automation (already reviewed by ananta@)

Review URL: https://chromiumcodereview.appspot.com/11419220

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@172295 0039d316-1c4b-4281-b951-d872f2087c98

17 files changed, 388 insertions, 415 deletions

diff --git a/net/base/upload_data.cc b/net/base/upload_data.cc
index 91923a5..5c53e08 100644
--- a/net/base/upload_data.cc
+++ b/net/base/upload_data.cc
@@ -4,10 +4,7 @@
 
 #include "net/base/upload_data.h"
 
-#include "base/bind.h"
-#include "base/location.h"
 #include "base/logging.h"
-#include "base/threading/worker_pool.h"
 
 namespace net {
 
@@ -34,22 +31,6 @@ void UploadData::AppendFileRange(const FilePath& file_path,
                                        expected_modification_time);
 }
 
-void UploadData::AppendChunk(const char* bytes,
-                             int bytes_len,
-                             bool is_last_chunk) {
-  DCHECK(is_chunked_);
-  DCHECK(!last_chunk_appended_);
-  elements_.push_back(new UploadElement());
-  elements_.back()->SetToBytes(bytes, bytes_len);
-  last_chunk_appended_ = is_last_chunk;
-  if (!chunk_callback_.is_null())
-    chunk_callback_.Run();
-}
-
-void UploadData::set_chunk_callback(const base::Closure& callback) {
-  chunk_callback_ = callback;
-}
-
 UploadData::~UploadData() {
 }
 
diff --git a/net/base/upload_data.h b/net/base/upload_data.h
index 2f0494c..4e6c6ca 100644
--- a/net/base/upload_data.h
+++ b/net/base/upload_data.h
@@ -6,7 +6,6 @@
 #define NET_BASE_UPLOAD_DATA_H_
 
 #include "base/basictypes.h"
-#include "base/callback.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_vector.h"
 #include "base/supports_user_data.h"
@@ -28,10 +27,6 @@ namespace net {
 // Until there is a more abstract class for this, this one derives from
 // SupportsUserData to allow users to stash random data by
 // key and ensure its destruction when UploadData is finally deleted.
-//
-// Chunked uploads are handled by repeatedly calling AppendChunk() as data
-// becomes available, which adds to |elements_|.  Whenever this happens,
-// |chunk_callback_| is called, if non-NULL.
 class NET_EXPORT UploadData
     : public base::RefCounted<UploadData>,
       public base::SupportsUserData {
@@ -44,13 +39,6 @@ class NET_EXPORT UploadData
                        uint64 offset, uint64 length,
                        const base::Time& expected_modification_time);
 
-  // Adds the given chunk of bytes to be sent immediately with chunked transfer
-  // encoding.
-  void AppendChunk(const char* bytes, int bytes_len, bool is_last_chunk);
-
-  // Sets the callback to be invoked when a new chunk is available to upload.
-  void set_chunk_callback(const base::Closure& callback);
-
   // Initializes the object to send chunks of upload data over time rather
   // than all at once. Chunked data may only contain bytes, not files.
   void set_is_chunked(bool set) { is_chunked_ = set; }
@@ -85,7 +73,6 @@ class NET_EXPORT UploadData
 
   ScopedVector<UploadElement> elements_;
   int64 identifier_;
-  base::Closure chunk_callback_;
   bool is_chunked_;
   bool last_chunk_appended_;
 
diff --git a/net/base/upload_data_stream.cc b/net/base/upload_data_stream.cc
index 750302e..c3a2f0b 100644
--- a/net/base/upload_data_stream.cc
+++ b/net/base/upload_data_stream.cc
@@ -7,11 +7,29 @@
 #include "base/logging.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
-#include "net/base/upload_data.h"
+#include "net/base/upload_bytes_element_reader.h"
 #include "net/base/upload_element_reader.h"
 
 namespace net {
 
+namespace {
+
+// A subclass of UplodBytesElementReader which owns the data given as a vector.
+class UploadOwnedBytesElementReader : public UploadBytesElementReader {
+ public:
+  UploadOwnedBytesElementReader(std::vector<char>* data)
+      : UploadBytesElementReader(&(*data)[0], data->size()) {
+    data_.swap(*data);
+  }
+
+  virtual ~UploadOwnedBytesElementReader() {}
+
+ private:
+  std::vector<char> data_;
+};
+
+}  // namespace
+
 bool UploadDataStream::merge_chunks_ = true;
 
 // static
@@ -20,21 +38,29 @@ void UploadDataStream::ResetMergeChunks() {
   merge_chunks_ = true;
 }
 
-UploadDataStream::UploadDataStream(UploadData* upload_data)
-    : upload_data_(upload_data),
-      element_index_(0),
+UploadDataStream::UploadDataStream(
+    ScopedVector<UploadElementReader>* element_readers,
+    int64 identifier)
+    : element_index_(0),
+      total_size_(0),
+      current_position_(0),
+      identifier_(identifier),
+      is_chunked_(false),
+      last_chunk_appended_(false),
+      initialized_successfully_(false),
+      weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
+  element_readers_.swap(*element_readers);
+}
+
+UploadDataStream::UploadDataStream(Chunked /*chunked*/, int64 identifier)
+    : element_index_(0),
       total_size_(0),
       current_position_(0),
+      identifier_(identifier),
+      is_chunked_(true),
+      last_chunk_appended_(false),
       initialized_successfully_(false),
-      weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
-      weak_ptr_factory_for_chunks_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
-  const ScopedVector<UploadElement>& elements = upload_data_->elements();
-  for (size_t i = 0; i < elements.size(); ++i)
-    element_readers_.push_back(UploadElementReader::Create(*elements[i]));
-
-  upload_data_->set_chunk_callback(
-      base::Bind(&UploadDataStream::OnChunkAvailable,
-                 weak_ptr_factory_for_chunks_.GetWeakPtr()));
+      weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
 }
 
 UploadDataStream::~UploadDataStream() {
@@ -79,20 +105,12 @@ int UploadDataStream::ReadSync(IOBuffer* buf, int buf_len) {
                       CompletionCallback());
 }
 
-int64 UploadDataStream::identifier() const {
-  return upload_data_->identifier();
-}
-
-bool UploadDataStream::is_chunked() const {
-  return upload_data_->is_chunked();
-}
-
 bool UploadDataStream::IsEOF() const {
   DCHECK(initialized_successfully_);
   // Check if all elements are consumed.
   if (element_index_ == element_readers_.size()) {
     // If the upload data is chunked, check if the last chunk is appended.
-    if (!is_chunked() || upload_data_->last_chunk_appended())
+    if (!is_chunked_ || last_chunk_appended_)
       return true;
   }
   return false;
@@ -104,7 +122,7 @@ bool UploadDataStream::IsInMemory() const {
   // are ready. Check is_chunked_ here, rather than relying on the loop
   // below, as there is a case that is_chunked_ is set to true, but the
   // first chunk is not yet delivered.
-  if (is_chunked())
+  if (is_chunked_)
     return false;
 
   for (size_t i = 0; i < element_readers_.size(); ++i) {
@@ -114,6 +132,29 @@ bool UploadDataStream::IsInMemory() const {
   return true;
 }
 
+void UploadDataStream::AppendChunk(const char* bytes,
+                                   int bytes_len,
+                                   bool is_last_chunk) {
+  DCHECK(is_chunked_);
+  DCHECK(!last_chunk_appended_);
+  last_chunk_appended_ = is_last_chunk;
+
+  // Initialize a reader for the newly appended chunk. We leave |total_size_| at
+  // zero, since for chunked uploads, we may not know the total size.
+  std::vector<char> data(bytes, bytes + bytes_len);
+  UploadElementReader* reader = new UploadOwnedBytesElementReader(&data);
+  const int rv = reader->InitSync();
+  DCHECK_EQ(OK, rv);
+  element_readers_.push_back(reader);
+
+  // Resume pending read.
+  if (!pending_chunked_read_callback_.is_null()) {
+    base::Closure callback = pending_chunked_read_callback_;
+    pending_chunked_read_callback_.Reset();
+    callback.Run();
+  }
+}
+
 void UploadDataStream::Reset() {
   weak_ptr_factory_.InvalidateWeakPtrs();
   pending_chunked_read_callback_.Reset();
@@ -166,7 +207,7 @@ void UploadDataStream::ResumePendingInit(int start_index,
 
 void UploadDataStream::FinalizeInitialization() {
   DCHECK(!initialized_successfully_);
-  if (!is_chunked()) {
+  if (!is_chunked_) {
     uint64 total_size = 0;
     for (size_t i = 0; i < element_readers_.size(); ++i) {
       UploadElementReader* reader = element_readers_[i];
@@ -193,7 +234,7 @@ int UploadDataStream::ReadInternal(scoped_refptr<DrainableIOBuffer> buf,
       break;
 
     // Some tests need chunks to be kept unmerged.
-    if (!merge_chunks_ && is_chunked() && buf->BytesConsumed())
+    if (!merge_chunks_ && is_chunked_ && buf->BytesConsumed())
       break;
 
     int result = OK;
@@ -218,7 +259,7 @@ int UploadDataStream::ReadInternal(scoped_refptr<DrainableIOBuffer> buf,
   const int bytes_copied = buf->BytesConsumed();
   current_position_ += bytes_copied;
 
-  if (is_chunked() && !IsEOF() && bytes_copied == 0) {
+  if (is_chunked_ && !IsEOF() && bytes_copied == 0) {
     DCHECK(!callback.is_null());
     DCHECK(pending_chunked_read_callback_.is_null());
     pending_chunked_read_callback_ =
@@ -246,29 +287,4 @@ void UploadDataStream::ResumePendingRead(scoped_refptr<DrainableIOBuffer> buf,
     callback.Run(result);
 }
 
-void UploadDataStream::OnChunkAvailable() {
-  DCHECK(is_chunked());
-
-  // Initialize a reader for the newly appended chunk.
-  const ScopedVector<UploadElement>& elements = upload_data_->elements();
-  DCHECK_EQ(elements.size(), element_readers_.size() + 1);
-
-  // We can initialize the reader synchronously here because only bytes can be
-  // appended for chunked data. We leave |total_size_| at zero, since for
-  // chunked uploads, we may not know the total size.
-  const UploadElement& element = *elements.back();
-  DCHECK_EQ(UploadElement::TYPE_BYTES, element.type());
-  UploadElementReader* reader = UploadElementReader::Create(element);
-  const int rv = reader->InitSync();
-  DCHECK_EQ(OK, rv);
-  element_readers_.push_back(reader);
-
-  // Resume pending read.
-  if (!pending_chunked_read_callback_.is_null()) {
-    base::Closure callback = pending_chunked_read_callback_;
-    pending_chunked_read_callback_.Reset();
-    callback.Run();
-  }
-}
-
 }  // namespace net
diff --git a/net/base/upload_data_stream.h b/net/base/upload_data_stream.h
index 021b6ca..2465302 100644
--- a/net/base/upload_data_stream.h
+++ b/net/base/upload_data_stream.h
@@ -16,13 +16,22 @@ namespace net {
 
 class DrainableIOBuffer;
 class IOBuffer;
-class UploadData;
 class UploadElementReader;
 
 // A class to read all elements from an UploadData object.
 class NET_EXPORT UploadDataStream {
  public:
-  explicit UploadDataStream(UploadData* upload_data);
+  // An enum used to construct chunked data stream.
+  enum Chunked { CHUNKED };
+
+  // Constructs a non-chunked data stream.
+  // |element_readers| is cleared by this ctor.
+  UploadDataStream(ScopedVector<UploadElementReader>* element_readers,
+                   int64 identifier);
+
+  // Constructs a chunked data stream.
+  UploadDataStream(Chunked chunked, int64 identifier);
+
   ~UploadDataStream();
 
   // Initializes the stream. This function must be called before calling any
@@ -62,7 +71,7 @@ class NET_EXPORT UploadDataStream {
   // Identifies a particular upload instance, which is used by the cache to
   // formulate a cache key.  This value should be unique across browser
   // sessions.  A value of 0 is used to indicate an unspecified identifier.
-  int64 identifier() const;
+  int64 identifier() const { return identifier_; }
 
   // Returns the total size of the data stream and the current position.
   // size() is not to be used to determine whether the stream has ended
@@ -72,7 +81,8 @@ class NET_EXPORT UploadDataStream {
   uint64 size() const { return total_size_; }
   uint64 position() const { return current_position_; }
 
-  bool is_chunked() const;
+  bool is_chunked() const { return is_chunked_; }
+  bool last_chunk_appended() const { return last_chunk_appended_; }
 
   const ScopedVector<UploadElementReader>& element_readers() const {
     return element_readers_;
@@ -85,19 +95,15 @@ class NET_EXPORT UploadDataStream {
   // Returns true if the upload data in the stream is entirely in memory.
   bool IsInMemory() const;
 
+  // Adds the given chunk of bytes to be sent with chunked transfer encoding.
+  void AppendChunk(const char* bytes, int bytes_len, bool is_last_chunk);
+
  private:
   friend class SpdyHttpStreamSpdy2Test;
   friend class SpdyHttpStreamSpdy3Test;
   friend class SpdyNetworkTransactionSpdy2Test;
   friend class SpdyNetworkTransactionSpdy3Test;
 
-  // TODO(hashimoto): Stop directly accsssing element_readers_ from tests and
-  // remove these friend declarations.
-  FRIEND_TEST_ALL_PREFIXES(UploadDataStreamTest, InitAsync);
-  FRIEND_TEST_ALL_PREFIXES(UploadDataStreamTest, InitAsyncFailureAsync);
-  FRIEND_TEST_ALL_PREFIXES(UploadDataStreamTest, InitAsyncFailureSync);
-  FRIEND_TEST_ALL_PREFIXES(UploadDataStreamTest, ReadAsync);
-
   // Resets this instance to the uninitialized state.
   void Reset();
 
@@ -124,14 +130,10 @@ class NET_EXPORT UploadDataStream {
                          const CompletionCallback& callback,
                          int previous_result);
 
-  // This method is called when a new chunk is available.
-  void OnChunkAvailable();
-
   // These methods are provided only to be used by unit tests.
   static void ResetMergeChunks();
   static void set_merge_chunks(bool merge) { merge_chunks_ = merge; }
 
-  scoped_refptr<UploadData> upload_data_;
   ScopedVector<UploadElementReader> element_readers_;
 
   // Index of the current upload element (i.e. the element currently being
@@ -144,6 +146,11 @@ class NET_EXPORT UploadDataStream {
   uint64 total_size_;
   uint64 current_position_;
 
+  const int64 identifier_;
+
+  const bool is_chunked_;
+  bool last_chunk_appended_;
+
   // True if the initialization was successful.
   bool initialized_successfully_;
 
@@ -152,8 +159,6 @@ class NET_EXPORT UploadDataStream {
 
   base::WeakPtrFactory<UploadDataStream> weak_ptr_factory_;
 
-  base::WeakPtrFactory<UploadDataStream> weak_ptr_factory_for_chunks_;
-
   // TODO(satish): Remove this once we have a better way to unit test POST
   // requests with chunked uploads.
   static bool merge_chunks_;
diff --git a/net/base/upload_data_stream_unittest.cc b/net/base/upload_data_stream_unittest.cc
index 0960c30..ee96e3c 100644
--- a/net/base/upload_data_stream_unittest.cc
+++ b/net/base/upload_data_stream_unittest.cc
@@ -18,7 +18,7 @@
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
-#include "net/base/upload_data.h"
+#include "net/base/upload_bytes_element_reader.h"
 #include "net/base/upload_file_element_reader.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -128,8 +128,6 @@ class MockCompletionCallback {
 
 class UploadDataStreamTest : public PlatformTest {
  public:
-  UploadDataStreamTest() : upload_data_(new UploadData) { }
-
   virtual void SetUp() OVERRIDE {
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
   }
@@ -139,13 +137,11 @@ class UploadDataStreamTest : public PlatformTest {
                          bool error_expected);
 
   base::ScopedTempDir temp_dir_;
-
-  scoped_refptr<UploadData> upload_data_;
+  ScopedVector<UploadElementReader> element_readers_;
 };
 
 TEST_F(UploadDataStreamTest, EmptyUploadData) {
-  upload_data_->AppendBytes("", 0);
-  UploadDataStream stream(upload_data_);
+  UploadDataStream stream(&element_readers_, 0);
   ASSERT_EQ(OK, stream.InitSync());
   EXPECT_TRUE(stream.IsInMemory());
   EXPECT_EQ(0U, stream.size());
@@ -154,8 +150,9 @@ TEST_F(UploadDataStreamTest, EmptyUploadData) {
 }
 
 TEST_F(UploadDataStreamTest, ConsumeAllBytes) {
-  upload_data_->AppendBytes(kTestData, kTestDataSize);
-  UploadDataStream stream(upload_data_);
+  element_readers_.push_back(new UploadBytesElementReader(
+      kTestData, kTestDataSize));
+  UploadDataStream stream(&element_readers_, 0);
   ASSERT_EQ(OK, stream.InitSync());
   EXPECT_TRUE(stream.IsInMemory());
   EXPECT_EQ(kTestDataSize, stream.size());
@@ -177,9 +174,10 @@ TEST_F(UploadDataStreamTest, File) {
   ASSERT_EQ(static_cast<int>(kTestDataSize),
             file_util::WriteFile(temp_file_path, kTestData, kTestDataSize));
 
-  upload_data_->AppendFileRange(temp_file_path, 0, kuint64max, base::Time());
+  element_readers_.push_back(new UploadFileElementReader(
+      temp_file_path, 0, kuint64max, base::Time()));
 
-  UploadDataStream stream(upload_data_);
+  UploadDataStream stream(&element_readers_, 0);
   ASSERT_EQ(OK, stream.InitSync());
   EXPECT_FALSE(stream.IsInMemory());
   EXPECT_EQ(kTestDataSize, stream.size());
@@ -205,9 +203,10 @@ TEST_F(UploadDataStreamTest, FileSmallerThanLength) {
   UploadFileElementReader::ScopedOverridingContentLengthForTests
       overriding_content_length(kFakeSize);
 
-  upload_data_->AppendFileRange(temp_file_path, 0, kuint64max, base::Time());
+  element_readers_.push_back(new UploadFileElementReader(
+      temp_file_path, 0, kuint64max, base::Time()));
 
-  UploadDataStream stream(upload_data_);
+  UploadDataStream stream(&element_readers_, 0);
   ASSERT_EQ(OK, stream.InitSync());
   EXPECT_FALSE(stream.IsInMemory());
   EXPECT_EQ(kFakeSize, stream.size());
@@ -236,13 +235,14 @@ TEST_F(UploadDataStreamTest, FileAndBytes) {
 
   const uint64 kFileRangeOffset = 1;
   const uint64 kFileRangeLength = 4;
-  upload_data_->AppendFileRange(
-      temp_file_path, kFileRangeOffset, kFileRangeLength, base::Time());
+  element_readers_.push_back(new UploadFileElementReader(
+      temp_file_path, kFileRangeOffset, kFileRangeLength, base::Time()));
 
-  upload_data_->AppendBytes(kTestData, kTestDataSize);
+  element_readers_.push_back(new UploadBytesElementReader(
+      kTestData, kTestDataSize));
 
   const uint64 kStreamSize = kTestDataSize + kFileRangeLength;
-  UploadDataStream stream(upload_data_);
+  UploadDataStream stream(&element_readers_, 0);
   ASSERT_EQ(OK, stream.InitSync());
   EXPECT_FALSE(stream.IsInMemory());
   EXPECT_EQ(kStreamSize, stream.size());
@@ -258,12 +258,11 @@ TEST_F(UploadDataStreamTest, FileAndBytes) {
 }
 
 TEST_F(UploadDataStreamTest, Chunk) {
-  upload_data_->set_is_chunked(true);
-  upload_data_->AppendChunk(kTestData, kTestDataSize, false);
-  upload_data_->AppendChunk(kTestData, kTestDataSize, true);
-
   const uint64 kStreamSize = kTestDataSize*2;
-  UploadDataStream stream(upload_data_);
+  UploadDataStream stream(UploadDataStream::CHUNKED, 0);
+  stream.AppendChunk(kTestData, kTestDataSize, false);
+  stream.AppendChunk(kTestData, kTestDataSize, true);
+
   ASSERT_EQ(OK, stream.InitSync());
   EXPECT_FALSE(stream.IsInMemory());
   EXPECT_EQ(0U, stream.size());  // Content-Length is 0 for chunked data.
@@ -280,31 +279,30 @@ TEST_F(UploadDataStreamTest, Chunk) {
 
 // Init() with on-memory and not-on-memory readers.
 TEST_F(UploadDataStreamTest, InitAsync) {
-  // Create stream without element readers.
-  UploadDataStream stream(upload_data_);
-
-  // Set mock readers to the stream.
+  // Create UploadDataStream with mock readers.
   MockUploadElementReader* reader = NULL;
 
   reader = new MockUploadElementReader(kTestDataSize, true);
   EXPECT_CALL(*reader, Init(_)).WillOnce(Return(OK));
-  stream.element_readers_.push_back(reader);
+  element_readers_.push_back(reader);
 
   reader = new MockUploadElementReader(kTestDataSize, true);
   EXPECT_CALL(*reader, Init(_)).WillOnce(Return(OK));
-  stream.element_readers_.push_back(reader);
+  element_readers_.push_back(reader);
 
   reader = new MockUploadElementReader(kTestDataSize, false);
   reader->SetAsyncInitExpectation(OK);
-  stream.element_readers_.push_back(reader);
+  element_readers_.push_back(reader);
 
   reader = new MockUploadElementReader(kTestDataSize, false);
   reader->SetAsyncInitExpectation(OK);
-  stream.element_readers_.push_back(reader);
+  element_readers_.push_back(reader);
 
   reader = new MockUploadElementReader(kTestDataSize, true);
   EXPECT_CALL(*reader, Init(_)).WillOnce(Return(OK));
-  stream.element_readers_.push_back(reader);
+  element_readers_.push_back(reader);
+
+  UploadDataStream stream(&element_readers_, 0);
 
   // Run Init().
   MockCompletionCallback mock_callback;
@@ -315,15 +313,14 @@ TEST_F(UploadDataStreamTest, InitAsync) {
 
 // Init() of a reader fails asynchronously.
 TEST_F(UploadDataStreamTest, InitAsyncFailureAsync) {
-  // Create stream without element readers.
-  UploadDataStream stream(upload_data_);
-
-  // Set a mock reader to the stream.
+  // Create UploadDataStream with a mock reader.
   MockUploadElementReader* reader = NULL;
 
   reader = new MockUploadElementReader(kTestDataSize, false);
   reader->SetAsyncInitExpectation(ERR_FAILED);
-  stream.element_readers_.push_back(reader);
+  element_readers_.push_back(reader);
+
+  UploadDataStream stream(&element_readers_, 0);
 
   // Run Init().
   MockCompletionCallback mock_callback;
@@ -334,19 +331,18 @@ TEST_F(UploadDataStreamTest, InitAsyncFailureAsync) {
 
 // Init() of a reader fails synchronously.
 TEST_F(UploadDataStreamTest, InitAsyncFailureSync) {
-  // Create stream without element readers.
-  UploadDataStream stream(upload_data_);
-
-  // Set mock readers to the stream.
+  // Create UploadDataStream with mock readers.
   MockUploadElementReader* reader = NULL;
 
   reader = new MockUploadElementReader(kTestDataSize, false);
   reader->SetAsyncInitExpectation(OK);
-  stream.element_readers_.push_back(reader);
+  element_readers_.push_back(reader);
 
   reader = new MockUploadElementReader(kTestDataSize, true);
   EXPECT_CALL(*reader, Init(_)).WillOnce(Return(ERR_FAILED));
-  stream.element_readers_.push_back(reader);
+  element_readers_.push_back(reader);
+
+  UploadDataStream stream(&element_readers_, 0);
 
   // Run Init().
   MockCompletionCallback mock_callback;
@@ -357,8 +353,9 @@ TEST_F(UploadDataStreamTest, InitAsyncFailureSync) {
 
 // Read with a buffer whose size is same as the data.
 TEST_F(UploadDataStreamTest, ReadAsyncWithExactSizeBuffer) {
-  upload_data_->AppendBytes(kTestData, kTestDataSize);
-  UploadDataStream stream(upload_data_);
+  element_readers_.push_back(new UploadBytesElementReader(
+      kTestData, kTestDataSize));
+  UploadDataStream stream(&element_readers_, 0);
 
   MockCompletionCallback mock_callback;
   EXPECT_CALL(mock_callback, Run(_)).Times(0);
@@ -378,31 +375,30 @@ TEST_F(UploadDataStreamTest, ReadAsyncWithExactSizeBuffer) {
 
 // Async Read() with on-memory and not-on-memory readers.
 TEST_F(UploadDataStreamTest, ReadAsync) {
-  // Create stream without element readers.
-  UploadDataStream stream(upload_data_);
-
-  // Set mock readers to the stream.
+  // Create UploadDataStream with mock readers.
   MockUploadElementReader* reader = NULL;
 
   reader = new MockUploadElementReader(kTestDataSize, true);
   EXPECT_CALL(*reader, Init(_)).WillOnce(Return(OK));
   reader->SetReadExpectation(kTestDataSize);
-  stream.element_readers_.push_back(reader);
+  element_readers_.push_back(reader);
 
   reader = new MockUploadElementReader(kTestDataSize, false);
   reader->SetAsyncInitExpectation(OK);
   reader->SetReadExpectation(kTestDataSize);
-  stream.element_readers_.push_back(reader);
+  element_readers_.push_back(reader);
 
   reader = new MockUploadElementReader(kTestDataSize, true);
   EXPECT_CALL(*reader, Init(_)).WillOnce(Return(OK));
   reader->SetReadExpectation(kTestDataSize);
-  stream.element_readers_.push_back(reader);
+  element_readers_.push_back(reader);
 
   reader = new MockUploadElementReader(kTestDataSize, false);
   reader->SetAsyncInitExpectation(OK);
   reader->SetReadExpectation(kTestDataSize);
-  stream.element_readers_.push_back(reader);
+  element_readers_.push_back(reader);
+
+  UploadDataStream stream(&element_readers_, 0);
 
   // Run Init().
   MockCompletionCallback mock_callback;
@@ -434,12 +430,12 @@ TEST_F(UploadDataStreamTest, ReadAsync) {
 void UploadDataStreamTest::FileChangedHelper(const FilePath& file_path,
                                              const base::Time& time,
                                              bool error_expected) {
-  // Don't use upload_data_ here, as this function is called twice, and
-  // reusing upload_data_ is wrong.
-  scoped_refptr<UploadData> upload_data(new UploadData);
-  upload_data->AppendFileRange(file_path, 1, 2, time);
+  // Don't use element_readers_ here, as this function is called twice, and
+  // reusing element_readers_ is wrong.
+  ScopedVector<UploadElementReader> element_readers;
+  element_readers.push_back(new UploadFileElementReader(file_path, 1, 2, time));
 
-  UploadDataStream stream(upload_data);
+  UploadDataStream stream(&element_readers, 0);
   int error_code = stream.InitSync();
   if (error_expected)
     ASSERT_EQ(ERR_UPLOAD_FILE_CHANGED, error_code);
@@ -466,34 +462,6 @@ TEST_F(UploadDataStreamTest, FileChanged) {
                     true);
 }
 
-TEST_F(UploadDataStreamTest, UploadDataReused) {
-  FilePath temp_file_path;
-  ASSERT_TRUE(file_util::CreateTemporaryFileInDir(temp_dir_.path(),
-                                                  &temp_file_path));
-  ASSERT_EQ(static_cast<int>(kTestDataSize),
-            file_util::WriteFile(temp_file_path, kTestData, kTestDataSize));
-
-  // Prepare |upload_data_| that contains a file.
-  upload_data_->AppendFileRange(temp_file_path, 0, kuint64max, base::Time());
-
-  // Confirm that the file is read properly.
-  {
-    UploadDataStream stream(upload_data_);
-    ASSERT_EQ(OK, stream.InitSync());
-    EXPECT_EQ(kTestDataSize, stream.size());
-    EXPECT_EQ(kTestData, ReadFromUploadDataStream(&stream));
-  }
-
-  // Reuse |upload_data_| for another UploadDataStream, and confirm that the
-  // file is read properly.
-  {
-    UploadDataStream stream(upload_data_);
-    ASSERT_EQ(OK, stream.InitSync());
-    EXPECT_EQ(kTestDataSize, stream.size());
-    EXPECT_EQ(kTestData, ReadFromUploadDataStream(&stream));
-  }
-}
-
 TEST_F(UploadDataStreamTest, MultipleInit) {
   FilePath temp_file_path;
   ASSERT_TRUE(file_util::CreateTemporaryFileInDir(temp_dir_.path(),
@@ -502,9 +470,11 @@ TEST_F(UploadDataStreamTest, MultipleInit) {
             file_util::WriteFile(temp_file_path, kTestData, kTestDataSize));
 
   // Prepare data.
-  upload_data_->AppendBytes(kTestData, kTestDataSize);
-  upload_data_->AppendFileRange(temp_file_path, 0, kuint64max, base::Time());
-  UploadDataStream stream(upload_data_);
+  element_readers_.push_back(new UploadBytesElementReader(
+      kTestData, kTestDataSize));
+  element_readers_.push_back(new UploadFileElementReader(
+      temp_file_path, 0, kuint64max, base::Time()));
+  UploadDataStream stream(&element_readers_, 0);
 
   std::string expected_data(kTestData, kTestData + kTestDataSize);
   expected_data += expected_data;
@@ -537,9 +507,11 @@ TEST_F(UploadDataStreamTest, MultipleInitAsync) {
   TestCompletionCallback test_callback;
 
   // Prepare data.
-  upload_data_->AppendBytes(kTestData, kTestDataSize);
-  upload_data_->AppendFileRange(temp_file_path, 0, kuint64max, base::Time());
-  UploadDataStream stream(upload_data_);
+  element_readers_.push_back(new UploadBytesElementReader(
+      kTestData, kTestDataSize));
+  element_readers_.push_back(new UploadFileElementReader(
+      temp_file_path, 0, kuint64max, base::Time()));
+  UploadDataStream stream(&element_readers_, 0);
 
   std::string expected_data(kTestData, kTestData + kTestDataSize);
   expected_data += expected_data;
@@ -573,9 +545,11 @@ TEST_F(UploadDataStreamTest, InitToReset) {
             file_util::WriteFile(temp_file_path, kTestData, kTestDataSize));
 
   // Prepare data.
-  upload_data_->AppendBytes(kTestData, kTestDataSize);
-  upload_data_->AppendFileRange(temp_file_path, 0, kuint64max, base::Time());
-  UploadDataStream stream(upload_data_);
+  element_readers_.push_back(new UploadBytesElementReader(
+      kTestData, kTestDataSize));
+  element_readers_.push_back(new UploadFileElementReader(
+      temp_file_path, 0, kuint64max, base::Time()));
+  UploadDataStream stream(&element_readers_, 0);
 
   std::vector<char> expected_data(kTestData, kTestData + kTestDataSize);
   expected_data.insert(expected_data.end(), expected_data.begin(),
@@ -622,9 +596,11 @@ TEST_F(UploadDataStreamTest, InitDuringAsyncInit) {
             file_util::WriteFile(temp_file_path, kTestData, kTestDataSize));
 
   // Prepare data.
-  upload_data_->AppendBytes(kTestData, kTestDataSize);
-  upload_data_->AppendFileRange(temp_file_path, 0, kuint64max, base::Time());
-  UploadDataStream stream(upload_data_);
+  element_readers_.push_back(new UploadBytesElementReader(
+      kTestData, kTestDataSize));
+  element_readers_.push_back(new UploadFileElementReader(
+      temp_file_path, 0, kuint64max, base::Time()));
+  UploadDataStream stream(&element_readers_, 0);
 
   std::vector<char> expected_data(kTestData, kTestData + kTestDataSize);
   expected_data.insert(expected_data.end(), expected_data.begin(),
@@ -663,9 +639,11 @@ TEST_F(UploadDataStreamTest, InitDuringAsyncRead) {
             file_util::WriteFile(temp_file_path, kTestData, kTestDataSize));
 
   // Prepare data.
-  upload_data_->AppendBytes(kTestData, kTestDataSize);
-  upload_data_->AppendFileRange(temp_file_path, 0, kuint64max, base::Time());
-  UploadDataStream stream(upload_data_);
+  element_readers_.push_back(new UploadBytesElementReader(
+      kTestData, kTestDataSize));
+  element_readers_.push_back(new UploadFileElementReader(
+      temp_file_path, 0, kuint64max, base::Time()));
+  UploadDataStream stream(&element_readers_, 0);
 
   std::vector<char> expected_data(kTestData, kTestData + kTestDataSize);
   expected_data.insert(expected_data.end(), expected_data.begin(),
diff --git a/net/base/upload_element_reader.cc b/net/base/upload_element_reader.cc
index ad7ed99..1b29d59 100644
--- a/net/base/upload_element_reader.cc
+++ b/net/base/upload_element_reader.cc
@@ -6,32 +6,10 @@
 
 #include "base/logging.h"
 #include "net/base/net_errors.h"
-#include "net/base/upload_bytes_element_reader.h"
 #include "net/base/upload_element.h"
-#include "net/base/upload_file_element_reader.h"
 
 namespace net {
 
-// static
-UploadElementReader* UploadElementReader::Create(const UploadElement& element) {
-  UploadElementReader* reader = NULL;
-  switch (element.type()) {
-    case UploadElement::TYPE_BYTES:
-      reader = new UploadBytesElementReader(element.bytes(),
-                                            element.bytes_length());
-      break;
-    case UploadElement::TYPE_FILE:
-      reader = new UploadFileElementReader(
-          element.file_path(),
-          element.file_range_offset(),
-          element.file_range_length(),
-          element.expected_file_modification_time());
-      break;
-  }
-  DCHECK(reader);
-  return reader;
-}
-
 const UploadBytesElementReader* UploadElementReader::AsBytesReader() const {
   return NULL;
 }
diff --git a/net/base/upload_element_reader.h b/net/base/upload_element_reader.h
index c717833..6c0d18a 100644
--- a/net/base/upload_element_reader.h
+++ b/net/base/upload_element_reader.h
@@ -22,9 +22,6 @@ class NET_EXPORT UploadElementReader {
   UploadElementReader() {}
   virtual ~UploadElementReader() {}
 
-  // Creates an appropriate UploadElementReader instance for the given element.
-  static UploadElementReader* Create(const UploadElement& element);
-
   // Returns this instance's pointer as UploadBytesElementReader when possible,
   // otherwise returns NULL.
   virtual const UploadBytesElementReader* AsBytesReader() const;
diff --git a/net/http/http_cache_unittest.cc b/net/http/http_cache_unittest.cc
index 73348255..cf330b6 100644
--- a/net/http/http_cache_unittest.cc
+++ b/net/http/http_cache_unittest.cc
@@ -17,7 +17,7 @@
 #include "net/base/net_errors.h"
 #include "net/base/net_log_unittest.h"
 #include "net/base/ssl_cert_request_info.h"
-#include "net/base/upload_data.h"
+#include "net/base/upload_bytes_element_reader.h"
 #include "net/base/upload_data_stream.h"
 #include "net/disk_cache/disk_cache.h"
 #include "net/http/http_byte_range.h"
@@ -2341,10 +2341,9 @@ TEST(HttpCache, SimplePOST_LoadOnlyFromCache_Hit) {
 
   const int64 kUploadId = 1;  // Just a dummy value.
 
-  scoped_refptr<net::UploadData> upload_data(new net::UploadData());
-  upload_data->set_identifier(kUploadId);
-  upload_data->AppendBytes("hello", 5);
-  net::UploadDataStream upload_data_stream(upload_data);
+  ScopedVector<net::UploadElementReader> element_readers;
+  element_readers.push_back(new net::UploadBytesElementReader("hello", 5));
+  net::UploadDataStream upload_data_stream(&element_readers, kUploadId);
   MockHttpRequest request(transaction);
   request.upload_data_stream = &upload_data_stream;
 
@@ -2373,10 +2372,9 @@ TEST(HttpCache, SimplePOST_WithRanges) {
 
   const int64 kUploadId = 1;  // Just a dummy value.
 
-  scoped_refptr<net::UploadData> upload_data(new net::UploadData());
-  upload_data->set_identifier(kUploadId);
-  upload_data->AppendBytes("hello", 5);
-  net::UploadDataStream upload_data_stream(upload_data);
+  ScopedVector<net::UploadElementReader> element_readers;
+  element_readers.push_back(new net::UploadBytesElementReader("hello", 5));
+  net::UploadDataStream upload_data_stream(&element_readers, kUploadId);
 
   MockHttpRequest request(transaction);
   request.upload_data_stream = &upload_data_stream;
@@ -2405,10 +2403,9 @@ TEST(HttpCache, SimplePOST_Invalidate) {
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
-  scoped_refptr<net::UploadData> upload_data(new net::UploadData());
-  upload_data->AppendBytes("hello", 5);
-  upload_data->set_identifier(1);
-  net::UploadDataStream upload_data_stream(upload_data);
+  ScopedVector<net::UploadElementReader> element_readers;
+  element_readers.push_back(new net::UploadBytesElementReader("hello", 5));
+  net::UploadDataStream upload_data_stream(&element_readers, 1);
 
   transaction.method = "POST";
   MockHttpRequest req2(transaction);
@@ -2428,9 +2425,9 @@ TEST(HttpCache, SimplePUT_Miss) {
   MockTransaction transaction(kSimplePOST_Transaction);
   transaction.method = "PUT";
 
-  scoped_refptr<net::UploadData> upload_data(new net::UploadData());
-  upload_data->AppendBytes("hello", 5);
-  net::UploadDataStream upload_data_stream(upload_data);
+  ScopedVector<net::UploadElementReader> element_readers;
+  element_readers.push_back(new net::UploadBytesElementReader("hello", 5));
+  net::UploadDataStream upload_data_stream(&element_readers, 0);
 
   MockHttpRequest request(transaction);
   request.upload_data_stream = &upload_data_stream;
@@ -2457,9 +2454,9 @@ TEST(HttpCache, SimplePUT_Invalidate) {
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
-  scoped_refptr<net::UploadData> upload_data(new net::UploadData());
-  upload_data->AppendBytes("hello", 5);
-  net::UploadDataStream upload_data_stream(upload_data);
+  ScopedVector<net::UploadElementReader> element_readers;
+  element_readers.push_back(new net::UploadBytesElementReader("hello", 5));
+  net::UploadDataStream upload_data_stream(&element_readers, 0);
 
   transaction.method = "PUT";
   MockHttpRequest req2(transaction);
@@ -2485,9 +2482,9 @@ TEST(HttpCache, SimpleDELETE_Miss) {
   MockTransaction transaction(kSimplePOST_Transaction);
   transaction.method = "DELETE";
 
-  scoped_refptr<net::UploadData> upload_data(new net::UploadData());
-  upload_data->AppendBytes("hello", 5);
-  net::UploadDataStream upload_data_stream(upload_data);
+  ScopedVector<net::UploadElementReader> element_readers;
+  element_readers.push_back(new net::UploadBytesElementReader("hello", 5));
+  net::UploadDataStream upload_data_stream(&element_readers, 0);
 
   MockHttpRequest request(transaction);
   request.upload_data_stream = &upload_data_stream;
@@ -2514,9 +2511,9 @@ TEST(HttpCache, SimpleDELETE_Invalidate) {
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
-  scoped_refptr<net::UploadData> upload_data(new net::UploadData());
-  upload_data->AppendBytes("hello", 5);
-  net::UploadDataStream upload_data_stream(upload_data);
+  ScopedVector<net::UploadElementReader> element_readers;
+  element_readers.push_back(new net::UploadBytesElementReader("hello", 5));
+  net::UploadDataStream upload_data_stream(&element_readers, 0);
 
   transaction.method = "DELETE";
   MockHttpRequest req2(transaction);
diff --git a/net/http/http_network_transaction_spdy2_unittest.cc b/net/http/http_network_transaction_spdy2_unittest.cc
index 29ec3fb..bfcfcc8 100644
--- a/net/http/http_network_transaction_spdy2_unittest.cc
+++ b/net/http/http_network_transaction_spdy2_unittest.cc
@@ -34,7 +34,7 @@
 #include "net/base/ssl_info.h"
 #include "net/base/test_completion_callback.h"
 #include "net/base/test_data_directory.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 "net/http/http_auth_handler_digest.h"
@@ -859,9 +859,9 @@ TEST_F(HttpNetworkTransactionSpdy2Test, ReuseConnection) {
 }
 
 TEST_F(HttpNetworkTransactionSpdy2Test, Ignores100) {
-  scoped_refptr<UploadData> upload_data(new UploadData());
-  upload_data->AppendBytes("foo", 3);
-  UploadDataStream upload_data_stream(upload_data);
+  ScopedVector<UploadElementReader> element_readers;
+  element_readers.push_back(new UploadBytesElementReader("foo", 3));
+  UploadDataStream upload_data_stream(&element_readers, 0);
 
   HttpRequestInfo request;
   request.method = "POST";
@@ -3690,9 +3690,9 @@ TEST_F(HttpNetworkTransactionSpdy2Test, RecycleSocketAfterZeroContentLength) {
 }
 
 TEST_F(HttpNetworkTransactionSpdy2Test, ResendRequestOnWriteBodyError) {
-  scoped_refptr<UploadData> upload_data(new UploadData());
-  upload_data->AppendBytes("foo", 3);
-  UploadDataStream upload_data_stream(upload_data);
+  ScopedVector<UploadElementReader> element_readers;
+  element_readers.push_back(new UploadBytesElementReader("foo", 3));
+  UploadDataStream upload_data_stream(&element_readers, 0);
 
   HttpRequestInfo request[2];
   // Transaction 1: a GET request that succeeds.  The socket is recycled
@@ -6529,9 +6529,10 @@ TEST_F(HttpNetworkTransactionSpdy2Test, UploadFileSmallerThanLength) {
   UploadFileElementReader::ScopedOverridingContentLengthForTests
       overriding_content_length(kFakeSize);
 
-  scoped_refptr<UploadData> upload_data(new UploadData());
-  upload_data->AppendFileRange(temp_file_path, 0, kuint64max, base::Time());
-  UploadDataStream upload_data_stream(upload_data);
+  ScopedVector<UploadElementReader> element_readers;
+  element_readers.push_back(
+      new UploadFileElementReader(temp_file_path, 0, kuint64max, base::Time()));
+  UploadDataStream upload_data_stream(&element_readers, 0);
 
   HttpRequestInfo request;
   request.method = "POST";
@@ -6581,9 +6582,10 @@ TEST_F(HttpNetworkTransactionSpdy2Test, UploadUnreadableFile) {
                                    temp_file_content.length()));
   ASSERT_TRUE(file_util::MakeFileUnreadable(temp_file));
 
-  scoped_refptr<UploadData> upload_data(new UploadData());
-  upload_data->AppendFileRange(temp_file, 0, kuint64max, base::Time());
-  UploadDataStream upload_data_stream(upload_data);
+  ScopedVector<UploadElementReader> element_readers;
+  element_readers.push_back(
+      new UploadFileElementReader(temp_file, 0, kuint64max, base::Time()));
+  UploadDataStream upload_data_stream(&element_readers, 0);
 
   HttpRequestInfo request;
   request.method = "POST";
@@ -6636,9 +6638,10 @@ TEST_F(HttpNetworkTransactionSpdy2Test, UnreadableUploadFileAfterAuthRestart) {
   ASSERT_TRUE(file_util::WriteFile(temp_file, temp_file_contents.c_str(),
                                    temp_file_contents.length()));
 
-  scoped_refptr<UploadData> upload_data(new UploadData());
-  upload_data->AppendFileRange(temp_file, 0, kuint64max, base::Time());
-  UploadDataStream upload_data_stream(upload_data);
+  ScopedVector<UploadElementReader> element_readers;
+  element_readers.push_back(
+      new UploadFileElementReader(temp_file, 0, kuint64max, base::Time()));
+  UploadDataStream upload_data_stream(&element_readers, 0);
 
   HttpRequestInfo request;
   request.method = "POST";
diff --git a/net/http/http_network_transaction_spdy3_unittest.cc b/net/http/http_network_transaction_spdy3_unittest.cc
index f9d057c..aa9ac21 100644
--- a/net/http/http_network_transaction_spdy3_unittest.cc
+++ b/net/http/http_network_transaction_spdy3_unittest.cc
@@ -34,7 +34,7 @@
 #include "net/base/ssl_info.h"
 #include "net/base/test_completion_callback.h"
 #include "net/base/test_data_directory.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 "net/http/http_auth_handler_digest.h"
@@ -859,9 +859,9 @@ TEST_F(HttpNetworkTransactionSpdy3Test, ReuseConnection) {
 }
 
 TEST_F(HttpNetworkTransactionSpdy3Test, Ignores100) {
-  scoped_refptr<UploadData> upload_data(new UploadData());
-  upload_data->AppendBytes("foo", 3);
-  UploadDataStream upload_data_stream(upload_data);
+  ScopedVector<UploadElementReader> element_readers;
+  element_readers.push_back(new UploadBytesElementReader("foo", 3));
+  UploadDataStream upload_data_stream(&element_readers, 0);
 
   HttpRequestInfo request;
   request.method = "POST";
@@ -3690,9 +3690,9 @@ TEST_F(HttpNetworkTransactionSpdy3Test, RecycleSocketAfterZeroContentLength) {
 }
 
 TEST_F(HttpNetworkTransactionSpdy3Test, ResendRequestOnWriteBodyError) {
-  scoped_refptr<UploadData> upload_data(new UploadData());
-  upload_data->AppendBytes("foo", 3);
-  UploadDataStream upload_data_stream(upload_data);
+  ScopedVector<UploadElementReader> element_readers;
+  element_readers.push_back(new UploadBytesElementReader("foo", 3));
+  UploadDataStream upload_data_stream(&element_readers, 0);
 
   HttpRequestInfo request[2];
   // Transaction 1: a GET request that succeeds.  The socket is recycled
@@ -6529,9 +6529,10 @@ TEST_F(HttpNetworkTransactionSpdy3Test, UploadFileSmallerThanLength) {
   UploadFileElementReader::ScopedOverridingContentLengthForTests
       overriding_content_length(kFakeSize);
 
-  scoped_refptr<UploadData> upload_data(new UploadData());
-  upload_data->AppendFileRange(temp_file_path, 0, kuint64max, base::Time());
-  UploadDataStream upload_data_stream(upload_data);
+  ScopedVector<UploadElementReader> element_readers;
+  element_readers.push_back(
+      new UploadFileElementReader(temp_file_path, 0, kuint64max, base::Time()));
+  UploadDataStream upload_data_stream(&element_readers, 0);
 
   HttpRequestInfo request;
   request.method = "POST";
@@ -6581,9 +6582,10 @@ TEST_F(HttpNetworkTransactionSpdy3Test, UploadUnreadableFile) {
                                    temp_file_content.length()));
   ASSERT_TRUE(file_util::MakeFileUnreadable(temp_file));
 
-  scoped_refptr<UploadData> upload_data(new UploadData());
-  upload_data->AppendFileRange(temp_file, 0, kuint64max, base::Time());
-  UploadDataStream upload_data_stream(upload_data);
+  ScopedVector<UploadElementReader> element_readers;
+  element_readers.push_back(
+      new UploadFileElementReader(temp_file, 0, kuint64max, base::Time()));
+  UploadDataStream upload_data_stream(&element_readers, 0);
 
   HttpRequestInfo request;
   request.method = "POST";
@@ -6636,9 +6638,10 @@ TEST_F(HttpNetworkTransactionSpdy3Test, UnreadableUploadFileAfterAuthRestart) {
   ASSERT_TRUE(file_util::WriteFile(temp_file, temp_file_contents.c_str(),
                                    temp_file_contents.length()));
 
-  scoped_refptr<UploadData> upload_data(new UploadData());
-  upload_data->AppendFileRange(temp_file, 0, kuint64max, base::Time());
-  UploadDataStream upload_data_stream(upload_data);
+  ScopedVector<UploadElementReader> element_readers;
+  element_readers.push_back(
+      new UploadFileElementReader(temp_file, 0, kuint64max, base::Time()));
+  UploadDataStream upload_data_stream(&element_readers, 0);
 
   HttpRequestInfo request;
   request.method = "POST";
diff --git a/net/http/http_stream_parser_unittest.cc b/net/http/http_stream_parser_unittest.cc
index b609c47..b62f539 100644
--- a/net/http/http_stream_parser_unittest.cc
+++ b/net/http/http_stream_parser_unittest.cc
@@ -14,8 +14,9 @@
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.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 "net/http/http_request_headers.h"
 #include "net/http/http_request_info.h"
 #include "net/http/http_response_info.h"
@@ -95,8 +96,8 @@ TEST(HttpStreamParser, ShouldMergeRequestHeadersAndBody_NoBody) {
 }
 
 TEST(HttpStreamParser, ShouldMergeRequestHeadersAndBody_EmptyBody) {
-  scoped_refptr<UploadData> upload_data = new UploadData;
-  scoped_ptr<UploadDataStream> body(new UploadDataStream(upload_data));
+  ScopedVector<UploadElementReader> element_readers;
+  scoped_ptr<UploadDataStream> body(new UploadDataStream(&element_readers, 0));
   ASSERT_EQ(OK, body->InitSync());
   // Shouldn't be merged if upload data is empty.
   ASSERT_FALSE(HttpStreamParser::ShouldMergeRequestHeadersAndBody(
@@ -104,12 +105,10 @@ TEST(HttpStreamParser, ShouldMergeRequestHeadersAndBody_EmptyBody) {
 }
 
 TEST(HttpStreamParser, ShouldMergeRequestHeadersAndBody_ChunkedBody) {
-  scoped_refptr<UploadData> upload_data = new UploadData;
-  upload_data->set_is_chunked(true);
   const std::string payload = "123";
-  upload_data->AppendChunk(payload.data(), payload.size(), true);
-
-  scoped_ptr<UploadDataStream> body(new UploadDataStream(upload_data));
+  scoped_ptr<UploadDataStream> body(
+      new UploadDataStream(UploadDataStream::CHUNKED, 0));
+  body->AppendChunk(payload.data(), payload.size(), true);
   ASSERT_EQ(OK, body->InitSync());
   // Shouldn't be merged if upload data carries chunked data.
   ASSERT_FALSE(HttpStreamParser::ShouldMergeRequestHeadersAndBody(
@@ -117,7 +116,7 @@ TEST(HttpStreamParser, ShouldMergeRequestHeadersAndBody_ChunkedBody) {
 }
 
 TEST(HttpStreamParser, ShouldMergeRequestHeadersAndBody_FileBody) {
-  scoped_refptr<UploadData> upload_data = new UploadData;
+  ScopedVector<UploadElementReader> element_readers;
 
   // Create an empty temporary file.
   base::ScopedTempDir temp_dir;
@@ -126,9 +125,10 @@ TEST(HttpStreamParser, ShouldMergeRequestHeadersAndBody_FileBody) {
   ASSERT_TRUE(file_util::CreateTemporaryFileInDir(temp_dir.path(),
                                                   &temp_file_path));
 
-  upload_data->AppendFileRange(temp_file_path, 0, 0, base::Time());
+  element_readers.push_back(new UploadFileElementReader(
+      temp_file_path, 0, 0, base::Time()));
 
-  scoped_ptr<UploadDataStream> body(new UploadDataStream(upload_data));
+  scoped_ptr<UploadDataStream> body(new UploadDataStream(&element_readers, 0));
   ASSERT_EQ(OK, body->InitSync());
   // Shouldn't be merged if upload data carries a file, as it's not in-memory.
   ASSERT_FALSE(HttpStreamParser::ShouldMergeRequestHeadersAndBody(
@@ -136,11 +136,12 @@ TEST(HttpStreamParser, ShouldMergeRequestHeadersAndBody_FileBody) {
 }
 
 TEST(HttpStreamParser, ShouldMergeRequestHeadersAndBody_SmallBodyInMemory) {
-  scoped_refptr<UploadData> upload_data = new UploadData;
+  ScopedVector<UploadElementReader> element_readers;
   const std::string payload = "123";
-  upload_data->AppendBytes(payload.data(), payload.size());
+  element_readers.push_back(new UploadBytesElementReader(
+      payload.data(), payload.size()));
 
-  scoped_ptr<UploadDataStream> body(new UploadDataStream(upload_data));
+  scoped_ptr<UploadDataStream> body(new UploadDataStream(&element_readers, 0));
   ASSERT_EQ(OK, body->InitSync());
   // Yes, should be merged if the in-memory body is small here.
   ASSERT_TRUE(HttpStreamParser::ShouldMergeRequestHeadersAndBody(
@@ -148,11 +149,12 @@ TEST(HttpStreamParser, ShouldMergeRequestHeadersAndBody_SmallBodyInMemory) {
 }
 
 TEST(HttpStreamParser, ShouldMergeRequestHeadersAndBody_LargeBodyInMemory) {
-  scoped_refptr<UploadData> upload_data = new UploadData;
+  ScopedVector<UploadElementReader> element_readers;
   const std::string payload(10000, 'a');  // 'a' x 10000.
-  upload_data->AppendBytes(payload.data(), payload.size());
+  element_readers.push_back(new UploadBytesElementReader(
+      payload.data(), payload.size()));
 
-  scoped_ptr<UploadDataStream> body(new UploadDataStream(upload_data));
+  scoped_ptr<UploadDataStream> body(new UploadDataStream(&element_readers, 0));
   ASSERT_EQ(OK, body->InitSync());
   // Shouldn't be merged if the in-memory body is large here.
   ASSERT_FALSE(HttpStreamParser::ShouldMergeRequestHeadersAndBody(
@@ -194,12 +196,8 @@ TEST(HttpStreamParser, AsyncChunkAndAsyncSocket) {
     MockRead(SYNCHRONOUS, 0, 8),  // EOF
   };
 
-  scoped_refptr<UploadData> upload_data(new UploadData);
-  upload_data->set_is_chunked(true);
-
-  upload_data->AppendChunk(kChunk1, arraysize(kChunk1) - 1, false);
-
-  UploadDataStream upload_stream(upload_data);
+  UploadDataStream upload_stream(UploadDataStream::CHUNKED, 0);
+  upload_stream.AppendChunk(kChunk1, arraysize(kChunk1) - 1, false);
   ASSERT_EQ(OK, upload_stream.InitSync());
 
   DeterministicSocketData data(reads, arraysize(reads),
@@ -247,7 +245,7 @@ TEST(HttpStreamParser, AsyncChunkAndAsyncSocket) {
 
   // Now append another chunk (while the first write is still pending), which
   // should not confuse the state machine.
-  upload_data->AppendChunk(kChunk2, arraysize(kChunk2) - 1, false);
+  upload_stream.AppendChunk(kChunk2, arraysize(kChunk2) - 1, false);
   ASSERT_FALSE(callback.have_result());
 
   // Complete writing the first chunk, which should then enqueue the second
@@ -264,7 +262,7 @@ TEST(HttpStreamParser, AsyncChunkAndAsyncSocket) {
 
   // Add the final chunk. This will enqueue another write, but it will not
   // complete due to the async nature.
-  upload_data->AppendChunk(kChunk3, arraysize(kChunk3) - 1, true);
+  upload_stream.AppendChunk(kChunk3, arraysize(kChunk3) - 1, true);
   ASSERT_FALSE(callback.have_result());
 
   // Finalize writing the last chunk, which will enqueue the trailer.
diff --git a/net/quic/quic_http_stream_test.cc b/net/quic/quic_http_stream_test.cc
index 2e0fd20..d0ad25d 100644
--- a/net/quic/quic_http_stream_test.cc
+++ b/net/quic/quic_http_stream_test.cc
@@ -8,7 +8,7 @@
 
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
-#include "net/base/upload_data.h"
+#include "net/base/upload_bytes_element_reader.h"
 #include "net/base/upload_data_stream.h"
 #include "net/http/http_response_headers.h"
 #include "net/quic/quic_client_session.h"
@@ -350,9 +350,10 @@ TEST_F(QuicHttpStreamTest, SendPostRequest) {
 
   Initialize();
 
-  UploadData* upload_data = new UploadData();
-  upload_data->AppendBytes(kUploadData, strlen(kUploadData));
-  UploadDataStream upload_data_stream(upload_data);
+  ScopedVector<UploadElementReader> element_readers;
+  element_readers.push_back(
+      new UploadBytesElementReader(kUploadData, strlen(kUploadData)));
+  UploadDataStream upload_data_stream(&element_readers, 0);
   request_.method = "POST";
   request_.url = GURL("http://www.google.com/");
   request_.upload_data_stream = &upload_data_stream;
diff --git a/net/spdy/spdy_http_stream_spdy2_unittest.cc b/net/spdy/spdy_http_stream_spdy2_unittest.cc
index f72d9a6..544f686 100644
--- a/net/spdy/spdy_http_stream_spdy2_unittest.cc
+++ b/net/spdy/spdy_http_stream_spdy2_unittest.cc
@@ -9,8 +9,8 @@
 #include "crypto/signature_creator.h"
 #include "net/base/asn1_util.h"
 #include "net/base/default_server_bound_cert_store.h"
-#include "net/base/upload_data.h"
 #include "net/base/upload_data_stream.h"
+#include "net/base/upload_element_reader.h"
 #include "net/http/http_request_info.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_response_info.h"
@@ -141,11 +141,9 @@ TEST_F(SpdyHttpStreamSpdy2Test, SendChunkedPost) {
   EXPECT_EQ(OK, InitSession(reads, arraysize(reads), writes, arraysize(writes),
                             host_port_pair));
 
-  scoped_refptr<UploadData> upload_data(new UploadData());
-  upload_data->set_is_chunked(true);
-  upload_data->AppendChunk(kUploadData, kUploadDataSize, false);
-  upload_data->AppendChunk(kUploadData, kUploadDataSize, true);
-  UploadDataStream upload_stream(upload_data);
+  UploadDataStream upload_stream(UploadDataStream::CHUNKED, 0);
+  upload_stream.AppendChunk(kUploadData, kUploadDataSize, false);
+  upload_stream.AppendChunk(kUploadData, kUploadDataSize, true);
 
   HttpRequestInfo request;
   request.method = "POST";
@@ -241,9 +239,7 @@ TEST_F(SpdyHttpStreamSpdy2Test, DelayedSendChunkedPost) {
   EXPECT_EQ(OK,
             session_->InitializeWithSocket(connection.release(), false, OK));
 
-  scoped_refptr<UploadData> upload_data(new UploadData());
-  upload_data->set_is_chunked(true);
-  UploadDataStream upload_stream(upload_data);
+  UploadDataStream upload_stream(UploadDataStream::CHUNKED, 0);
 
   HttpRequestInfo request;
   request.method = "POST";
@@ -251,7 +247,7 @@ TEST_F(SpdyHttpStreamSpdy2Test, DelayedSendChunkedPost) {
   request.upload_data_stream = &upload_stream;
 
   ASSERT_EQ(OK, upload_stream.InitSync());
-  upload_data->AppendChunk(kUploadData, kUploadDataSize, false);
+  upload_stream.AppendChunk(kUploadData, kUploadDataSize, false);
 
   BoundNetLog net_log;
   scoped_ptr<SpdyHttpStream> http_stream(
@@ -274,8 +270,8 @@ TEST_F(SpdyHttpStreamSpdy2Test, DelayedSendChunkedPost) {
   EXPECT_GT(callback.WaitForResult(), 0);
 
   // Now append the final two chunks which will enqueue two more writes.
-  upload_data->AppendChunk(kUploadData1, kUploadData1Size, false);
-  upload_data->AppendChunk(kUploadData, kUploadDataSize, true);
+  upload_stream.AppendChunk(kUploadData1, kUploadData1Size, false);
+  upload_stream.AppendChunk(kUploadData, kUploadDataSize, true);
 
   // Finish writing all the chunks.
   data.RunFor(2);
diff --git a/net/spdy/spdy_http_stream_spdy3_unittest.cc b/net/spdy/spdy_http_stream_spdy3_unittest.cc
index 49e4791..70c406d 100644
--- a/net/spdy/spdy_http_stream_spdy3_unittest.cc
+++ b/net/spdy/spdy_http_stream_spdy3_unittest.cc
@@ -11,8 +11,8 @@
 #include "crypto/signature_creator.h"
 #include "net/base/asn1_util.h"
 #include "net/base/default_server_bound_cert_store.h"
-#include "net/base/upload_data.h"
 #include "net/base/upload_data_stream.h"
+#include "net/base/upload_element_reader.h"
 #include "net/http/http_request_info.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_response_info.h"
@@ -151,11 +151,9 @@ TEST_F(SpdyHttpStreamSpdy3Test, SendChunkedPost) {
   EXPECT_EQ(OK, InitSession(reads, arraysize(reads), writes, arraysize(writes),
                             host_port_pair));
 
-  scoped_refptr<UploadData> upload_data(new UploadData());
-  upload_data->set_is_chunked(true);
-  upload_data->AppendChunk(kUploadData, kUploadDataSize, false);
-  upload_data->AppendChunk(kUploadData, kUploadDataSize, true);
-  UploadDataStream upload_stream(upload_data);
+  UploadDataStream upload_stream(UploadDataStream::CHUNKED, 0);
+  upload_stream.AppendChunk(kUploadData, kUploadDataSize, false);
+  upload_stream.AppendChunk(kUploadData, kUploadDataSize, true);
 
   HttpRequestInfo request;
   request.method = "POST";
@@ -251,9 +249,7 @@ TEST_F(SpdyHttpStreamSpdy3Test, DelayedSendChunkedPost) {
   EXPECT_EQ(OK,
             session_->InitializeWithSocket(connection.release(), false, OK));
 
-  scoped_refptr<UploadData> upload_data(new UploadData());
-  upload_data->set_is_chunked(true);
-  UploadDataStream upload_stream(upload_data);
+  UploadDataStream upload_stream(UploadDataStream::CHUNKED, 0);
 
   HttpRequestInfo request;
   request.method = "POST";
@@ -261,7 +257,7 @@ TEST_F(SpdyHttpStreamSpdy3Test, DelayedSendChunkedPost) {
   request.upload_data_stream = &upload_stream;
 
   ASSERT_EQ(OK, upload_stream.InitSync());
-  upload_data->AppendChunk(kUploadData, kUploadDataSize, false);
+  upload_stream.AppendChunk(kUploadData, kUploadDataSize, false);
 
   BoundNetLog net_log;
   scoped_ptr<SpdyHttpStream> http_stream(
@@ -284,8 +280,8 @@ TEST_F(SpdyHttpStreamSpdy3Test, DelayedSendChunkedPost) {
   EXPECT_GT(callback.WaitForResult(), 0);
 
   // Now append the final two chunks which will enqueue two more writes.
-  upload_data->AppendChunk(kUploadData1, kUploadData1Size, false);
-  upload_data->AppendChunk(kUploadData, kUploadDataSize, true);
+  upload_stream.AppendChunk(kUploadData1, kUploadData1Size, false);
+  upload_stream.AppendChunk(kUploadData, kUploadDataSize, true);
 
   // Finish writing all the chunks.
   data.RunFor(2);
@@ -383,9 +379,7 @@ TEST_F(SpdyHttpStreamSpdy3Test, DelayedSendChunkedPostWithWindowUpdate) {
   EXPECT_EQ(OK,
             session_->InitializeWithSocket(connection.release(), false, OK));
 
-  scoped_refptr<UploadData> upload_data(new UploadData());
-  upload_data->set_is_chunked(true);
-  UploadDataStream upload_stream(upload_data);
+  UploadDataStream upload_stream(UploadDataStream::CHUNKED, 0);
 
   HttpRequestInfo request;
   request.method = "POST";
@@ -393,7 +387,7 @@ TEST_F(SpdyHttpStreamSpdy3Test, DelayedSendChunkedPostWithWindowUpdate) {
   request.upload_data_stream = &upload_stream;
 
   ASSERT_EQ(OK, upload_stream.InitSync());
-  upload_data->AppendChunk(kUploadData, kUploadDataSize, true);
+  upload_stream.AppendChunk(kUploadData, kUploadDataSize, true);
 
   BoundNetLog net_log;
   scoped_ptr<SpdyHttpStream> http_stream(
diff --git a/net/spdy/spdy_network_transaction_spdy2_unittest.cc b/net/spdy/spdy_network_transaction_spdy2_unittest.cc
index fc9fdf3..9df36f0 100644
--- a/net/spdy/spdy_network_transaction_spdy2_unittest.cc
+++ b/net/spdy/spdy_network_transaction_spdy2_unittest.cc
@@ -14,8 +14,9 @@
 #include "base/memory/scoped_vector.h"
 #include "net/base/auth.h"
 #include "net/base/net_log_unittest.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 "net/http/http_network_session_peer.h"
 #include "net/http/http_transaction_unittest.h"
 #include "net/socket/client_socket_pool_base.h"
@@ -367,9 +368,10 @@ class SpdyNetworkTransactionSpdy2Test
 
   const HttpRequestInfo& CreatePostRequest() {
     if (!google_post_request_initialized_) {
-      scoped_refptr<UploadData> upload_data(new UploadData());
-      upload_data->AppendBytes(kUploadData, kUploadDataSize);
-      upload_data_stream_.reset(new UploadDataStream(upload_data));
+      ScopedVector<UploadElementReader> element_readers;
+      element_readers.push_back(
+          new UploadBytesElementReader(kUploadData, kUploadDataSize));
+      upload_data_stream_.reset(new UploadDataStream(&element_readers, 0));
 
       google_post_request_.method = "POST";
       google_post_request_.url = GURL(kDefaultURL);
@@ -386,9 +388,10 @@ class SpdyNetworkTransactionSpdy2Test
       CHECK_EQ(static_cast<int>(kUploadDataSize),
                file_util::WriteFile(file_path, kUploadData, kUploadDataSize));
 
-      scoped_refptr<UploadData> upload_data(new UploadData());
-      upload_data->AppendFileRange(file_path, 0, kUploadDataSize, base::Time());
-      upload_data_stream_.reset(new UploadDataStream(upload_data));
+      ScopedVector<UploadElementReader> element_readers;
+      element_readers.push_back(new UploadFileElementReader(
+          file_path, 0, kUploadDataSize, base::Time()));
+      upload_data_stream_.reset(new UploadDataStream(&element_readers, 0));
 
       google_post_request_.method = "POST";
       google_post_request_.url = GURL(kDefaultURL);
@@ -409,14 +412,15 @@ class SpdyNetworkTransactionSpdy2Test
       CHECK_EQ(static_cast<int>(kUploadDataSize),
                file_util::WriteFile(file_path, kUploadData, kUploadDataSize));
 
-      scoped_refptr<UploadData> upload_data(new UploadData());
-      upload_data->AppendBytes(kUploadData, kFileRangeOffset);
-      upload_data->AppendFileRange(
-          file_path, kFileRangeOffset, kFileRangeLength, base::Time());
-      upload_data->AppendBytes(
+      ScopedVector<UploadElementReader> element_readers;
+      element_readers.push_back(
+          new UploadBytesElementReader(kUploadData, kFileRangeOffset));
+      element_readers.push_back(new UploadFileElementReader(
+          file_path, kFileRangeOffset, kFileRangeLength, base::Time()));
+      element_readers.push_back(new UploadBytesElementReader(
           kUploadData + kFileRangeOffset + kFileRangeLength,
-          kUploadDataSize - (kFileRangeOffset + kFileRangeLength));
-      upload_data_stream_.reset(new UploadDataStream(upload_data));
+          kUploadDataSize - (kFileRangeOffset + kFileRangeLength)));
+      upload_data_stream_.reset(new UploadDataStream(&element_readers, 0));
 
       google_post_request_.method = "POST";
       google_post_request_.url = GURL(kDefaultURL);
@@ -428,11 +432,10 @@ class SpdyNetworkTransactionSpdy2Test
 
   const HttpRequestInfo& CreateChunkedPostRequest() {
     if (!google_chunked_post_request_initialized_) {
-      scoped_refptr<UploadData> upload_data(new UploadData());
-      upload_data->set_is_chunked(true);
-      upload_data->AppendChunk(kUploadData, kUploadDataSize, false);
-      upload_data->AppendChunk(kUploadData, kUploadDataSize, true);
-      upload_data_stream_.reset(new UploadDataStream(upload_data));
+      upload_data_stream_.reset(
+          new UploadDataStream(UploadDataStream::CHUNKED, 0));
+      upload_data_stream_->AppendChunk(kUploadData, kUploadDataSize, false);
+      upload_data_stream_->AppendChunk(kUploadData, kUploadDataSize, true);
 
       google_chunked_post_request_.method = "POST";
       google_chunked_post_request_.url = GURL(kDefaultURL);
@@ -1756,7 +1759,8 @@ TEST_P(SpdyNetworkTransactionSpdy2Test, NullPost) {
 // Test that a simple POST works.
 TEST_P(SpdyNetworkTransactionSpdy2Test, EmptyPost) {
   // Create an empty UploadDataStream.
-  UploadDataStream stream(new UploadData());
+  ScopedVector<UploadElementReader> element_readers;
+  UploadDataStream stream(&element_readers, 0);
 
   // Setup the request
   HttpRequestInfo request;
@@ -1793,9 +1797,10 @@ TEST_P(SpdyNetworkTransactionSpdy2Test, EmptyPost) {
 // While we're doing a post, the server sends back a SYN_REPLY.
 TEST_P(SpdyNetworkTransactionSpdy2Test, PostWithEarlySynReply) {
   static const char upload[] = { "hello!" };
-  scoped_refptr<UploadData> upload_data(new UploadData());
-  upload_data->AppendBytes(upload, sizeof(upload));
-  UploadDataStream stream(upload_data);
+  ScopedVector<UploadElementReader> element_readers;
+  element_readers.push_back(
+      new UploadBytesElementReader(upload, sizeof(upload)));
+  UploadDataStream stream(&element_readers, 0);
 
   // Setup the request
   HttpRequestInfo request;
diff --git a/net/spdy/spdy_network_transaction_spdy3_unittest.cc b/net/spdy/spdy_network_transaction_spdy3_unittest.cc
index c8a7014..0b6a794 100644
--- a/net/spdy/spdy_network_transaction_spdy3_unittest.cc
+++ b/net/spdy/spdy_network_transaction_spdy3_unittest.cc
@@ -14,8 +14,9 @@
 #include "base/memory/scoped_vector.h"
 #include "net/base/auth.h"
 #include "net/base/net_log_unittest.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 "net/http/http_network_session_peer.h"
 #include "net/http/http_transaction_unittest.h"
 #include "net/socket/client_socket_pool_base.h"
@@ -368,9 +369,10 @@ class SpdyNetworkTransactionSpdy3Test
 
   const HttpRequestInfo& CreatePostRequest() {
     if (!google_post_request_initialized_) {
-      scoped_refptr<UploadData> upload_data(new UploadData());
-      upload_data->AppendBytes(kUploadData, kUploadDataSize);
-      upload_data_stream_.reset(new UploadDataStream(upload_data));
+      ScopedVector<UploadElementReader> element_readers;
+      element_readers.push_back(
+          new UploadBytesElementReader(kUploadData, kUploadDataSize));
+      upload_data_stream_.reset(new UploadDataStream(&element_readers, 0));
 
       google_post_request_.method = "POST";
       google_post_request_.url = GURL(kDefaultURL);
@@ -387,9 +389,10 @@ class SpdyNetworkTransactionSpdy3Test
       CHECK_EQ(static_cast<int>(kUploadDataSize),
                file_util::WriteFile(file_path, kUploadData, kUploadDataSize));
 
-      scoped_refptr<UploadData> upload_data(new UploadData());
-      upload_data->AppendFileRange(file_path, 0, kUploadDataSize, base::Time());
-      upload_data_stream_.reset(new UploadDataStream(upload_data));
+      ScopedVector<UploadElementReader> element_readers;
+      element_readers.push_back(new UploadFileElementReader(
+          file_path, 0, kUploadDataSize, base::Time()));
+      upload_data_stream_.reset(new UploadDataStream(&element_readers, 0));
 
       google_post_request_.method = "POST";
       google_post_request_.url = GURL(kDefaultURL);
@@ -410,14 +413,15 @@ class SpdyNetworkTransactionSpdy3Test
       CHECK_EQ(static_cast<int>(kUploadDataSize),
                file_util::WriteFile(file_path, kUploadData, kUploadDataSize));
 
-      scoped_refptr<UploadData> upload_data(new UploadData());
-      upload_data->AppendBytes(kUploadData, kFileRangeOffset);
-      upload_data->AppendFileRange(
-          file_path, kFileRangeOffset, kFileRangeLength, base::Time());
-      upload_data->AppendBytes(
+      ScopedVector<UploadElementReader> element_readers;
+      element_readers.push_back(
+          new UploadBytesElementReader(kUploadData, kFileRangeOffset));
+      element_readers.push_back(new UploadFileElementReader(
+          file_path, kFileRangeOffset, kFileRangeLength, base::Time()));
+      element_readers.push_back(new UploadBytesElementReader(
           kUploadData + kFileRangeOffset + kFileRangeLength,
-          kUploadDataSize - (kFileRangeOffset + kFileRangeLength));
-      upload_data_stream_.reset(new UploadDataStream(upload_data));
+          kUploadDataSize - (kFileRangeOffset + kFileRangeLength)));
+      upload_data_stream_.reset(new UploadDataStream(&element_readers, 0));
 
       google_post_request_.method = "POST";
       google_post_request_.url = GURL(kDefaultURL);
@@ -429,11 +433,10 @@ class SpdyNetworkTransactionSpdy3Test
 
   const HttpRequestInfo& CreateChunkedPostRequest() {
     if (!google_chunked_post_request_initialized_) {
-      scoped_refptr<UploadData> upload_data(new UploadData());
-      upload_data->set_is_chunked(true);
-      upload_data->AppendChunk(kUploadData, kUploadDataSize, false);
-      upload_data->AppendChunk(kUploadData, kUploadDataSize, true);
-      upload_data_stream_.reset(new UploadDataStream(upload_data));
+      upload_data_stream_.reset(
+          new UploadDataStream(UploadDataStream::CHUNKED, 0));
+      upload_data_stream_->AppendChunk(kUploadData, kUploadDataSize, false);
+      upload_data_stream_->AppendChunk(kUploadData, kUploadDataSize, true);
 
       google_chunked_post_request_.method = "POST";
       google_chunked_post_request_.url = GURL(kDefaultURL);
@@ -1765,7 +1768,8 @@ TEST_P(SpdyNetworkTransactionSpdy3Test, NullPost) {
 // Test that a simple POST works.
 TEST_P(SpdyNetworkTransactionSpdy3Test, EmptyPost) {
   // Create an empty UploadDataStream.
-  UploadDataStream stream(new UploadData());
+  ScopedVector<UploadElementReader> element_readers;
+  UploadDataStream stream(&element_readers, 0);
 
   // Setup the request
   HttpRequestInfo request;
@@ -1802,9 +1806,10 @@ TEST_P(SpdyNetworkTransactionSpdy3Test, EmptyPost) {
 // While we're doing a post, the server sends back a SYN_REPLY.
 TEST_P(SpdyNetworkTransactionSpdy3Test, PostWithEarlySynReply) {
   static const char upload[] = { "hello!" };
-  scoped_refptr<UploadData> upload_data(new UploadData());
-  upload_data->AppendBytes(upload, sizeof(upload));
-  UploadDataStream stream(upload_data);
+  ScopedVector<UploadElementReader> element_readers;
+  element_readers.push_back(
+      new UploadBytesElementReader(upload, sizeof(upload)));
+  UploadDataStream stream(&element_readers, 0);
 
   // Setup the request
   HttpRequestInfo request;
@@ -2007,10 +2012,12 @@ TEST_P(SpdyNetworkTransactionSpdy3Test, WindowUpdateReceived) {
   DelayedSocketData data(0, reads, arraysize(reads),
                          writes, arraysize(writes));
 
-  scoped_refptr<UploadData> upload_data(new UploadData());
-  for (int i = 0; i < kFrameCount; ++i)
-    upload_data->AppendBytes(content->c_str(), content->size());
-  UploadDataStream upload_data_stream(upload_data);
+  ScopedVector<UploadElementReader> element_readers;
+  for (int i = 0; i < kFrameCount; ++i) {
+    element_readers.push_back(
+        new UploadBytesElementReader(content->c_str(), content->size()));
+  }
+  UploadDataStream upload_data_stream(&element_readers, 0);
 
   // Setup the request
   HttpRequestInfo request;
@@ -2158,10 +2165,12 @@ TEST_P(SpdyNetworkTransactionSpdy3Test, WindowUpdateOverflow) {
   DeterministicSocketData data(reads, arraysize(reads),
                                writes, arraysize(writes));
 
-  scoped_refptr<UploadData> upload_data(new UploadData());
-  for (int i = 0; i < kFrameCount; ++i)
-    upload_data->AppendBytes(content->c_str(), content->size());
-  UploadDataStream upload_data_stream(upload_data);
+  ScopedVector<UploadElementReader> element_readers;
+  for (int i = 0; i < kFrameCount; ++i) {
+    element_readers.push_back(
+        new UploadBytesElementReader(content->c_str(), content->size()));
+  }
+  UploadDataStream upload_data_stream(&element_readers, 0);
 
   // Setup the request
   HttpRequestInfo request;
@@ -2257,12 +2266,12 @@ TEST_P(SpdyNetworkTransactionSpdy3Test, FlowControlStallResume) {
   DelayedSocketData data(num_writes, reads, arraysize(reads),
                          writes.get(), num_writes);
 
-  scoped_refptr<UploadData> upload_data(new UploadData());
+  ScopedVector<UploadElementReader> element_readers;
   std::string upload_data_string(kSpdyStreamInitialWindowSize, 'a');
   upload_data_string.append(kUploadData, kUploadDataSize);
-  upload_data->AppendBytes(upload_data_string.c_str(),
-                           upload_data_string.size());
-  UploadDataStream upload_data_stream(upload_data);
+  element_readers.push_back(new UploadBytesElementReader(
+      upload_data_string.c_str(), upload_data_string.size()));
+  UploadDataStream upload_data_stream(&element_readers, 0);
 
   HttpRequestInfo request;
   request.method = "POST";
@@ -2355,12 +2364,12 @@ TEST_P(SpdyNetworkTransactionSpdy3Test, FlowControlStallResumeAfterSettings) {
   DelayedSocketData data(num_writes, reads, arraysize(reads),
                          writes.get(), num_writes);
 
-  scoped_refptr<UploadData> upload_data(new UploadData());
+  ScopedVector<UploadElementReader> element_readers;
   std::string upload_data_string(kSpdyStreamInitialWindowSize, 'a');
   upload_data_string.append(kUploadData, kUploadDataSize);
-  upload_data->AppendBytes(upload_data_string.c_str(),
-                           upload_data_string.size());
-  UploadDataStream upload_data_stream(upload_data);
+  element_readers.push_back(new UploadBytesElementReader(
+      upload_data_string.c_str(), upload_data_string.size()));
+  UploadDataStream upload_data_stream(&element_readers, 0);
 
   HttpRequestInfo request;
   request.method = "POST";
@@ -2462,12 +2471,12 @@ TEST_P(SpdyNetworkTransactionSpdy3Test, FlowControlNegativeSendWindowSize) {
   DelayedSocketData data(num_writes, reads, arraysize(reads),
                          writes.get(), num_writes);
 
-  scoped_refptr<UploadData> upload_data(new UploadData());
+  ScopedVector<UploadElementReader> element_readers;
   std::string upload_data_string(kSpdyStreamInitialWindowSize, 'a');
   upload_data_string.append(kUploadData, kUploadDataSize);
-  upload_data->AppendBytes(upload_data_string.c_str(),
-                           upload_data_string.size());
-  UploadDataStream upload_data_stream(upload_data);
+  element_readers.push_back(new UploadBytesElementReader(
+      upload_data_string.c_str(), upload_data_string.size()));
+  UploadDataStream upload_data_stream(&element_readers, 0);
 
   HttpRequestInfo request;
   request.method = "POST";
diff --git a/net/url_request/url_request.cc b/net/url_request/url_request.cc
index 43c7c62..8831ec6 100644
--- a/net/url_request/url_request.cc
+++ b/net/url_request/url_request.cc
@@ -23,8 +23,10 @@
 #include "net/base/network_change_notifier.h"
 #include "net/base/network_delegate.h"
 #include "net/base/ssl_cert_request_info.h"
+#include "net/base/upload_bytes_element_reader.h"
 #include "net/base/upload_data.h"
 #include "net/base/upload_data_stream.h"
+#include "net/base/upload_file_element_reader.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_util.h"
 #include "net/url_request/url_request_context.h"
@@ -255,26 +257,49 @@ void URLRequest::UnregisterRequestInterceptor(Interceptor* interceptor) {
 }
 
 void URLRequest::EnableChunkedUpload() {
-  DCHECK(!upload_ || upload_->is_chunked());
-  if (!upload_) {
-    upload_ = new UploadData();
-    upload_->set_is_chunked(true);
-    upload_data_stream_.reset(new UploadDataStream(upload_));
+  DCHECK(!upload_data_stream_ || upload_data_stream_->is_chunked());
+  if (!upload_data_stream_) {
+    upload_data_stream_.reset(
+        new UploadDataStream(UploadDataStream::CHUNKED, 0));
   }
 }
 
 void URLRequest::AppendChunkToUpload(const char* bytes,
                                      int bytes_len,
                                      bool is_last_chunk) {
-  DCHECK(upload_);
-  DCHECK(upload_->is_chunked());
+  DCHECK(upload_data_stream_);
+  DCHECK(upload_data_stream_->is_chunked());
   DCHECK_GT(bytes_len, 0);
-  upload_->AppendChunk(bytes, bytes_len, is_last_chunk);
+  upload_data_stream_->AppendChunk(bytes, bytes_len, is_last_chunk);
 }
 
 void URLRequest::set_upload(UploadData* upload) {
+  DCHECK(!upload->is_chunked());
   upload_ = upload;
-  upload_data_stream_.reset(new UploadDataStream(upload_));
+  ScopedVector<UploadElementReader> element_readers;
+  const ScopedVector<UploadElement>& elements = upload->elements();
+  for (ScopedVector<UploadElement>::const_iterator it = elements.begin();
+       it != elements.end(); ++it) {
+    UploadElementReader* reader = NULL;
+    const UploadElement& element = **it;
+    switch (element.type()) {
+      case UploadElement::TYPE_BYTES:
+        reader = new UploadBytesElementReader(element.bytes(),
+                                              element.bytes_length());
+        break;
+      case UploadElement::TYPE_FILE:
+        reader = new UploadFileElementReader(
+            element.file_path(),
+            element.file_range_offset(),
+            element.file_range_length(),
+            element.expected_file_modification_time());
+        break;
+    }
+    DCHECK(reader);
+    element_readers.push_back(reader);
+  }
+  upload_data_stream_.reset(new UploadDataStream(&element_readers,
+                                                 upload->identifier()));
 }
 
 const UploadDataStream* URLRequest::get_upload() const {
@@ -515,7 +540,7 @@ void URLRequest::StartJob(URLRequestJob* job) {
       NetLog::TYPE_URL_REQUEST_START_JOB,
       base::Bind(&NetLogURLRequestStartCallback,
                  &url(), &method_, load_flags_, priority_,
-                 upload_.get() ? upload_->identifier() : -1));
+                 upload_data_stream_ ? upload_data_stream_->identifier() : -1));
 
   job_ = job;
   job_->SetExtraRequestHeaders(extra_request_headers_);