Moves video frame callbacks from VideoFrameCompositor to Renderer.

chromecast/renderer/media/cma_renderer.cc

 // Copyright 2014 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/renderer/media/cma_renderer.h"
 
 #include <algorithm>
 #include <utility>
 #include <vector>
 
@@ skipping 43 matching lines @@
       media_pipeline_(std::move(media_pipeline)),
       audio_pipeline_(media_pipeline_->GetAudioPipeline()),
       video_pipeline_(media_pipeline_->GetVideoPipeline()),
       video_renderer_sink_(video_renderer_sink),
       state_(kUninitialized),
       is_pending_transition_(false),
       has_audio_(false),
       has_video_(false),
       received_audio_eos_(false),
       received_video_eos_(false),
-      initial_natural_size_(gfx::Size()),
-      initial_video_hole_created_(false),
       gpu_factories_(gpu_factories),
       time_interpolator_(
           new ::media::TimeDeltaInterpolator(&default_tick_clock_)),
       playback_rate_(1.0),
       weak_factory_(this) {
   weak_this_ = weak_factory_.GetWeakPtr();
   thread_checker_.DetachFromThread();
 
   time_interpolator_->SetUpperBound(base::TimeDelta());
 }
@@ skipping 72 matching lines @@
   CMALOG(kLogControl) << __FUNCTION__ << ": " << time.InMilliseconds();
   DCHECK(thread_checker_.CalledOnValidThread());
   BeginStateTransition();
 
   if (state_ == kError) {
     client_->OnError(::media::PIPELINE_ERROR_ABORT);
     CompleteStateTransition(kError);
     return;
   }
 
-  // Create a video hole frame just before starting playback.
-  // Note that instead of creating the video hole frame in Initialize(), we do
-  // it here because paint_cb_ (which eventually calls OnOpacityChanged)
-  // expects the current state to not be HaveNothing. And the place where
-  // the ready state is changed to HaveMetadata (OnPipelineMetadata) is
-  // right before the pipeline calls StartPlayingFrom (in
-  // Pipeline::StateTransitionTask).
-  if (HasVideo() && !initial_video_hole_created_) {
-    initial_video_hole_created_ = true;
-    video_renderer_sink_->PaintFrameUsingOldRenderingPath(
-        hole_frame_factory_->CreateHoleFrame(initial_natural_size_));
-  }
-
   {
     base::AutoLock auto_lock(time_interpolator_lock_);
     time_interpolator_.reset(
         new ::media::TimeDeltaInterpolator(&default_tick_clock_));
     time_interpolator_->SetPlaybackRate(playback_rate_);
     time_interpolator_->SetBounds(time, time);
     time_interpolator_->StartInterpolating();
   }
 
   received_audio_eos_ = false;
@@ skipping 142 matching lines @@
       base::Bind(&CmaRenderer::OnNaturalSizeChanged, weak_this_));
   video_pipeline_->SetClient(client);
 
   std::unique_ptr<CodedFrameProvider> frame_provider(new DemuxerStreamAdapter(
       base::ThreadTaskRunnerHandle::Get(), media_task_runner_factory_, stream));
 
   const ::media::VideoDecoderConfig& config = stream->video_decoder_config();
   if (config.codec() == ::media::kCodecH264)
     stream->EnableBitstreamConverter();
 
-  initial_natural_size_ = config.natural_size();
-
   std::vector<::media::VideoDecoderConfig> configs;
   configs.push_back(config);
   media_pipeline_->InitializeVideo(configs, std::move(frame_provider),
                                    video_initialization_done_cb);
 }
 
 void CmaRenderer::OnVideoPipelineInitializeDone(
     bool video_stream_present,
     ::media::PipelineStatus status) {
   CMALOG(kLogControl) << __FUNCTION__ << ": state=" << state_;
@@ skipping 45 matching lines @@
 void CmaRenderer::OnStatisticsUpdated(
     const ::media::PipelineStatistics& stats) {
   DCHECK(thread_checker_.CalledOnValidThread());
   client_->OnStatisticsUpdate(stats);
 }
 
 void CmaRenderer::OnNaturalSizeChanged(const gfx::Size& size) {
   DCHECK(thread_checker_.CalledOnValidThread());
   video_renderer_sink_->PaintFrameUsingOldRenderingPath(
       hole_frame_factory_->CreateHoleFrame(size));
+  client_->OnVideoNaturalSizeChange(size);
 }
 
 void CmaRenderer::OnPlaybackTimeUpdated(base::TimeDelta time,
                                         base::TimeDelta max_time,
                                         base::TimeTicks capture_time) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (state_ != kPlaying) {
     LOG(WARNING) << "Ignoring a late time update";
     return;
   }
@@ skipping 56 matching lines @@
   is_pending_transition_ = true;
 }
 
 void CmaRenderer::CompleteStateTransition(State new_state) {
   state_ = new_state;
   is_pending_transition_ = false;
 }
 
 }  // namespace media
 }  // namespace chromecast