net: Change type of UploadData::elements from std::vector to ScopedVector

net/base/upload_data_stream.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 "net/base/upload_data_stream.h"
 
 #include "base/logging.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/base/upload_element_reader.h"
 
 namespace net {
 
 bool UploadDataStream::merge_chunks_ = true;
 
 // static
 void UploadDataStream::ResetMergeChunks() {
   // WARNING: merge_chunks_ must match the above initializer.
   merge_chunks_ = true;
 }
 
 UploadDataStream::UploadDataStream(UploadData* upload_data)
     : upload_data_(upload_data),
       element_index_(0),
       total_size_(0),
       current_position_(0),
       initialized_successfully_(false),
       weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       weak_ptr_factory_for_chunks_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
-  const std::vector<UploadElement>& elements = *upload_data_->elements();
+  const ScopedVector<UploadElement>& elements = upload_data_->elements();
   for (size_t i = 0; i < elements.size(); ++i)
-    element_readers_.push_back(UploadElementReader::Create(elements[i]));
+    element_readers_.push_back(UploadElementReader::Create(*elements[i]));
 
   upload_data_->set_chunk_callback(
       base::Bind(&UploadDataStream::OnChunkAvailable,
                  weak_ptr_factory_for_chunks_.GetWeakPtr()));
 }
 
 UploadDataStream::~UploadDataStream() {
 }
 
 int UploadDataStream::Init(const CompletionCallback& callback) {
@@ skipping 191 matching lines @@
   DCHECK(!callback.is_null());
   const int result = ReadInternal(buf, callback);
   if (result != ERR_IO_PENDING)
     callback.Run(result);
 }
 
 void UploadDataStream::OnChunkAvailable() {
   DCHECK(is_chunked());
 
   // Initialize a reader for the newly appended chunk.
-  const std::vector<UploadElement>& elements = *upload_data_->elements();
+  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();
+  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