Move Renderer permanent callbacks into RendererClient interface.

media/mojo/services/mojo_renderer_service.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 "media/mojo/services/mojo_renderer_service.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "media/base/media_keys.h"
@@ skipping 85 matching lines @@
   if (!cdm_context) {
     DVLOG(1) << "CDM context not available: " << cdm_id;
     callback.Run(false);
     return;
   }
 
   renderer_->SetCdm(cdm_context, base::Bind(&MojoRendererService::OnCdmAttached,
                                             weak_this_, cdm, callback));
 }
 
+void MojoRendererService::OnError(PipelineStatus error) {
+  DVLOG(1) << __FUNCTION__ << "(" << error << ")";
+  state_ = STATE_ERROR;
+  client_->OnError();
+}
+
+void MojoRendererService::OnEnded() {
+  DVLOG(1) << __FUNCTION__;
+  CancelPeriodicMediaTimeUpdates();
+  client_->OnEnded();
+}
+
+void MojoRendererService::OnStatisticsUpdate(const PipelineStatistics& stats) {}
+
+void MojoRendererService::OnBufferingStateChange(BufferingState state) {
+  DVLOG(2) << __FUNCTION__ << "(" << state << ")";
+  client_->OnBufferingStateChange(
+      static_cast<interfaces::BufferingState>(state));
+}
+
+void MojoRendererService::OnWaitingForDecryptionKey() {}

[xhwang, 2016/05/09 18:13:22]

This CL makes it super clear that we should plumb OnStatisticsUpdate() and
OnWaitingForDecryptionKey() over the renderer mojom client interface :) Could
you please add a TODO somewhere to make sure we don't forget?

[alokp, 2016/05/09 21:31:43]

Done.

+
 void MojoRendererService::OnStreamReady(
     const mojo::Callback<void(bool)>& callback) {
   DCHECK_EQ(state_, STATE_INITIALIZING);
 
   renderer_->Initialize(
-      stream_provider_.get(),
-      base::Bind(
-          &MojoRendererService::OnRendererInitializeDone, weak_this_, callback),
-      base::Bind(&MojoRendererService::OnUpdateStatistics, weak_this_),
-      base::Bind(&MojoRendererService::OnBufferingStateChanged, weak_this_),
-      base::Bind(&MojoRendererService::OnRendererEnded, weak_this_),
-      base::Bind(&MojoRendererService::OnError, weak_this_),
-      base::Bind(base::DoNothing));
+      this, stream_provider_.get(),
+      base::Bind(&MojoRendererService::OnRendererInitializeDone, weak_this_,
+                 callback));
 }
 
 void MojoRendererService::OnRendererInitializeDone(
     const mojo::Callback<void(bool)>& callback,
     PipelineStatus status) {
   DVLOG(1) << __FUNCTION__;
   DCHECK_EQ(state_, STATE_INITIALIZING);
 
   if (status != PIPELINE_OK) {
     state_ = STATE_ERROR;
     callback.Run(false);
     return;
   }
 
   state_ = STATE_PLAYING;
   callback.Run(true);
 }
 
-void MojoRendererService::OnUpdateStatistics(const PipelineStatistics& stats) {
-}
-
 void MojoRendererService::UpdateMediaTime(bool force) {
   const uint64_t media_time = renderer_->GetMediaTime().InMicroseconds();
   if (!force && media_time == last_media_time_usec_)
     return;
 
   client_->OnTimeUpdate(media_time, media_time);
   last_media_time_usec_ = media_time;
 }
 
 void MojoRendererService::CancelPeriodicMediaTimeUpdates() {
   DVLOG(2) << __FUNCTION__;
   UpdateMediaTime(false);
   time_update_timer_.Stop();
 }
 
 void MojoRendererService::SchedulePeriodicMediaTimeUpdates() {
   DVLOG(2) << __FUNCTION__;
   UpdateMediaTime(true);
   time_update_timer_.Start(
       FROM_HERE,
       base::TimeDelta::FromMilliseconds(kTimeUpdateIntervalMs),
       base::Bind(&MojoRendererService::UpdateMediaTime, weak_this_, false));
 }
 
-void MojoRendererService::OnBufferingStateChanged(
-    BufferingState new_buffering_state) {
-  DVLOG(2) << __FUNCTION__ << "(" << new_buffering_state << ")";
-  client_->OnBufferingStateChange(
-      static_cast<interfaces::BufferingState>(new_buffering_state));
-}
-
-void MojoRendererService::OnRendererEnded() {
-  DVLOG(1) << __FUNCTION__;
-  CancelPeriodicMediaTimeUpdates();
-  client_->OnEnded();
-}
-
-void MojoRendererService::OnError(PipelineStatus error) {
-  DVLOG(1) << __FUNCTION__ << "(" << error << ")";
-  state_ = STATE_ERROR;
-  client_->OnError();
-}
-
 void MojoRendererService::OnFlushCompleted(const mojo::Closure& callback) {
   DVLOG(1) << __FUNCTION__;
   DCHECK_EQ(state_, STATE_FLUSHING);
   state_ = STATE_PLAYING;
   callback.Run();
 }
 
 void MojoRendererService::OnCdmAttached(
     scoped_refptr<MediaKeys> cdm,
     const mojo::Callback<void(bool)>& callback,
     bool success) {
   DVLOG(1) << __FUNCTION__ << "(" << success << ")";
 
   if (success)
     cdm_ = cdm;
 
   callback.Run(success);
 }
 
 }  // namespace media