Move Renderer permanent callbacks into RendererClient interface.

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>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.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/av_pipeline_client.h"
 #include "chromecast/media/cma/pipeline/media_pipeline_client.h"
 #include "chromecast/media/cma/pipeline/video_pipeline_client.h"
 #include "chromecast/renderer/media/audio_pipeline_proxy.h"
 #include "chromecast/renderer/media/hole_frame_factory.h"
 #include "chromecast/renderer/media/media_pipeline_proxy.h"
 #include "chromecast/renderer/media/video_pipeline_proxy.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/demuxer_stream_provider.h"
 #include "media/base/pipeline_status.h"
+#include "media/base/renderer_client.h"
 #include "media/base/time_delta_interpolator.h"
 #include "media/base/video_renderer_sink.h"
 #include "media/renderers/gpu_video_accelerator_factories.h"
 #include "ui/gfx/geometry/size.h"
 
 namespace chromecast {
 namespace media {
 
 namespace {
 
@@ skipping 40 matching lines @@
     base::ResetAndReturn(&init_cb_).Run(::media::PIPELINE_ERROR_ABORT);
   else if (!flush_cb_.is_null())
     base::ResetAndReturn(&flush_cb_).Run();
 
   if (has_audio_ || has_video_)
     media_pipeline_->Stop();
 }
 
 void CmaRenderer::Initialize(
     ::media::DemuxerStreamProvider* demuxer_stream_provider,
-    const ::media::PipelineStatusCB& init_cb,
-    const ::media::StatisticsCB& statistics_cb,
-    const ::media::BufferingStateCB& buffering_state_cb,
-    const base::Closure& ended_cb,
-    const ::media::PipelineStatusCB& error_cb,
-    const base::Closure& waiting_for_decryption_key_cb) {
+    ::media::RendererClient* client,
+    const ::media::PipelineStatusCB& init_cb) {
   CMALOG(kLogControl) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_EQ(state_, kUninitialized) << state_;
   DCHECK(!init_cb.is_null());
-  DCHECK(!statistics_cb.is_null());
-  DCHECK(!ended_cb.is_null());
-  DCHECK(!error_cb.is_null());
-  DCHECK(!buffering_state_cb.is_null());
-  DCHECK(!waiting_for_decryption_key_cb.is_null());
   DCHECK(demuxer_stream_provider->GetStream(::media::DemuxerStream::AUDIO) ||
          demuxer_stream_provider->GetStream(::media::DemuxerStream::VIDEO));
 
   // Deferred from ctor so as to initialise on correct thread.
   hole_frame_factory_.reset(new HoleFrameFactory(gpu_factories_));
 
   BeginStateTransition();
 
   demuxer_stream_provider_ = demuxer_stream_provider;
-  statistics_cb_ = statistics_cb;
-  buffering_state_cb_ = buffering_state_cb;
-  ended_cb_ = ended_cb;
-  error_cb_ = error_cb;
-  waiting_for_decryption_key_cb_ = waiting_for_decryption_key_cb;
+  client_ = client;
 
   MediaPipelineClient media_pipeline_client;
-  media_pipeline_client.error_cb = ::media::BindToCurrentLoop(error_cb_);
+  media_pipeline_client.error_cb =
+      ::media::BindToCurrentLoop(base::Bind(&CmaRenderer::OnError, weak_this_));
   media_pipeline_client.buffering_state_cb = ::media::BindToCurrentLoop(
       base::Bind(&CmaRenderer::OnBufferingNotification, weak_this_));
   media_pipeline_client.time_update_cb = ::media::BindToCurrentLoop(
       base::Bind(&CmaRenderer::OnPlaybackTimeUpdated, weak_this_));
   media_pipeline_client.pipeline_backend_created_cb =
       base::Bind(&MediaPipelineClientDummyCallback);
   media_pipeline_client.pipeline_backend_destroyed_cb =
       base::Bind(&MediaPipelineClientDummyCallback);
   media_pipeline_->SetClient(media_pipeline_client);
 
@@ skipping 23 matching lines @@
     time_interpolator_->StopInterpolating();
   }
 }
 
 void CmaRenderer::StartPlayingFrom(base::TimeDelta time) {
   CMALOG(kLogControl) << __FUNCTION__ << ": " << time.InMilliseconds();
   DCHECK(thread_checker_.CalledOnValidThread());
   BeginStateTransition();
 
   if (state_ == kError) {
-    error_cb_.Run(::media::PIPELINE_ERROR_ABORT);
+    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
@@ skipping 190 matching lines @@
     base::ResetAndReturn(&init_cb_).Run(status);
     return;
   }
 
   has_video_ = video_stream_present;
   CompleteStateTransition(kFlushed);
   base::ResetAndReturn(&init_cb_).Run(::media::PIPELINE_OK);
 }
 
 void CmaRenderer::OnWaitForKey(bool is_audio) {
-  waiting_for_decryption_key_cb_.Run();
+  client_->OnWaitingForDecryptionKey();
 }
 
 void CmaRenderer::OnEosReached(bool is_audio) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (state_ != kPlaying) {
     LOG(WARNING) << __FUNCTION__ << " Ignoring a late EOS event";
     return;
   }
 
   if (is_audio) {
     DCHECK(!received_audio_eos_);
     received_audio_eos_ = true;
   } else {
     DCHECK(!received_video_eos_);
     received_video_eos_ = true;
   }
 
   bool audio_finished = !has_audio_ || received_audio_eos_;
   bool video_finished = !has_video_ || received_video_eos_;
   CMALOG(kLogControl) << __FUNCTION__ << " audio_finished=" << audio_finished
                       << " video_finished=" << video_finished;
   if (audio_finished && video_finished)
-    ended_cb_.Run();
+    client_->OnEnded();
 }
 
 void CmaRenderer::OnStatisticsUpdated(
     const ::media::PipelineStatistics& stats) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  statistics_cb_.Run(stats);
