[Chromecast] Support blocking some video resolutions

chromecast/browser/media/cast_renderer.cc

 // Copyright 2016 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 "chromecast/browser/media/cast_renderer.h"
 
 #include "base/bind.h"
 #include "base/single_thread_task_runner.h"
 #include "chromecast/base/task_runner_impl.h"
+#include "chromecast/browser/media/video_resolution_policy.h"
 #include "chromecast/media/cdm/cast_cdm_context.h"
 #include "chromecast/media/cma/base/balanced_media_task_runner_factory.h"
 #include "chromecast/media/cma/base/cma_logging.h"
 #include "chromecast/media/cma/base/demuxer_stream_adapter.h"
 #include "chromecast/media/cma/pipeline/media_pipeline_impl.h"
 #include "chromecast/media/cma/pipeline/video_pipeline_client.h"
 #include "chromecast/public/media/media_pipeline_backend.h"
 #include "chromecast/public/media/media_pipeline_device_params.h"
 #include "media/base/audio_decoder_config.h"
 #include "media/base/demuxer_stream.h"
 #include "media/base/demuxer_stream_provider.h"
 #include "media/base/media_log.h"
 #include "media/base/renderer_client.h"
 
 namespace chromecast {
 namespace media {
 
 namespace {
 // Maximum difference between audio frame PTS and video frame PTS
 // for frames read from the DemuxerStream.
 const base::TimeDelta kMaxDeltaFetcher(base::TimeDelta::FromMilliseconds(2000));
 }  // namespace
 
 CastRenderer::CastRenderer(
     const CreateMediaPipelineBackendCB& create_backend_cb,
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
-    const std::string& audio_device_id)
+    const std::string& audio_device_id,
+    VideoResolutionPolicy* video_resolution_policy)
     : create_backend_cb_(create_backend_cb),
       task_runner_(task_runner),
       audio_device_id_(audio_device_id),
+      video_resolution_policy_(video_resolution_policy),
       client_(nullptr),
       cast_cdm_context_(nullptr),
       media_task_runner_factory_(
           new BalancedMediaTaskRunnerFactory(kMaxDeltaFetcher)),
       weak_factory_(this) {
   CMALOG(kLogControl) << __FUNCTION__ << ": " << this;
+
+  if (video_resolution_policy_)
+    video_resolution_policy_->AddObserver(this);
 }
 
 CastRenderer::~CastRenderer() {
   CMALOG(kLogControl) << __FUNCTION__ << ": " << this;
   DCHECK(task_runner_->BelongsToCurrentThread());
+
+  if (video_resolution_policy_)
+    video_resolution_policy_->RemoveObserver(this);
 }
 
 void CastRenderer::Initialize(
     ::media::DemuxerStreamProvider* demuxer_stream_provider,
     ::media::RendererClient* client,
     const ::media::PipelineStatusCB& init_cb) {
   CMALOG(kLogControl) << __FUNCTION__ << ": " << this;
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   // Create pipeline backend.
@@ skipping 138 matching lines @@
 bool CastRenderer::HasAudio() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   return pipeline_->HasAudio();
 }
 
 bool CastRenderer::HasVideo() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   return pipeline_->HasVideo();
 }
 
+void CastRenderer::OnVideoResolutionPolicyChanged() {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+  if (!video_resolution_policy_)
+    return;
+
+  if (video_resolution_policy_->ShouldBlock(video_res_))
+    OnError(::media::PIPELINE_ERROR_DECODE);
+}
+
 void CastRenderer::OnError(::media::PipelineStatus status) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   client_->OnError(status);
 }
 
 void CastRenderer::OnEnded(Stream stream) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(!eos_[stream]);
   eos_[stream] = true;
   CMALOG(kLogControl) << __FUNCTION__ << ": eos_audio=" << eos_[STREAM_AUDIO]
@@ skipping 14 matching lines @@
 }
 
 void CastRenderer::OnWaitingForDecryptionKey() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   client_->OnWaitingForDecryptionKey();
 }
 
 void CastRenderer::OnVideoNaturalSizeChange(const gfx::Size& size) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   client_->OnVideoNaturalSizeChange(size);
+
+  video_res_ = size;
+  OnVideoResolutionPolicyChanged();
 }
 
 void CastRenderer::OnVideoOpacityChange(bool opaque) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(opaque);
   client_->OnVideoOpacityChange(opaque);
 }
 
 }  // namespace media
 }  // namespace chromecast