Remove ScopedVector from content/.

base::ScopedVector is deprecated, see bug.

BUG=554289
TBR=tsepez@chromium.org

Review-Url: https://codereview.chromium.org/2749203002
Cr-Commit-Position: refs/heads/master@{#457371}

content/app/content_main_runner.cc

@@ -27,7 +27,6 @@
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/macros.h"
-#include "base/memory/scoped_vector.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram_base.h"
 #include "base/metrics/statistics_recorder.h"

content/browser/media/android/browser_media_player_manager.cc

@@ -88,18 +88,16 @@ BrowserMediaPlayerManager::CreateMediaPlayer(
     case MEDIA_PLAYER_TYPE_REMOTE_ONLY:
     case MEDIA_PLAYER_TYPE_URL: {
       const std::string user_agent = GetContentClient()->GetUserAgent();
-      std::unique_ptr<MediaPlayerAndroid> media_player_bridge(
-          new MediaPlayerBridge(
-              media_player_params.player_id, media_player_params.url,
-              media_player_params.first_party_for_cookies, user_agent,
-              hide_url_log, this,
-              base::Bind(&BrowserMediaPlayerManager::OnDecoderResourcesReleased,
-                         weak_ptr_factory_.GetWeakPtr()),
-              media_player_params.frame_url,
-              media_player_params.allow_credentials));
+      auto media_player_bridge = base::MakeUnique<MediaPlayerBridge>(
+          media_player_params.player_id, media_player_params.url,
+          media_player_params.first_party_for_cookies, user_agent, hide_url_log,
+          this,
+          base::Bind(&BrowserMediaPlayerManager::OnDecoderResourcesReleased,
+                     weak_ptr_factory_.GetWeakPtr()),
+          media_player_params.frame_url, media_player_params.allow_credentials);
 
       if (media_player_params.type == MEDIA_PLAYER_TYPE_REMOTE_ONLY)
-        return media_player_bridge;
+        return std::move(media_player_bridge);
 
       bool should_block = false;
       bool extract_metadata =
@@ -122,10 +120,9 @@ BrowserMediaPlayerManager::CreateMediaPlayer(
         OnMediaMetadataChanged(media_player_params.player_id, base::TimeDelta(),
                                0, 0, false);
       } else if (!should_block) {
-        static_cast<MediaPlayerBridge*>(media_player_bridge.get())
-            ->Initialize();
+        media_player_bridge->Initialize();
       }
-      return media_player_bridge;
+      return std::move(media_player_bridge);
     }
   }
 

content/child/blob_storage/blob_transport_controller.cc

@@ -16,7 +16,6 @@
 #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"
@@ -210,8 +209,8 @@ void BlobTransportController::OnMemoryRequest(
 
   // 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.
@@ -252,13 +251,11 @@ void BlobTransportController::OnMemoryRequest(
       }
       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
@@ -269,14 +266,15 @@ void BlobTransportController::OnMemoryRequest(
                          << ".";
             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);

content/common/input/input_param_traits_unittest.cc

@@ -5,7 +5,10 @@
 #include "content/common/input/input_param_traits.h"
 
 #include <stddef.h>
+
+#include <memory>
 #include <utility>
+#include <vector>
 
 #include "base/memory/ptr_util.h"
 #include "content/common/input/input_event.h"
@@ -27,7 +30,7 @@
 namespace content {
 namespace {
 
-typedef ScopedVector<InputEvent> InputEvents;
+typedef std::vector<std::unique_ptr<InputEvent>> InputEvents;
 
 class InputParamTraitsTest : public testing::Test {
  protected:
@@ -44,7 +47,7 @@ class InputParamTraitsTest : public testing::Test {
 
   static void Compare(const InputEvents* a, const InputEvents* b) {
     for (size_t i = 0; i < a->size(); ++i)
-      Compare((*a)[i], (*b)[i]);
+      Compare((*a)[i].get(), (*b)[i].get());
   }
 
   static void Compare(const SyntheticSmoothScrollGestureParams* a,
@@ -201,35 +204,35 @@ TEST_F(InputParamTraitsTest, InitializedEvents) {
                                     blink::WebInputEvent::NoModifiers,
                                     blink::WebInputEvent::TimeStampForTesting);
   key_event.nativeKeyCode = 5;
-  events.push_back(new InputEvent(key_event, latency));
+  events.push_back(base::MakeUnique<InputEvent>(key_event, latency));
 
   blink::WebMouseWheelEvent wheel_event(
       blink::WebInputEvent::MouseWheel, blink::WebInputEvent::NoModifiers,
       blink::WebInputEvent::TimeStampForTesting);
   wheel_event.deltaX = 10;
   latency.AddLatencyNumber(ui::INPUT_EVENT_LATENCY_BEGIN_RWH_COMPONENT, 1, 1);
-  events.push_back(new InputEvent(wheel_event, latency));
+  events.push_back(base::MakeUnique<InputEvent>(wheel_event, latency));
 
   blink::WebMouseEvent mouse_event(blink::WebInputEvent::MouseDown,
                                    blink::WebInputEvent::NoModifiers,
                                    blink::WebInputEvent::TimeStampForTesting);
   mouse_event.x = 10;
   latency.AddLatencyNumber(ui::INPUT_EVENT_LATENCY_UI_COMPONENT, 2, 2);
-  events.push_back(new InputEvent(mouse_event, latency));
+  events.push_back(base::MakeUnique<InputEvent>(mouse_event, latency));
 
   blink::WebGestureEvent gesture_event(
       blink::WebInputEvent::GestureScrollBegin,
       blink::WebInputEvent::NoModifiers,
       blink::WebInputEvent::TimeStampForTesting);
   gesture_event.x = -1;
-  events.push_back(new InputEvent(gesture_event, latency));
+  events.push_back(base::MakeUnique<InputEvent>(gesture_event, latency));
 
   blink::WebTouchEvent touch_event(blink::WebInputEvent::TouchStart,
                                    blink::WebInputEvent::NoModifiers,
                                    blink::WebInputEvent::TimeStampForTesting);
   touch_event.touchesLength = 1;
   touch_event.touches[0].radiusX = 1;
-  events.push_back(new InputEvent(touch_event, latency));
+  events.push_back(base::MakeUnique<InputEvent>(touch_event, latency));
 
   Verify(events);
 }

content/public/browser/web_ui.h

@@ -8,7 +8,6 @@
 #include <vector>
 
 #include "base/callback.h"
-#include "base/memory/scoped_vector.h"
 #include "base/strings/string16.h"
 #include "content/common/content_export.h"
 #include "ui/base/page_transition_types.h"

content/public/test/mock_render_process_host.cc

@@ -10,6 +10,7 @@
 
 #include "base/lazy_instance.h"
 #include "base/location.h"
+#include "base/memory/ptr_util.h"
 #include "base/process/process_handle.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
@@ -377,28 +378,24 @@ MockRenderProcessHostFactory::MockRenderProcessHostFactory() {}
 MockRenderProcessHostFactory::~MockRenderProcessHostFactory() {
   // Detach this object from MockRenderProcesses to prevent STLDeleteElements()
   // from calling MockRenderProcessHostFactory::Remove().
-  for (ScopedVector<MockRenderProcessHost>::iterator it = processes_.begin();
-       it != processes_.end(); ++it) {
-    (*it)->SetFactory(NULL);
-  }
+  for (const auto& process : processes_)
+    process->SetFactory(nullptr);
 }
 
 RenderProcessHost* MockRenderProcessHostFactory::CreateRenderProcessHost(
     BrowserContext* browser_context,
     SiteInstance* site_instance) const {
-  MockRenderProcessHost* host = new MockRenderProcessHost(browser_context);
-  if (host) {
-    processes_.push_back(host);
-    host->SetFactory(this);
-  }
-  return host;
+  processes_.push_back(
+      base::MakeUnique<MockRenderProcessHost>(browser_context));
+  processes_.back()->SetFactory(this);
+  return processes_.back().get();
 }
 
 void MockRenderProcessHostFactory::Remove(MockRenderProcessHost* host) const {
-  for (ScopedVector<MockRenderProcessHost>::iterator it = processes_.begin();
-       it != processes_.end(); ++it) {
-    if (*it == host) {
-      processes_.weak_erase(it);
+  for (auto it = processes_.begin(); it != processes_.end(); ++it) {
+    if (it->get() == host) {
+      it->release();
+      processes_.erase(it);
       break;
     }
   }

content/public/test/mock_render_process_host.h

@@ -9,9 +9,9 @@
 #include <stdint.h>
 #include <memory>
 #include <utility>
+#include <vector>
 
 #include "base/macros.h"
-#include "base/memory/scoped_vector.h"
 #include "base/metrics/persistent_memory_allocator.h"
 #include "base/observer_list.h"
 #include "content/public/browser/render_process_host.h"
@@ -192,7 +192,7 @@ class MockRenderProcessHostFactory : public RenderProcessHostFactory {
   // A list of MockRenderProcessHosts created by this object. This list is used
   // for deleting all MockRenderProcessHosts that have not deleted by a test in
   // the destructor and prevent them from being leaked.
-  mutable ScopedVector<MockRenderProcessHost> processes_;
+  mutable std::vector<std::unique_ptr<MockRenderProcessHost>> processes_;
 
   DISALLOW_COPY_AND_ASSIGN(MockRenderProcessHostFactory);
 };

content/public/test/test_file_system_context.h

@@ -6,7 +6,6 @@
 #define CONTENT_PUBLIC_TEST_TEST_FILE_SYSTEM_CONTEXT_H_
 
 #include "base/files/file_path.h"
-#include "base/memory/scoped_vector.h"
 #include "storage/browser/fileapi/file_system_context.h"
 
 namespace storage {

content/public/test/test_web_contents_factory.h

@@ -6,9 +6,9 @@
 #define CONTENT_PUBLIC_TEST_TEST_WEB_CONTENTS_FACTORY_H_
 
 #include <memory>
+#include <vector>
 
 #include "base/macros.h"
-#include "base/memory/scoped_vector.h"
 
 namespace content {
 class BrowserContext;
@@ -41,7 +41,7 @@ class TestWebContentsFactory {
   std::unique_ptr<RenderViewHostTestEnabler> rvh_enabler_;
 
   // The vector of web contents that this class created.
-  ScopedVector<WebContents> web_contents_;
+  std::vector<std::unique_ptr<WebContents>> web_contents_;
 
   DISALLOW_COPY_AND_ASSIGN(TestWebContentsFactory);
 };

content/test/test_web_contents_factory.cc

@@ -4,6 +4,7 @@
 
 #include "content/public/test/test_web_contents_factory.h"
 
+#include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/test/test_renderer_host.h"
@@ -29,10 +30,10 @@ TestWebContentsFactory::~TestWebContentsFactory() {
 
 WebContents* TestWebContentsFactory::CreateWebContents(
     BrowserContext* context) {
-  web_contents_.push_back(
-      WebContentsTester::CreateTestWebContents(context, nullptr));
+  web_contents_.push_back(base::WrapUnique(
+      WebContentsTester::CreateTestWebContents(context, nullptr)));
   DCHECK(web_contents_.back());
-  return web_contents_.back();
+  return web_contents_.back().get();
 }
 
 }  // namespace content