Acquire media resources in MediaPipelineBackendWrapper instead of CastRenderer.

This is necessary for the case where a dynamic group leader has its
resources revoked. In that situation, it needs to release its resources
without stopping the cast app; thus, the CastRenderer needs to remain
but the resources need to be released.

Test: With chromecast internal changes on 1.40ac branch.
Bug: b/141143745
Change-Id: Ia69aa32e7f97bd4126bead4f650f210d00e98d02
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1872240
Commit-Queue: Antonio Rivera <antoniori@google.com>
Reviewed-by: Yuchen Liu <yucliu@chromium.org>
Cr-Commit-Position: refs/heads/master@{#708038}

chromecast/browser/cast_browser_main_parts.cc

@@ -409,7 +409,8 @@ CastBrowserMainParts::media_pipeline_backend_manager() {
   if (!media_pipeline_backend_manager_) {
     media_pipeline_backend_manager_ =
         std::make_unique<media::MediaPipelineBackendManager>(
-            cast_content_browser_client_->GetMediaTaskRunner());
+            cast_content_browser_client_->GetMediaTaskRunner(),
+            cast_content_browser_client_->media_resource_tracker());
   }
   return media_pipeline_backend_manager_.get();
 }

chromecast/browser/cast_content_browser_client.cc

@@ -153,8 +153,7 @@ static void CreateMediaService(CastContentBrowserClient* browser_client,
       base::Bind(&CastContentBrowserClient::CreateCdmFactory,
                  base::Unretained(browser_client)),
       browser_client->GetVideoModeSwitcher(),
-      browser_client->GetVideoResolutionPolicy(),
-      browser_client->media_resource_tracker());
+      browser_client->GetVideoResolutionPolicy());
   service = std::make_unique<::media::MediaService>(
       std::move(mojo_media_client), std::move(request));
   service_manager::Service::RunAsyncUntilTermination(std::move(service));
@@ -1047,8 +1046,7 @@ void CastContentBrowserClient::BindMediaRenderer(
       std::make_unique<media::CastRenderer>(
           GetCmaBackendFactory(), std::move(media_task_runner),
           GetVideoModeSwitcher(), GetVideoResolutionPolicy(),
-          media_resource_tracker(), nullptr /* connector */,
-          nullptr /* host_interfaces */),
+          nullptr /* connector */, nullptr /* host_interfaces */),
       std::move(request));
 }
 

chromecast/media/cma/backend/BUILD.gn

@@ -40,6 +40,7 @@ cast_source_set("backend") {
     "//chromecast:chromecast_buildflags",
     "//chromecast/base/metrics:metrics",
     "//chromecast/media:libcast_media",
+    "//chromecast/media/base:media_resource_tracker",
     "//chromecast/media/cma/base",
     "//chromecast/media/cma/decoder",
   ]

chromecast/media/cma/backend/media_pipeline_backend_manager.cc

@@ -41,8 +41,10 @@ constexpr base::TimeDelta kPowerSaveWaitTime = base::TimeDelta::FromSeconds(5);
 }  // namespace
 
 MediaPipelineBackendManager::MediaPipelineBackendManager(
-    scoped_refptr<base::SingleThreadTaskRunner> media_task_runner)
+    scoped_refptr<base::SingleThreadTaskRunner> media_task_runner,
+    MediaResourceTracker* media_resource_tracker)
     : media_task_runner_(std::move(media_task_runner)),
