Remove ScopedVector from content/browser/ [1].

content/browser/media/android/browser_media_player_manager.cc

Index: content/browser/media/android/browser_media_player_manager.cc
diff --git a/content/browser/media/android/browser_media_player_manager.cc b/content/browser/media/android/browser_media_player_manager.cc
index d73137b1a63e7d87d7b1ef4dfc4d97600bbd0b90..1ea8bf152dcc60c5445115e8057fd529e462b437 100644
--- a/content/browser/media/android/browser_media_player_manager.cc
+++ b/content/browser/media/android/browser_media_player_manager.cc
@@ -7,6 +7,7 @@
 #include <utility>
 
 #include "base/android/scoped_java_ref.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/singleton.h"
 #include "content/browser/frame_host/render_frame_host_impl.h"
 #include "content/browser/media/android/media_resource_getter_impl.h"
@@ -79,20 +80,23 @@ ContentViewCore* BrowserMediaPlayerManager::GetContentViewCore() const {
 }
 #endif
 
-MediaPlayerAndroid* BrowserMediaPlayerManager::CreateMediaPlayer(
+std::unique_ptr<MediaPlayerAndroid>
+BrowserMediaPlayerManager::CreateMediaPlayer(
     const MediaPlayerHostMsg_Initialize_Params& media_player_params,
     bool hide_url_log) {
   switch (media_player_params.type) {
     case MEDIA_PLAYER_TYPE_REMOTE_ONLY:
     case MEDIA_PLAYER_TYPE_URL: {
       const std::string user_agent = GetContentClient()->GetUserAgent();
-      MediaPlayerBridge* 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);
+      std::unique_ptr<MediaPlayerAndroid> media_player_bridge(

[Avi (use Gerrit), 2017/03/13 15:23:34]

Not MakeUnique? :(

[leonhsl(Using Gerrit), 2017/03/14 02:17:12]

I was using MakeUnique, but trybots compile failed, because MakeUnique would
just create a std::unique_ptr<MediaPlayerBridge>, which can't be casted
automatically to a std::unique_ptr<MediaPlayerAndroid> expected to be returned
by CreateMediaPlayer(). So I changed to such a way..

[danakj, 2017/03/14 15:09:55]

Just cast it when you return

class B : public A {};

unique_ptr<A> f() {
  auto b = base::MakeUnique<B>();
  return std::move(b);
}

+          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));
 
       if (media_player_params.type == MEDIA_PLAYER_TYPE_REMOTE_ONLY)
         return media_player_bridge;
@@ -118,14 +122,15 @@ MediaPlayerAndroid* BrowserMediaPlayerManager::CreateMediaPlayer(
         OnMediaMetadataChanged(media_player_params.player_id, base::TimeDelta(),
                                0, 0, false);
       } else if (!should_block) {
-        media_player_bridge->Initialize();
+        static_cast<MediaPlayerBridge*>(media_player_bridge.get())
+            ->Initialize();
       }
       return media_player_bridge;
     }
   }
 
   NOTREACHED();
-  return NULL;
+  return nullptr;
 }
 
 BrowserMediaPlayerManager::BrowserMediaPlayerManager(
@@ -141,12 +146,13 @@ BrowserMediaPlayerManager::~BrowserMediaPlayerManager() {
   // During the tear down process, OnDestroyPlayer() may or may not be called
   // (e.g. the WebContents may be destroyed before the render process). So
   // we cannot DCHECK(players_.empty()) here. Instead, all media players in
-  // |players_| will be destroyed here because |player_| is a ScopedVector.
+  // |players_| will be destroyed here because |player_| is a
+  // std::vector<std::unique_ptr<>>.
 
-  for (MediaPlayerAndroid* player : players_)
-    player->DeleteOnCorrectThread();
+  for (auto& player : players_)
+    player.release()->DeleteOnCorrectThread();

[Avi (use Gerrit), 2017/03/13 15:23:34]

This is... odd, but no worse than before.

 
-  players_.weak_clear();
+  players_.clear();
 }
 
 void BrowserMediaPlayerManager::DidExitFullscreen(bool release_media_player) {
@@ -280,12 +286,11 @@ MediaPlayerAndroid* BrowserMediaPlayerManager::GetFullscreenPlayer() {
 }
 
 MediaPlayerAndroid* BrowserMediaPlayerManager::GetPlayer(int player_id) {
-  for (ScopedVector<MediaPlayerAndroid>::iterator it = players_.begin();
-      it != players_.end(); ++it) {
-    if ((*it)->player_id() == player_id)
-      return *it;
+  for (const auto& player : players_) {
+    if (player->player_id() == player_id)
+      return player.get();
   }
-  return NULL;
+  return nullptr;
 }
 
 bool BrowserMediaPlayerManager::RequestPlay(int player_id,
@@ -356,13 +361,13 @@ void BrowserMediaPlayerManager::OnInitialize(
 
   RenderProcessHostImpl* host = static_cast<RenderProcessHostImpl*>(
       web_contents()->GetRenderProcessHost());
-  MediaPlayerAndroid* player = CreateMediaPlayer(
-      media_player_params, host->GetBrowserContext()->IsOffTheRecord());
+  auto player = CreateMediaPlayer(media_player_params,
+                                  host->GetBrowserContext()->IsOffTheRecord());
 
   if (!player)
     return;
 
-  AddPlayer(player, media_player_params.delegate_id);
+  AddPlayer(std::move(player), media_player_params.delegate_id);
 }
 
 void BrowserMediaPlayerManager::OnStart(int player_id) {
@@ -435,19 +440,18 @@ bool BrowserMediaPlayerManager::IsPlayingRemotely(int player_id) {
 }
 
 void BrowserMediaPlayerManager::AddPlayer(
-    MediaPlayerAndroid* player, int delegate_id) {
+    std::unique_ptr<MediaPlayerAndroid> player,
+    int delegate_id) {
   DCHECK(!GetPlayer(player->player_id()));
-  players_.push_back(player);
-  player_id_to_delegate_id_map_[player->player_id()] =
-      delegate_id;
+  players_.push_back(std::move(player));
+  player_id_to_delegate_id_map_[players_.back()->player_id()] = delegate_id;
 }
 
 void BrowserMediaPlayerManager::DestroyPlayer(int player_id) {
-  for (ScopedVector<MediaPlayerAndroid>::iterator it = players_.begin();
-      it != players_.end(); ++it) {
+  for (auto it = players_.begin(); it != players_.end(); ++it) {
     if ((*it)->player_id() == player_id) {
-      (*it)->DeleteOnCorrectThread();
-      players_.weak_erase(it);
+      it->release()->DeleteOnCorrectThread();
+      players_.erase(it);
       break;
     }
   }
@@ -463,23 +467,22 @@ void BrowserMediaPlayerManager::ReleaseResources(int player_id) {
     fullscreen_player_is_released_ = true;
 }
 
-std::unique_ptr<media::MediaPlayerAndroid>
-BrowserMediaPlayerManager::SwapPlayer(int player_id,
-                                      media::MediaPlayerAndroid* player) {
-  media::MediaPlayerAndroid* previous_player = NULL;
-  for (ScopedVector<MediaPlayerAndroid>::iterator it = players_.begin();
-      it != players_.end(); ++it) {
+std::unique_ptr<MediaPlayerAndroid> BrowserMediaPlayerManager::SwapPlayer(
+    int player_id,
+    MediaPlayerAndroid* player) {
+  std::unique_ptr<MediaPlayerAndroid> previous_player;
+  for (auto it = players_.begin(); it != players_.end(); ++it) {
     if ((*it)->player_id() == player_id) {
-      previous_player = *it;
+      previous_player = std::move(*it);
       MediaWebContentsObserverAndroid::FromWebContents(web_contents_)
           ->DisconnectMediaSession(render_frame_host_,
                                    player_id_to_delegate_id_map_[player_id]);
-      players_.weak_erase(it);
-      players_.push_back(player);
+      players_.erase(it);
+      players_.push_back(base::WrapUnique(player));
       break;
     }
   }
-  return std::unique_ptr<media::MediaPlayerAndroid>(previous_player);
+  return previous_player;
 }
 
 bool BrowserMediaPlayerManager::RequestDecoderResources(