Move Renderer permanent callbacks into RendererClient interface.

media/renderers/video_renderer_impl.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 "media/renderers/video_renderer_impl.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/location.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_util.h"
 #include "base/time/default_tick_clock.h"
 #include "base/trace_event/trace_event.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/limits.h"
 #include "media/base/media_log.h"
 #include "media/base/media_switches.h"
 #include "media/base/pipeline_status.h"
+#include "media/base/renderer_client.h"
 #include "media/base/video_frame.h"
 #include "media/renderers/gpu_video_accelerator_factories.h"
 #include "media/video/gpu_memory_buffer_video_frame_pool.h"
 
 namespace media {
 
 VideoRendererImpl::VideoRendererImpl(
     const scoped_refptr<base::SingleThreadTaskRunner>& media_task_runner,
     const scoped_refptr<base::TaskRunner>& worker_task_runner,
     VideoRendererSink* sink,
     ScopedVector<VideoDecoder> decoders,
     bool drop_frames,
     GpuVideoAcceleratorFactories* gpu_factories,
     const scoped_refptr<MediaLog>& media_log)
     : task_runner_(media_task_runner),
       sink_(sink),
       sink_started_(false),
+      client_(nullptr),
       video_frame_stream_(new VideoFrameStream(media_task_runner,
                                                std::move(decoders),
                                                media_log)),
       gpu_memory_buffer_pool_(nullptr),
       media_log_(media_log),
       low_delay_(false),
       received_end_of_stream_(false),
       rendered_end_of_stream_(false),
       state_(kUninitialized),
       sequence_token_(0),
@@ skipping 38 matching lines @@
 
   base::AutoLock auto_lock(lock_);
   DCHECK_EQ(state_, kPlaying);
   flush_cb_ = callback;
   state_ = kFlushing;
 
   // This is necessary if the |video_frame_stream_| has already seen an end of
   // stream and needs to drain it before flushing it.
   if (buffering_state_ != BUFFERING_HAVE_NOTHING) {
     buffering_state_ = BUFFERING_HAVE_NOTHING;
-    buffering_state_cb_.Run(BUFFERING_HAVE_NOTHING);
+    task_runner_->PostTask(
+        FROM_HERE, base::Bind(&VideoRendererImpl::OnBufferingStateChange,
+                              weak_factory_.GetWeakPtr(), buffering_state_));
   }
   received_end_of_stream_ = false;
   rendered_end_of_stream_ = false;
 
   algorithm_->Reset();
 
   video_frame_stream_->Reset(
       base::Bind(&VideoRendererImpl::OnVideoFrameStreamResetDone,
                  weak_factory_.GetWeakPtr()));
 }
 
 void VideoRendererImpl::StartPlayingFrom(base::TimeDelta timestamp) {
   DVLOG(1) << __FUNCTION__ << "(" << timestamp.InMicroseconds() << ")";
   DCHECK(task_runner_->BelongsToCurrentThread());
   base::AutoLock auto_lock(lock_);
   DCHECK_EQ(state_, kFlushed);
   DCHECK(!pending_read_);
   DCHECK_EQ(buffering_state_, BUFFERING_HAVE_NOTHING);
 
   state_ = kPlaying;
   start_timestamp_ = timestamp;
   AttemptRead_Locked();
 }
 
 void VideoRendererImpl::Initialize(
     DemuxerStream* stream,
-    const PipelineStatusCB& init_cb,
     CdmContext* cdm_context,
-    const StatisticsCB& statistics_cb,
-    const BufferingStateCB& buffering_state_cb,
-    const base::Closure& ended_cb,
-    const PipelineStatusCB& error_cb,
+    RendererClient* client,
     const TimeSource::WallClockTimeCB& wall_clock_time_cb,
-    const base::Closure& waiting_for_decryption_key_cb) {
+    const PipelineStatusCB& init_cb) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   base::AutoLock auto_lock(lock_);
   DCHECK(stream);
   DCHECK_EQ(stream->type(), DemuxerStream::VIDEO);
   DCHECK(!init_cb.is_null());
