Move Renderer permanent callbacks into RendererClient interface.

media/base/pipeline_impl.cc

 // Copyright (c) 2012 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/base/pipeline_impl.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 339 matching lines @@
   DCHECK(media_task_runner_->BelongsToCurrentThread());
   DCHECK(IsRunning());
   DCHECK_NE(PIPELINE_OK, error);
   VLOG(1) << "Media pipeline error: " << error;
 
   media_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&PipelineImpl::ErrorChangedTask, weak_this_, error));
 }
 
+void PipelineImpl::OnEnded() {
+  DCHECK(media_task_runner_->BelongsToCurrentThread());
+  media_log_->AddEvent(media_log_->CreateEvent(MediaLogEvent::ENDED));
+
+  if (state_ != kPlaying)
+    return;
+
+  DCHECK(!renderer_ended_);
+  renderer_ended_ = true;
+
+  RunEndedCallbackIfNeeded();
+}
+
+void PipelineImpl::OnStatisticsUpdate(const PipelineStatistics& stats) {
+  DCHECK(media_task_runner_->BelongsToCurrentThread());
+
+  base::AutoLock auto_lock(lock_);
+  statistics_.audio_bytes_decoded += stats.audio_bytes_decoded;
+  statistics_.video_bytes_decoded += stats.video_bytes_decoded;
+  statistics_.video_frames_decoded += stats.video_frames_decoded;
+  statistics_.video_frames_dropped += stats.video_frames_dropped;
+  statistics_.audio_memory_usage += stats.audio_memory_usage;
+  statistics_.video_memory_usage += stats.video_memory_usage;
+}
+
+void PipelineImpl::OnBufferingStateChange(BufferingState state) {
+  DVLOG(1) << __FUNCTION__ << "(" << state << ") ";
+  DCHECK(media_task_runner_->BelongsToCurrentThread());
+
+  main_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&Pipeline::Client::OnBufferingStateChange,
+                            weak_client_, state));
+}
+
+void PipelineImpl::OnWaitingForDecryptionKey() {
+  DCHECK(media_task_runner_->BelongsToCurrentThread());
+
+  main_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&Pipeline::Client::OnWaitingForDecryptionKey, weak_client_));
+}
+
 void PipelineImpl::SetDuration(TimeDelta duration) {
   // TODO(alokp): Add thread DCHECK after ensuring that all Demuxer
   // implementations call DemuxerHost on the media thread.
   DCHECK(IsRunning());
   media_log_->AddEvent(media_log_->CreateTimeEvent(MediaLogEvent::DURATION_SET,
                                                    "duration", duration));
   UMA_HISTOGRAM_LONG_TIMES("Media.Duration", duration);
 
   base::AutoLock auto_lock(lock_);
   duration_ = duration;
@@ skipping 160 matching lines @@
 
 void PipelineImpl::OnBufferedTimeRangesChanged(
     const Ranges<base::TimeDelta>& ranges) {
   // TODO(alokp): Add thread DCHECK after ensuring that all Demuxer
   // implementations call DemuxerHost on the media thread.
   base::AutoLock auto_lock(lock_);
   buffered_time_ranges_ = ranges;
   did_loading_progress_ = true;
 }
 
-// Called from any thread.
-void PipelineImpl::OnUpdateStatistics(const PipelineStatistics& stats_delta) {
-  base::AutoLock auto_lock(lock_);
-  statistics_.audio_bytes_decoded += stats_delta.audio_bytes_decoded;
-  statistics_.video_bytes_decoded += stats_delta.video_bytes_decoded;
-  statistics_.video_frames_decoded += stats_delta.video_frames_decoded;
-  statistics_.video_frames_dropped += stats_delta.video_frames_dropped;
-  statistics_.audio_memory_usage += stats_delta.audio_memory_usage;
-  statistics_.video_memory_usage += stats_delta.video_memory_usage;
-}
-
-void PipelineImpl::OnWaitingForDecryptionKey() {
-  DCHECK(media_task_runner_->BelongsToCurrentThread());
-
-  main_task_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(&Pipeline::Client::OnWaitingForDecryptionKey, weak_client_));
-}
-
 void PipelineImpl::StartTask() {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
   CHECK_EQ(kCreated, state_)
       << "Media pipeline cannot be started more than once";
 
   text_renderer_ = CreateTextRenderer();
   if (text_renderer_) {
     text_renderer_->Initialize(
         base::Bind(&PipelineImpl::OnTextRendererEnded, weak_this_));
@@ skipping 232 matching lines @@
 
 void PipelineImpl::OnCdmAttached(const CdmAttachedCB& cdm_attached_cb,
                                  CdmContext* cdm_context,
                                  bool success) {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
   if (success)
     cdm_context_ = cdm_context;
   cdm_attached_cb.Run(success);
 }
 
-void PipelineImpl::OnRendererEnded() {
-  DCHECK(media_task_runner_->BelongsToCurrentThread());
-  media_log_->AddEvent(media_log_->CreateEvent(MediaLogEvent::ENDED));
-
-  if (state_ != kPlaying)
-    return;
-
-  DCHECK(!renderer_ended_);
-  renderer_ended_ = true;
-
-  RunEndedCallbackIfNeeded();
-}
-
 void PipelineImpl::OnTextRendererEnded() {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
   media_log_->AddEvent(media_log_->CreateEvent(MediaLogEvent::TEXT_ENDED));
 
   if (state_ != kPlaying)
     return;
 
   DCHECK(!text_renderer_ended_);
   text_renderer_ended_ = true;
 
@@ skipping 66 matching lines @@
       base::AutoLock auto_lock(lock_);
       renderer_.reset();
     }
     OnError(PIPELINE_ERROR_COULD_NOT_RENDER);
     return;
   }
 
   if (cdm_context_)
     renderer_->SetCdm(cdm_context_, base::Bind(&IgnoreCdmAttached));
 
-  renderer_->Initialize(
-      demuxer_, done_cb,
-      base::Bind(&PipelineImpl::OnUpdateStatistics, weak_this_),
-      base::Bind(&PipelineImpl::BufferingStateChanged, weak_this_),
-      base::Bind(&PipelineImpl::OnRendererEnded, weak_this_),
-      base::Bind(&PipelineImpl::OnError, weak_this_),
-      base::Bind(&PipelineImpl::OnWaitingForDecryptionKey, weak_this_));
+  renderer_->Initialize(this, demuxer_, done_cb);
 }
 
 void PipelineImpl::ReportMetadata() {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
   PipelineMetadata metadata;
   metadata.timeline_offset = demuxer_->GetTimelineOffset();
   DemuxerStream* stream = demuxer_->GetStream(DemuxerStream::VIDEO);
   if (stream) {
     metadata.has_video = true;
     metadata.natural_size = stream->video_decoder_config().natural_size();
     metadata.video_rotation = stream->video_rotation();
   }
   if (demuxer_->GetStream(DemuxerStream::AUDIO)) {
     metadata.has_audio = true;
   }
 
   main_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&Pipeline::Client::OnMetadata, weak_client_, metadata));
 }
 
-void PipelineImpl::BufferingStateChanged(BufferingState new_buffering_state) {
-  DVLOG(1) << __FUNCTION__ << "(" << new_buffering_state << ") ";
-  DCHECK(media_task_runner_->BelongsToCurrentThread());
-
-  main_task_runner_->PostTask(
-      FROM_HERE, base::Bind(&Pipeline::Client::OnBufferingStateChange,
-                            weak_client_, new_buffering_state));
-}
-
 }  // namespace media