+  client_->OnStatisticsUpdate(stats);
 }
 
 void CmaRenderer::OnNaturalSizeChanged(const gfx::Size& size) {
   DCHECK(thread_checker_.CalledOnValidThread());
   video_renderer_sink_->PaintFrameUsingOldRenderingPath(
       hole_frame_factory_->CreateHoleFrame(size));
 }
 
 void CmaRenderer::OnPlaybackTimeUpdated(base::TimeDelta time,
                                         base::TimeDelta max_time,
@@ skipping 11 matching lines @@
       std::min(max_time, time + base::TimeTicks::Now() - capture_time);
 
   base::AutoLock auto_lock(time_interpolator_lock_);
   time_interpolator_->SetBounds(lower_bound, max_time);
 }
 
 void CmaRenderer::OnBufferingNotification(
     ::media::BufferingState buffering_state) {
   CMALOG(kLogControl) << __FUNCTION__ << ": state=" << state_
                       << ", buffering=" << buffering_state;
-  buffering_state_cb_.Run(buffering_state);
+  DCHECK(thread_checker_.CalledOnValidThread());
+  client_->OnBufferingStateChange(buffering_state);
 }
 
 void CmaRenderer::OnFlushDone() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (state_ == kError) {
     // If OnError was called while the flush was in progress,
     // |flush_cb_| must be null.
     DCHECK(flush_cb_.is_null());
     return;
   }
 
   CompleteStateTransition(kFlushed);
   base::ResetAndReturn(&flush_cb_).Run();
 }
 
 void CmaRenderer::OnError(::media::PipelineStatus error) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_NE(::media::PIPELINE_OK, error) << "PIPELINE_OK isn't an error!";
   LOG(ERROR) << "CMA error encountered: " << error;
 
   State old_state = state_;
   CompleteStateTransition(kError);
 
   if (old_state != kError) {
     if (!init_cb_.is_null()) {
       base::ResetAndReturn(&init_cb_).Run(error);
       return;
     }
-    error_cb_.Run(error);
+    client_->OnError(error);
   }
 
   // After OnError() returns, the pipeline may destroy |this|.
   if (!flush_cb_.is_null())
     base::ResetAndReturn(&flush_cb_).Run();
 }
 
 void CmaRenderer::BeginStateTransition() {
   DCHECK(!is_pending_transition_) << state_;
   is_pending_transition_ = true;
 }
 
 void CmaRenderer::CompleteStateTransition(State new_state) {
   state_ = new_state;
   is_pending_transition_ = false;
 }
 
 }  // namespace media
 }  // namespace chromecast