Remove ScopedVector from content/browser/ [1].

content/browser/media/android/browser_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 "content/browser/media/android/browser_media_player_manager.h"
 
 #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"
 #include "content/browser/media/android/media_throttler.h"
 #include "content/browser/media/android/media_web_contents_observer_android.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
 #include "content/browser/web_contents/web_contents_impl.h"
 #include "content/common/media/media_player_messages_android.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
@@ skipping 52 matching lines @@
     return g_factory(rfh);
   return new BrowserMediaPlayerManager(rfh);
 }
 
 #if !defined(USE_AURA)
 ContentViewCore* BrowserMediaPlayerManager::GetContentViewCore() const {
   return ContentViewCoreImpl::FromWebContents(web_contents());
 }
 #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;
 
       bool should_block = false;
       bool extract_metadata =
           // Initialize the player will cause MediaMetadataExtractor to decode
           // small chunks of data.
           RequestDecoderResources(media_player_params.player_id, true);
 #if !defined(USE_AURA)
       if (WebContentsDelegate* delegate = web_contents_->GetDelegate()) {
         should_block =
             delegate->ShouldBlockMediaRequest(media_player_params.url);
       } else {
         extract_metadata = false;
       }
 #endif
       if (!extract_metadata) {
         // May reach here due to prerendering or throttling. Don't extract the
         // metadata since it is expensive.
         // TODO(qinmin): extract the metadata once the user decided to load
         // the page.
         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(
     RenderFrameHost* render_frame_host)
     : render_frame_host_(render_frame_host),
       fullscreen_player_id_(kInvalidMediaPlayerId),
       fullscreen_player_is_released_(false),
       web_contents_(WebContents::FromRenderFrameHost(render_frame_host)),
       weak_ptr_factory_(this) {
 }
 
 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) {
 #if defined(USE_AURA)
   // TODO(crbug.com/548024)
   NOTIMPLEMENTED();
 #else
   if (WebContentsDelegate* delegate = web_contents_->GetDelegate())
     delegate->ExitFullscreenModeForTab(web_contents_);
 
@@ skipping 113 matching lines @@
 media::MediaUrlInterceptor*
 BrowserMediaPlayerManager::GetMediaUrlInterceptor() {
   return media_url_interceptor_;
 }
 
 MediaPlayerAndroid* BrowserMediaPlayerManager::GetFullscreenPlayer() {
   return GetPlayer(fullscreen_player_id_);
 }
 
 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,
                                             base::TimeDelta duration,
                                             bool has_audio) {
   DCHECK(player_id_to_delegate_id_map_.find(player_id) !=
          player_id_to_delegate_id_map_.end());
   return MediaWebContentsObserverAndroid::FromWebContents(web_contents_)
       ->RequestPlay(render_frame_host_,
                     player_id_to_delegate_id_map_[player_id], has_audio,
@@ skipping 50 matching lines @@
   }
 #endif  // defined(USE_AURA)
 }
 
 void BrowserMediaPlayerManager::OnInitialize(
     const MediaPlayerHostMsg_Initialize_Params& media_player_params) {
   DestroyPlayer(media_player_params.player_id);
 
   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) {
   MediaPlayerAndroid* player = GetPlayer(player_id);
   if (!player)
     return;
 
   if (RequestDecoderResources(player_id, false)) {
     StartInternal(player_id);
   } else if (WebContentsDelegate* delegate = web_contents_->GetDelegate()){
@@ skipping 52 matching lines @@
 void BrowserMediaPlayerManager::OnRequestRemotePlaybackStop(
     int /* player_id */) {
   // Does nothing if we don't have a remote player
 }
 
 bool BrowserMediaPlayerManager::IsPlayingRemotely(int player_id) {
   return false;
 }
 
 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;
     }
   }
   active_players_.erase(player_id);
   player_id_to_delegate_id_map_.erase(player_id);
 }
 
 void BrowserMediaPlayerManager::ReleaseResources(int player_id) {
   MediaPlayerAndroid* player = GetPlayer(player_id);
   if (player)
     ReleasePlayer(player);
   if (player_id == fullscreen_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(
     int player_id, bool temporary) {
   if (!MediaThrottler::GetInstance()->RequestDecoderResources())
     return false;
 
   ActivePlayerMap::iterator it;
   // The player is already active, ignore it. A long running player should not
   // request temporary permissions.
@@ skipping 66 matching lines @@
   if (!player)
     return;
   player->Start();
   if (fullscreen_player_id_ == player_id && fullscreen_player_is_released_) {
     video_view_->OpenVideo();
     fullscreen_player_is_released_ = false;
   }
 }
 
 }  // namespace content