Remove ScopedVector from chrome/browser/.

chrome/browser/media/android/remote/remote_media_player_manager.cc

 // Copyright 2013 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 "chrome/browser/media/android/remote/remote_media_player_manager.h"
 
+#include "base/memory/ptr_util.h"
 #include "chrome/browser/android/tab_android.h"
 #include "chrome/common/chrome_content_client.h"
 #include "content/common/media/media_player_messages_android.h"
 #include "third_party/WebKit/public/platform/modules/remoteplayback/WebRemotePlaybackAvailability.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/gfx/android/java_bitmap.h"
 
 using media::MediaPlayerAndroid;
 
 static const int MAX_POSTER_BITMAP_SIZE = 1024 * 1024;
 
 namespace remote_media {
 
 RemoteMediaPlayerManager::RemoteMediaPlayerManager(
     content::RenderFrameHost* render_frame_host)
     : BrowserMediaPlayerManager(render_frame_host),
       weak_ptr_factory_(this) {
 }
 
 RemoteMediaPlayerManager::~RemoteMediaPlayerManager() {
-  for (MediaPlayerAndroid* player : alternative_players_)
-    player->DeleteOnCorrectThread();
+  for (auto& player : alternative_players_)
+    player.release()->DeleteOnCorrectThread();
 
-  alternative_players_.weak_clear();
+  alternative_players_.clear();
 }
 
 void RemoteMediaPlayerManager::OnStart(int player_id) {
   RemoteMediaPlayerBridge* remote_player = GetRemotePlayer(player_id);
   if (remote_player && IsPlayingRemotely(player_id))
     remote_player->Start();
 
   BrowserMediaPlayerManager::OnStart(player_id);
 }
 
@@ skipping 94 matching lines @@
     const GURL& image_url,
     const std::vector<SkBitmap>& bitmaps,
     const std::vector<gfx::Size>& original_bitmap_sizes) {
   RemoteMediaPlayerBridge* player = GetRemotePlayer(player_id);
   if (player)
     player->SetPosterBitmap(bitmaps);
 }
 
 RemoteMediaPlayerBridge* RemoteMediaPlayerManager::CreateRemoteMediaPlayer(
     int player_id) {
-  RemoteMediaPlayerBridge* player =
-      new RemoteMediaPlayerBridge(player_id, GetUserAgent(), this);
-  alternative_players_.push_back(player);
-  player->Initialize();
-  return player;
+  alternative_players_.push_back(base::MakeUnique<RemoteMediaPlayerBridge>(
+      player_id, GetUserAgent(), this));
+  RemoteMediaPlayerBridge* remote =
+      static_cast<RemoteMediaPlayerBridge*>(alternative_players_.back().get());
+  remote->Initialize();
+  return remote;
 }
 
 bool RemoteMediaPlayerManager::SwapCurrentPlayer(int player_id) {
   // Find the alternative player to swap the current one with.
   auto it = GetAlternativePlayer(player_id);
   if (it == alternative_players_.end())
     return false;
 
-  MediaPlayerAndroid* new_player = *it;
+  // Release ownership of the alternative player.
   std::unique_ptr<MediaPlayerAndroid> old_player =
-      SwapPlayer(player_id, new_player);
+      SwapPlayer(player_id, std::move(*it));
+  alternative_players_.erase(it);
   if (!old_player) {
-    // There's no player to swap with, destroy the alternative player and exit.
-    alternative_players_.erase(it);
     return false;
   }
 
-  alternative_players_.weak_erase(it);
-  alternative_players_.push_back(old_player.release());
+  alternative_players_.push_back(std::move(old_player));
   return true;
 }
 
 void RemoteMediaPlayerManager::SwitchToRemotePlayer(
     int player_id,
     const std::string& casting_message) {
   DCHECK(!IsPlayingRemotely(player_id));
   if (!SwapCurrentPlayer(player_id))
     return;
   players_playing_remotely_.insert(player_id);
@@ skipping 62 matching lines @@
 }
 
 void RemoteMediaPlayerManager::OnPlaying(int player_id) {
   Send(new MediaPlayerMsg_DidMediaPlayerPlay(RoutingID(),player_id));
 }
 
 void RemoteMediaPlayerManager::OnPaused(int player_id) {
   Send(new MediaPlayerMsg_DidMediaPlayerPause(RoutingID(),player_id));
 }
 
-ScopedVector<MediaPlayerAndroid>::iterator
+std::vector<std::unique_ptr<MediaPlayerAndroid>>::iterator
 RemoteMediaPlayerManager::GetAlternativePlayer(int player_id) {
   for (auto it = alternative_players_.begin(); it != alternative_players_.end();
        ++it) {
     if ((*it)->player_id() == player_id) {
       return it;
     }
   }
   return alternative_players_.end();
 }
 
 RemoteMediaPlayerBridge* RemoteMediaPlayerManager::GetRemotePlayer(
     int player_id) {
   if (IsPlayingRemotely(player_id))
     return static_cast<RemoteMediaPlayerBridge*>(GetPlayer(player_id));
   auto it = GetAlternativePlayer(player_id);
   if (it == alternative_players_.end())
     return nullptr;
-  return static_cast<RemoteMediaPlayerBridge*>(*it);
+  return static_cast<RemoteMediaPlayerBridge*>(it->get());
 }
 
 MediaPlayerAndroid* RemoteMediaPlayerManager::GetLocalPlayer(int player_id) {
   if (!IsPlayingRemotely(player_id))
     return static_cast<RemoteMediaPlayerBridge*>(GetPlayer(player_id));
   auto it = GetAlternativePlayer(player_id);
   if (it == alternative_players_.end())
     return nullptr;
-  return *it;
+  return it->get();
 }
 
 void RemoteMediaPlayerManager::OnMediaMetadataChanged(int player_id,
                                                       base::TimeDelta duration,
                                                       int width,
                                                       int height,
                                                       bool success) {
   if (IsPlayingRemotely(player_id)) {
     MediaPlayerAndroid* local_player = GetLocalPlayer(player_id);
     Send(new MediaPlayerMsg_MediaMetadataChanged(
         RoutingID(), player_id, duration, local_player->GetVideoWidth(),
         local_player->GetVideoHeight(), success));
   } else {
     BrowserMediaPlayerManager::OnMediaMetadataChanged(player_id, duration,
                                                       width, height, success);
   }
 }
 } // namespace remote_media