-  DCHECK(!statistics_cb.is_null());
-  DCHECK(!buffering_state_cb.is_null());
-  DCHECK(!ended_cb.is_null());
   DCHECK(!wall_clock_time_cb.is_null());
   DCHECK_EQ(kUninitialized, state_);
   DCHECK(!render_first_frame_and_stop_);
   DCHECK(!posted_maybe_stop_after_first_paint_);
   DCHECK(!was_background_rendering_);
   DCHECK(!time_progressing_);
 
   low_delay_ = (stream->liveness() == DemuxerStream::LIVENESS_LIVE);
   UMA_HISTOGRAM_BOOLEAN("Media.VideoRenderer.LowDelay", low_delay_);
   if (low_delay_)
     MEDIA_LOG(DEBUG, media_log_) << "Video rendering in low delay mode.";
 
   // Always post |init_cb_| because |this| could be destroyed if initialization
   // failed.
   init_cb_ = BindToCurrentLoop(init_cb);
 
-  // Always post |buffering_state_cb_| because it may otherwise invoke reentrant
-  // calls to OnTimeStateChanged() under lock, which can deadlock the compositor
-  // and media threads.
-  buffering_state_cb_ = BindToCurrentLoop(buffering_state_cb);
-
-  statistics_cb_ = statistics_cb;
-  ended_cb_ = ended_cb;
-  error_cb_ = error_cb;
+  client_ = client;
   wall_clock_time_cb_ = wall_clock_time_cb;
   state_ = kInitializing;
 
   video_frame_stream_->Initialize(
       stream, base::Bind(&VideoRendererImpl::OnVideoFrameStreamInitialized,
                          weak_factory_.GetWeakPtr()),
-      cdm_context, statistics_cb, waiting_for_decryption_key_cb);
+      cdm_context, base::Bind(&VideoRendererImpl::OnStatisticsUpdate,
+                              weak_factory_.GetWeakPtr()),
+      base::Bind(&VideoRendererImpl::OnWaitingForDecryptionKey,
+                 weak_factory_.GetWeakPtr()));
 }
 
 scoped_refptr<VideoFrame> VideoRendererImpl::Render(
     base::TimeTicks deadline_min,
     base::TimeTicks deadline_max,
     bool background_rendering) {
   base::AutoLock auto_lock(lock_);
   DCHECK_EQ(state_, kPlaying);
 
   size_t frames_dropped = 0;
@@ skipping 87 matching lines @@
   // have not populated any buffers yet.
   state_ = kFlushed;
 
   algorithm_.reset(new VideoRendererAlgorithm(wall_clock_time_cb_));
   if (!drop_frames_)
     algorithm_->disable_frame_dropping();
 
   base::ResetAndReturn(&init_cb_).Run(PIPELINE_OK);
 }
 
+void VideoRendererImpl::OnPlaybackError(PipelineStatus error) {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+  client_->OnError(error);
+}
+
+void VideoRendererImpl::OnPlaybackEnded() {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+  client_->OnEnded();
+}
+
+void VideoRendererImpl::OnStatisticsUpdate(const PipelineStatistics& stats) {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+  client_->OnStatisticsUpdate(stats);
+}
+
+void VideoRendererImpl::OnBufferingStateChange(BufferingState state) {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+  client_->OnBufferingStateChange(state);
+}
+
+void VideoRendererImpl::OnWaitingForDecryptionKey() {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+  client_->OnWaitingForDecryptionKey();
+}
+
 void VideoRendererImpl::SetTickClockForTesting(
     std::unique_ptr<base::TickClock> tick_clock) {
   tick_clock_.swap(tick_clock);
 }
 
 void VideoRendererImpl::SetGpuMemoryBufferVideoForTesting(
     std::unique_ptr<GpuMemoryBufferVideoFramePool> gpu_memory_buffer_pool) {
   gpu_memory_buffer_pool_.swap(gpu_memory_buffer_pool);
 }
 
@@ skipping 60 matching lines @@
       return;
 
     DCHECK_NE(state_, kUninitialized);
     DCHECK_NE(state_, kFlushed);
 
     CHECK(pending_read_);
     pending_read_ = false;
 
     if (status == VideoFrameStream::DECODE_ERROR) {
       DCHECK(!frame);
-      PipelineStatus error = PIPELINE_ERROR_DECODE;
-      task_runner_->PostTask(FROM_HERE, base::Bind(error_cb_, error));
+      task_runner_->PostTask(
+          FROM_HERE,
+          base::Bind(&VideoRendererImpl::OnPlaybackError,
+                     weak_factory_.GetWeakPtr(), PIPELINE_ERROR_DECODE));
       return;
     }
 
     // Already-queued VideoFrameStream ReadCB's can fire after various state
     // transitions have happened; in that case just drop those frames
     // immediately.
     if (state_ == kFlushing)
       return;
 
     DCHECK_EQ(state_, kPlaying);
