Remove ScopedVector from content/.

content/child/blob_storage/blob_transport_controller.cc

 // Copyright 2015 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 "content/child/blob_storage/blob_transport_controller.h"
 
 #include <limits>
 #include <memory>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/files/file.h"
 #include "base/lazy_instance.h"
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
-#include "base/memory/scoped_vector.h"
 #include "base/memory/shared_memory.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/task_runner.h"
 #include "base/task_runner_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "content/child/blob_storage/blob_consolidation.h"
@@ skipping 173 matching lines @@
     return;
 
   BlobConsolidation* consolidation = it->second.get();
   const auto& consolidated_items = consolidation->consolidated_items();
 
   std::unique_ptr<std::vector<BlobItemBytesRequest>> file_requests(
       new std::vector<BlobItemBytesRequest>());
 
   // Since we can be writing to the same shared memory handle from multiple
   // requests, we keep them in a vector and lazily create them.
-  ScopedVector<SharedMemory> opened_memory;
-  opened_memory.resize(memory_handles->size());
+  std::vector<std::unique_ptr<SharedMemory>> opened_memory(
+      memory_handles->size());
 
   // We need to calculate how much memory we expect to be writing to the memory
   // segments so we can correctly map it the first time.
   std::vector<size_t> shared_memory_sizes(memory_handles->size());
   for (const BlobItemBytesRequest& request : requests) {
     if (request.transport_strategy !=
         IPCBlobItemRequestStrategy::SHARED_MEMORY) {
       continue;
     }
     DCHECK_LT(request.handle_index, memory_handles->size())
@@ skipping 20 matching lines @@
         ReadStatus status = consolidation->ReadMemory(
             request.renderer_item_index, request.renderer_item_offset,
             request.size, response.allocate_mutable_data(request.size));
         DCHECK(status == ReadStatus::OK)
             << "Error reading from consolidated blob: "
             << static_cast<int>(status);
         break;
       }
       case IPCBlobItemRequestStrategy::SHARED_MEMORY: {
         responses.push_back(BlobItemBytesResponse(request.request_number));
-        SharedMemory* memory = opened_memory[request.handle_index];
-        if (!memory) {
+        if (!opened_memory[request.handle_index]) {
           SharedMemoryHandle& handle = (*memory_handles)[request.handle_index];
           size_t size = shared_memory_sizes[request.handle_index];
           DCHECK(SharedMemory::IsHandleValid(handle));
-          std::unique_ptr<SharedMemory> shared_memory(
-              new SharedMemory(handle, false));
+          auto shared_memory = base::MakeUnique<SharedMemory>(handle, false);
 
           if (!shared_memory->Map(size)) {
             // This would happen if the renderer process doesn't have enough
             // memory to map the shared memory, which is possible if we don't
             // have much memory. If this scenario happens often, we could delay
             // the response until we have enough memory.  For now we just fail.
             CHECK(false) << "Unable to map shared memory to send blob " << uuid
                          << ".";
             return;
           }
-          memory = shared_memory.get();
-          opened_memory[request.handle_index] = shared_memory.release();
+          opened_memory[request.handle_index] = std::move(shared_memory);
         }
-        CHECK(memory->memory()) << "Couldn't map memory for blob transfer.";
+        CHECK(opened_memory[request.handle_index]->memory())
+            << "Couldn't map memory for blob transfer.";
         ReadStatus status = consolidation->ReadMemory(
             request.renderer_item_index, request.renderer_item_offset,
             request.size,
-            static_cast<char*>(memory->memory()) + request.handle_offset);
+            static_cast<char*>(opened_memory[request.handle_index]->memory()) +
+                request.handle_offset);
         DCHECK(status == ReadStatus::OK)
             << "Error reading from consolidated blob: "
             << static_cast<int>(status);
         break;
       }
       case IPCBlobItemRequestStrategy::FILE:
         DCHECK_LT(request.handle_index, file_handles.size())
             << "Invalid handle index.";
         file_requests->push_back(request);
         break;
@@ skipping 120 matching lines @@
 
 void BlobTransportController::ReleaseBlobConsolidation(
     const std::string& uuid) {
   if (blob_storage_.erase(uuid)) {
     main_thread_runner_->PostTask(FROM_HERE,
                                   base::Bind(&DecChildProcessRefCount));
   }
 }
 
 }  // namespace content