+      media_resource_tracker_(media_resource_tracker),
       playing_audio_streams_count_({{AudioContentType::kMedia, 0},
                                     {AudioContentType::kAlarm, 0},
                                     {AudioContentType::kCommunication, 0},
@@ -76,7 +78,8 @@ MediaPipelineBackendManager::~MediaPipelineBackendManager() {
 std::unique_ptr<CmaBackend> MediaPipelineBackendManager::CreateCmaBackend(
     const media::MediaPipelineDeviceParams& params) {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
-  return std::make_unique<MediaPipelineBackendWrapper>(params, this);
+  return std::make_unique<MediaPipelineBackendWrapper>(params, this,
+                                                       media_resource_tracker_);
 }
 
 void MediaPipelineBackendManager::BackendDestroyed(

chromecast/media/cma/backend/media_pipeline_backend_manager.h

@@ -28,6 +28,7 @@ class CastDecoderBuffer;
 class CmaBackend;
 class MediaPipelineBackendWrapper;
 class ActiveMediaPipelineBackendWrapper;
+class MediaResourceTracker;
 
 // This class tracks all created media backends, tracking whether or not volume
 // feedback sounds should be enabled based on the currently active backends.
@@ -82,8 +83,9 @@ class MediaPipelineBackendManager {
     NUM_DECODER_TYPES
   };
 
-  explicit MediaPipelineBackendManager(
-      scoped_refptr<base::SingleThreadTaskRunner> media_task_runner);
+  MediaPipelineBackendManager(
+      scoped_refptr<base::SingleThreadTaskRunner> media_task_runner,
+      MediaResourceTracker* media_resource_tracker);
   ~MediaPipelineBackendManager();
 
   // Creates a CMA backend. Must be called on the same thread as
@@ -156,6 +158,7 @@ class MediaPipelineBackendManager {
   void EnterPowerSaveMode();
 
   const scoped_refptr<base::SingleThreadTaskRunner> media_task_runner_;
+  MediaResourceTracker* const media_resource_tracker_;
 
   // Total count of decoders created
   int decoder_count_[NUM_DECODER_TYPES];

chromecast/media/cma/backend/media_pipeline_backend_wrapper.cc

@@ -78,7 +78,8 @@ class ActiveMediaPipelineBackendWrapper : public DecoderCreatorCmaBackend {
   ActiveMediaPipelineBackendWrapper(
       const media::MediaPipelineDeviceParams& params,
       MediaPipelineBackendWrapper* wrapping_backend,
-      MediaPipelineBackendManager* backend_manager);
+      MediaPipelineBackendManager* backend_manager,
+      MediaResourceTracker* media_resource_tracker);
   ~ActiveMediaPipelineBackendWrapper() override;
 
   // DecoderCreatorCmaBackend implementation:
@@ -115,6 +116,10 @@ class ActiveMediaPipelineBackendWrapper : public DecoderCreatorCmaBackend {
   const MediaPipelineDeviceParams::AudioStreamType audio_stream_type_;
   const AudioContentType content_type_;
 
+  // Acquire the media resource at construction. The resource will be released
+  // when this class is destructed.
+  MediaResourceTracker::ScopedUsage media_resource_usage_;
+
   bool playing_;
 
   DISALLOW_COPY_AND_ASSIGN(ActiveMediaPipelineBackendWrapper);
@@ -123,7 +128,8 @@ class ActiveMediaPipelineBackendWrapper : public DecoderCreatorCmaBackend {
 ActiveMediaPipelineBackendWrapper::ActiveMediaPipelineBackendWrapper(
     const media::MediaPipelineDeviceParams& params,
     MediaPipelineBackendWrapper* wrapping_backend,
-    MediaPipelineBackendManager* backend_manager)
+    MediaPipelineBackendManager* backend_manager,
+    MediaResourceTracker* media_resource_tracker)
     : audio_decoder_ptr_(nullptr),
       video_decoder_created_(false),
       backend_(base::WrapUnique(
@@ -132,6 +138,7 @@ ActiveMediaPipelineBackendWrapper::ActiveMediaPipelineBackendWrapper(
       backend_manager_(backend_manager),
       audio_stream_type_(params.audio_type),
       content_type_(params.content_type),
+      media_resource_usage_(media_resource_tracker),
       playing_(false) {
   DCHECK(backend_);
   DCHECK(backend_manager_);
@@ -277,12 +284,13 @@ void ActiveMediaPipelineBackendWrapper::SetPlaying(bool playing) {
 
 MediaPipelineBackendWrapper::MediaPipelineBackendWrapper(
     const media::MediaPipelineDeviceParams& params,
-    MediaPipelineBackendManager* backend_manager)
+    MediaPipelineBackendManager* backend_manager,
+    MediaResourceTracker* media_resource_tracker)
     : revoked_(false),
       backend_manager_(backend_manager),
       content_type_(params.content_type) {
   backend_ = std::make_unique<ActiveMediaPipelineBackendWrapper>(
-      params, this, backend_manager);
+      params, this, backend_manager, media_resource_tracker);
 }
 
 MediaPipelineBackendWrapper::~MediaPipelineBackendWrapper() {

chromecast/media/cma/backend/media_pipeline_backend_wrapper.h

@@ -12,6 +12,7 @@
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/time/time.h"
+#include "chromecast/media/base/media_resource_tracker.h"
 #include "chromecast/media/cma/backend/cma_backend.h"
 #include "chromecast/public/media/media_pipeline_device_params.h"
 
@@ -28,7 +29,8 @@ class DecoderCreatorCmaBackend;
 class MediaPipelineBackendWrapper : public CmaBackend {
  public:
   MediaPipelineBackendWrapper(const media::MediaPipelineDeviceParams& params,
-                              MediaPipelineBackendManager* backend_manager);
+                              MediaPipelineBackendManager* backend_manager,
+                              MediaResourceTracker* media_resource_tracker);
   ~MediaPipelineBackendWrapper() override;
 
   // After revocation, this class releases the media resource on the device,

chromecast/media/service/cast_mojo_media_client.cc

@@ -18,14 +18,12 @@ CastMojoMediaClient::CastMojoMediaClient(
     CmaBackendFactory* backend_factory,
     const CreateCdmFactoryCB& create_cdm_factory_cb,
     VideoModeSwitcher* video_mode_switcher,
-    VideoResolutionPolicy* video_resolution_policy,
-    MediaResourceTracker* media_resource_tracker)
+    VideoResolutionPolicy* video_resolution_policy)
     : connector_(nullptr),
       backend_factory_(backend_factory),
       create_cdm_factory_cb_(create_cdm_factory_cb),
       video_mode_switcher_(video_mode_switcher),
-      video_resolution_policy_(video_resolution_policy),
-      media_resource_tracker_(media_resource_tracker) {
+      video_resolution_policy_(video_resolution_policy) {
   DCHECK(backend_factory_);
 }
 
@@ -50,8 +48,7 @@ std::unique_ptr<::media::Renderer> CastMojoMediaClient::CreateCastRenderer(
   // |overlay_plane_id|s.
   return std::make_unique<CastRenderer>(
       backend_factory_, task_runner, video_mode_switcher_,
-      video_resolution_policy_, media_resource_tracker_, connector_,
-      host_interfaces);
+      video_resolution_policy_, connector_, host_interfaces);
 }
 #endif
 
@@ -62,8 +59,7 @@ std::unique_ptr<::media::Renderer> CastMojoMediaClient::CreateRenderer(
     const std::string& audio_device_id) {
   return std::make_unique<CastRenderer>(
       backend_factory_, task_runner, video_mode_switcher_,
-      video_resolution_policy_, media_resource_tracker_, connector_,
-      host_interfaces);
+      video_resolution_policy_, connector_, host_interfaces);
 }
 
 std::unique_ptr<::media::CdmFactory> CastMojoMediaClient::CreateCdmFactory(

chromecast/media/service/cast_mojo_media_client.h

@@ -15,7 +15,6 @@ namespace chromecast {
 namespace media {
 
 class CmaBackendFactory;
-class MediaResourceTracker;
 class VideoModeSwitcher;
 class VideoResolutionPolicy;
 
@@ -28,8 +27,7 @@ class CastMojoMediaClient : public ::media::MojoMediaClient {
   CastMojoMediaClient(CmaBackendFactory* backend_factory,
                       const CreateCdmFactoryCB& create_cdm_factory_cb,
                       VideoModeSwitcher* video_mode_switcher,
-                      VideoResolutionPolicy* video_resolution_policy,
-                      MediaResourceTracker* media_resource_tracker);
+                      VideoResolutionPolicy* video_resolution_policy);
   ~CastMojoMediaClient() override;
 
   // MojoMediaClient implementation:
@@ -55,7 +53,6 @@ class CastMojoMediaClient : public ::media::MojoMediaClient {
   const CreateCdmFactoryCB create_cdm_factory_cb_;
   VideoModeSwitcher* video_mode_switcher_;
   VideoResolutionPolicy* video_resolution_policy_;
-  MediaResourceTracker* media_resource_tracker_;
 
   DISALLOW_COPY_AND_ASSIGN(CastMojoMediaClient);
 };

chromecast/media/service/cast_renderer.cc

@@ -60,14 +60,12 @@ CastRenderer::CastRenderer(
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
     VideoModeSwitcher* video_mode_switcher,
     VideoResolutionPolicy* video_resolution_policy,
-    MediaResourceTracker* media_resource_tracker,
     service_manager::Connector* connector,
     service_manager::mojom::InterfaceProvider* host_interfaces)
     : backend_factory_(backend_factory),
       task_runner_(task_runner),
       video_mode_switcher_(video_mode_switcher),
       video_resolution_policy_(video_resolution_policy),
-      media_resource_tracker_(media_resource_tracker),
       connector_(connector),
       host_interfaces_(host_interfaces),
       client_(nullptr),
@@ -164,8 +162,6 @@ void CastRenderer::OnGetMultiroomInfo(
   // trigger a second call to this function.
   multiroom_manager_.reset();
   // Create pipeline backend.
-  media_resource_usage_.reset(
-      new MediaResourceTracker::ScopedUsage(media_resource_tracker_));
   backend_task_runner_.reset(new TaskRunnerImpl());
   // TODO(erickung): crbug.com/443956. Need to provide right LoadType.
   LoadType load_type = kLoadTypeMediaSource;

chromecast/media/service/cast_renderer.h

@@ -10,7 +10,6 @@
 
 #include "base/memory/weak_ptr.h"
 #include "chromecast/common/mojom/multiroom.mojom.h"
-#include "chromecast/media/base/media_resource_tracker.h"
 #include "chromecast/media/base/video_resolution_policy.h"
 #include "chromecast/media/cma/backend/cma_backend_factory.h"
 #include "media/base/renderer.h"
@@ -48,7 +47,6 @@ class CastRenderer : public ::media::Renderer,
                const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
                VideoModeSwitcher* video_mode_switcher,
                VideoResolutionPolicy* video_resolution_policy,
-               MediaResourceTracker* media_resource_tracker,
                service_manager::Connector* connector,
                service_manager::mojom::InterfaceProvider* host_interfaces);
   ~CastRenderer() final;
@@ -98,11 +96,8 @@ class CastRenderer : public ::media::Renderer,
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
   VideoModeSwitcher* video_mode_switcher_;
   VideoResolutionPolicy* video_resolution_policy_;
-  MediaResourceTracker* media_resource_tracker_;
   service_manager::Connector* connector_;
   service_manager::mojom::InterfaceProvider* host_interfaces_;
-  // Must outlive |pipeline_| to properly count resource usage.
-  std::unique_ptr<MediaResourceTracker::ScopedUsage> media_resource_usage_;
 
   ::media::RendererClient* client_;
   CastCdmContext* cast_cdm_context_;