@@ skipping 73 matching lines @@
 
   return algorithm_->effective_frames_queued() > 0;
 }
 
 void VideoRendererImpl::TransitionToHaveEnough_Locked() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(buffering_state_, BUFFERING_HAVE_NOTHING);
   lock_.AssertAcquired();
 
   buffering_state_ = BUFFERING_HAVE_ENOUGH;
-  buffering_state_cb_.Run(BUFFERING_HAVE_ENOUGH);
+  task_runner_->PostTask(
+      FROM_HERE, base::Bind(&VideoRendererImpl::OnBufferingStateChange,
+                            weak_factory_.GetWeakPtr(), buffering_state_));
 }
 
 void VideoRendererImpl::TransitionToHaveNothing() {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   base::AutoLock auto_lock(lock_);
   if (buffering_state_ != BUFFERING_HAVE_ENOUGH || HaveEnoughData_Locked())
     return;
 
   buffering_state_ = BUFFERING_HAVE_NOTHING;
-  buffering_state_cb_.Run(BUFFERING_HAVE_NOTHING);
+  task_runner_->PostTask(
+      FROM_HERE, base::Bind(&VideoRendererImpl::OnBufferingStateChange,
+                            weak_factory_.GetWeakPtr(), buffering_state_));
 }
 
 void VideoRendererImpl::AddReadyFrame_Locked(
     const scoped_refptr<VideoFrame>& frame) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   lock_.AssertAcquired();
   DCHECK(!frame->metadata()->IsTrue(VideoFrameMetadata::END_OF_STREAM));
 
   frames_decoded_++;
 
@@ skipping 56 matching lines @@
   DCHECK_GE(frames_dropped_, 0);
 
   if (frames_decoded_ || frames_dropped_) {
     PipelineStatistics statistics;
     statistics.video_frames_decoded = frames_decoded_;
     statistics.video_frames_dropped = frames_dropped_;
 
     const size_t memory_usage = algorithm_->GetMemoryUsage();
     statistics.video_memory_usage = memory_usage - last_video_memory_usage_;
 
-    task_runner_->PostTask(FROM_HERE, base::Bind(statistics_cb_, statistics));
+    task_runner_->PostTask(FROM_HERE,
+                           base::Bind(&VideoRendererImpl::OnStatisticsUpdate,
+                                      weak_factory_.GetWeakPtr(), statistics));
     frames_decoded_ = 0;
     frames_dropped_ = 0;
     last_video_memory_usage_ = memory_usage;
   }
 }
 
 void VideoRendererImpl::MaybeStopSinkAfterFirstPaint() {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   if (!time_progressing_ && sink_started_)
@@ skipping 44 matching lines @@
 
   // Don't fire ended if time isn't moving and we have frames.
   if (!time_progressing && algorithm_->frames_queued())
     return;
 
   // Fire ended if we have no more effective frames or only ever had one frame.
   if (!algorithm_->effective_frames_queued() ||
       (algorithm_->frames_queued() == 1u &&
        algorithm_->average_frame_duration().is_zero())) {
     rendered_end_of_stream_ = true;
-    task_runner_->PostTask(FROM_HERE, ended_cb_);
+    task_runner_->PostTask(FROM_HERE,
+                           base::Bind(&VideoRendererImpl::OnPlaybackEnded,
+                                      weak_factory_.GetWeakPtr()));
   }
 }
 
 base::TimeTicks VideoRendererImpl::ConvertMediaTimestamp(
     base::TimeDelta media_time) {
   std::vector<base::TimeDelta> media_times(1, media_time);
   std::vector<base::TimeTicks> wall_clock_times;
   if (!wall_clock_time_cb_.Run(media_times, &wall_clock_times))
     return base::TimeTicks();
   return wall_clock_times[0];
@@ skipping 47 matching lines @@
   // the entire queue.  Note: this may cause slight inaccuracies in the number
   // of dropped frames since the frame may have been rendered before.
   if (!sink_started_ && !algorithm_->effective_frames_queued()) {
     frames_dropped_ += algorithm_->frames_queued();
     algorithm_->Reset(
         VideoRendererAlgorithm::ResetFlag::kPreserveNextFrameEstimates);
   }
 }
 
 }  // namespace media