media: Add unittest for MojoRenderer{Impl|Service}

media/mojo/clients/mojo_renderer_impl.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/clients/mojo_renderer_impl.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
@@ skipping 16 matching lines @@
       video_overlay_factory_(std::move(video_overlay_factory)),
       video_renderer_sink_(video_renderer_sink),
       remote_renderer_info_(remote_renderer.PassInterface()),
       binding_(this) {
   DVLOG(1) << __FUNCTION__;
 }
 
 MojoRendererImpl::~MojoRendererImpl() {
   DVLOG(1) << __FUNCTION__;
   DCHECK(task_runner_->BelongsToCurrentThread());
+
+  FireAllPendingCallbacks();

[sandersd (OOO until July 31), 2016/06/16 18:10:06]

Why does the destructor need to call this?

[xhwang, 2016/06/17 06:59:00]

The Renderer API says all pending callbacks should be fired during destruction:

https://cs.chromium.org/chromium/src/media/base/renderer.h?rcl=0&l=28

Even though typically the caller will use weak ptr and ignore these callbacks,
but I feel it's still good practice to always fire all callbacks.

 }
 
 void MojoRendererImpl::Initialize(
     DemuxerStreamProvider* demuxer_stream_provider,
     media::RendererClient* client,
     const PipelineStatusCB& init_cb) {
   DVLOG(1) << __FUNCTION__;
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(demuxer_stream_provider);
 
+  if (encountered_error_) {
+    task_runner_->PostTask(
+        FROM_HERE, base::Bind(init_cb, PIPELINE_ERROR_INITIALIZATION_FAILED));
+    return;
+  }
+
   demuxer_stream_provider_ = demuxer_stream_provider;
-  client_ = client;
   init_cb_ = init_cb;
 
   // Create audio and video mojom::DemuxerStream and bind its lifetime to
   // the pipe.
   DemuxerStream* const audio =
       demuxer_stream_provider_->GetStream(DemuxerStream::AUDIO);
   DemuxerStream* const video =
       demuxer_stream_provider_->GetStream(DemuxerStream::VIDEO);
 
   mojom::DemuxerStreamPtr audio_stream;
   if (audio)
     new MojoDemuxerStreamImpl(audio, GetProxy(&audio_stream));
 
   mojom::DemuxerStreamPtr video_stream;
   if (video)
     new MojoDemuxerStreamImpl(video, GetProxy(&video_stream));
 
   BindRemoteRendererIfNeeded();
 
   // Using base::Unretained(this) is safe because |this| owns
   // |remote_renderer_|, and the callback won't be dispatched if
   // |remote_renderer_| is destroyed.
-  remote_renderer_->Initialize(
-      binding_.CreateInterfacePtrAndBind(), std::move(audio_stream),
-      std::move(video_stream),
-      base::Bind(&MojoRendererImpl::OnInitialized, base::Unretained(this)));
+  remote_renderer_->Initialize(binding_.CreateInterfacePtrAndBind(),
+                               std::move(audio_stream), std::move(video_stream),
+                               base::Bind(&MojoRendererImpl::OnInitialized,
+                                          base::Unretained(this), client));
 }
 
 void MojoRendererImpl::SetCdm(CdmContext* cdm_context,
                               const CdmAttachedCB& cdm_attached_cb) {
   DVLOG(1) << __FUNCTION__;
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(cdm_context);
+  DCHECK(!cdm_attached_cb.is_null());
+  DCHECK(cdm_attached_cb_.is_null());
+
+  if (encountered_error_) {
+    task_runner_->PostTask(FROM_HERE, base::Bind(cdm_attached_cb, false));
+    return;
+  }
 
   int32_t cdm_id = cdm_context->GetCdmId();
   if (cdm_id == CdmContext::kInvalidCdmId) {
     DVLOG(2) << "MojoRendererImpl only works with remote CDMs but the CDM ID "
                 "is invalid.";
-    cdm_attached_cb.Run(false);
+    task_runner_->PostTask(FROM_HERE, base::Bind(cdm_attached_cb, false));
     return;
   }
 
   BindRemoteRendererIfNeeded();
-  remote_renderer_->SetCdm(cdm_id, cdm_attached_cb);
+
+  cdm_attached_cb_ = cdm_attached_cb;
+  remote_renderer_->SetCdm(cdm_id, base::Bind(&MojoRendererImpl::OnCdmAttached,
+                                              base::Unretained(this)));
 }
 
 void MojoRendererImpl::Flush(const base::Closure& flush_cb) {
   DVLOG(2) << __FUNCTION__;
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(remote_renderer_.is_bound());
-  remote_renderer_->Flush(flush_cb);
+  DCHECK(!flush_cb.is_null());
+  DCHECK(flush_cb_.is_null());
+
+  if (encountered_error_) {
+    task_runner_->PostTask(FROM_HERE, flush_cb);
+    return;
+  }
+
+  flush_cb_ = flush_cb;
+  remote_renderer_->Flush(
+      base::Bind(&MojoRendererImpl::OnFlushed, base::Unretained(this)));
 }
 
 void MojoRendererImpl::StartPlayingFrom(base::TimeDelta time) {
   DVLOG(2) << __FUNCTION__;
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(remote_renderer_.is_bound());
 
   {
     base::AutoLock auto_lock(lock_);
     time_ = time;
   }
 
   remote_renderer_->StartPlayingFrom(time.InMicroseconds());
 }
 
 void MojoRendererImpl::SetPlaybackRate(double playback_rate) {
   DVLOG(2) << __FUNCTION__;
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(remote_renderer_.is_bound());
+
   remote_renderer_->SetPlaybackRate(playback_rate);
 }
 
 void MojoRendererImpl::SetVolume(float volume) {
   DVLOG(2) << __FUNCTION__;
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(remote_renderer_.is_bound());
+
   remote_renderer_->SetVolume(volume);
 }
 
 base::TimeDelta MojoRendererImpl::GetMediaTime() {
   base::AutoLock auto_lock(lock_);
   DVLOG(3) << __FUNCTION__ << ": " << time_.InMilliseconds() << " ms";
   return time_;
 }
 
 bool MojoRendererImpl::HasAudio() {
   DVLOG(1) << __FUNCTION__;
   DCHECK(task_runner_->BelongsToCurrentThread());
-  DCHECK(remote_renderer_.get());  // We always bind the renderer.
+  DCHECK(remote_renderer_.is_bound());
+
   return !!demuxer_stream_provider_->GetStream(DemuxerStream::AUDIO);
 }
 
 bool MojoRendererImpl::HasVideo() {
   DVLOG(1) << __FUNCTION__;
   DCHECK(task_runner_->BelongsToCurrentThread());
+  DCHECK(remote_renderer_.is_bound());
+
   return !!demuxer_stream_provider_->GetStream(DemuxerStream::VIDEO);
 }
 
 void MojoRendererImpl::OnTimeUpdate(int64_t time_usec, int64_t max_time_usec) {
   DVLOG(3) << __FUNCTION__ << ": " << time_usec << ", " << max_time_usec;
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   base::AutoLock auto_lock(lock_);
   time_ = base::TimeDelta::FromMicroseconds(time_usec);
 }
 
 void MojoRendererImpl::OnBufferingStateChange(mojom::BufferingState state) {
   DVLOG(2) << __FUNCTION__;
   DCHECK(task_runner_->BelongsToCurrentThread());
   client_->OnBufferingStateChange(static_cast<media::BufferingState>(state));
 }
 
 void MojoRendererImpl::OnEnded() {
   DVLOG(1) << __FUNCTION__;
   DCHECK(task_runner_->BelongsToCurrentThread());
   client_->OnEnded();
 }
 
 void MojoRendererImpl::OnError() {
   DVLOG(1) << __FUNCTION__;
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(init_cb_.is_null());
 
+  encountered_error_ = true;
+
   // TODO(tim): Should we plumb error code from remote renderer?
   // http://crbug.com/410451.
   client_->OnError(PIPELINE_ERROR_DECODE);
 }
 
 void MojoRendererImpl::OnVideoNaturalSizeChange(const gfx::Size& size) {
   DVLOG(2) << __FUNCTION__ << ": " << size.ToString();
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   video_renderer_sink_->PaintSingleFrame(
       video_overlay_factory_->CreateFrame(size));
   client_->OnVideoNaturalSizeChange(size);
 }
 
 void MojoRendererImpl::OnVideoOpacityChange(bool opaque) {
   DVLOG(2) << __FUNCTION__ << ": " << opaque;
   DCHECK(task_runner_->BelongsToCurrentThread());
   client_->OnVideoOpacityChange(opaque);
 }
 
 void MojoRendererImpl::OnConnectionError() {
   DVLOG(1) << __FUNCTION__;
   DCHECK(task_runner_->BelongsToCurrentThread());
 
-  if (!init_cb_.is_null()) {
-    base::ResetAndReturn(&init_cb_).Run(PIPELINE_ERROR_INITIALIZATION_FAILED);
-    return;
-  }
+  encountered_error_ = true;
+  FireAllPendingCallbacks();
 
-  client_->OnError(PIPELINE_ERROR_DECODE);
+  if (client_)
+    client_->OnError(PIPELINE_ERROR_DECODE);
 }
 
 void MojoRendererImpl::BindRemoteRendererIfNeeded() {
   DVLOG(2) << __FUNCTION__;
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   // If |remote_renderer_| has already been bound, do nothing.
+  // Note that after Bind() is called, |remote_renderer_| is always bound even
+  // after connection error.
   if (remote_renderer_.is_bound())
     return;
 
   // Bind |remote_renderer_| to the |task_runner_|.
   remote_renderer_.Bind(std::move(remote_renderer_info_));
 
   // Otherwise, set an error handler to catch the connection error.
   // Using base::Unretained(this) is safe because |this| owns
   // |remote_renderer_|, and the error handler can't be invoked once
   // |remote_renderer_| is destroyed.
   remote_renderer_.set_connection_error_handler(
       base::Bind(&MojoRendererImpl::OnConnectionError, base::Unretained(this)));
 }
 
-void MojoRendererImpl::OnInitialized(bool success) {
+void MojoRendererImpl::OnInitialized(media::RendererClient* client,
+                                     bool success) {
   DVLOG(1) << __FUNCTION__;
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(!init_cb_.is_null());
 
+  // Only set |client_| after initialization succeeded. No client methods should
+  // be called before this.
+  if (success)
+    client_ = client;
+
   base::ResetAndReturn(&init_cb_).Run(
       success ? PIPELINE_OK : PIPELINE_ERROR_INITIALIZATION_FAILED);
 }
 
+void MojoRendererImpl::OnFlushed() {
+  DVLOG(1) << __FUNCTION__;
+  DCHECK(task_runner_->BelongsToCurrentThread());
+  DCHECK(!flush_cb_.is_null());
+
+  base::ResetAndReturn(&flush_cb_).Run();
+}
+
+void MojoRendererImpl::OnCdmAttached(bool success) {
+  DVLOG(1) << __FUNCTION__;
+  DCHECK(task_runner_->BelongsToCurrentThread());
+  DCHECK(!cdm_attached_cb_.is_null());
+
+  base::ResetAndReturn(&cdm_attached_cb_).Run(success);
+}
+
+void MojoRendererImpl::FireAllPendingCallbacks() {

[sandersd (OOO until July 31), 2016/06/16 18:10:06]

This name should probably indicate that the callbacks are failed. Perhaps
CancelPendingCallbacks()?

[xhwang, 2016/06/17 06:59:00]

Done.

+  DVLOG(1) << __FUNCTION__;
+  DCHECK(task_runner_->BelongsToCurrentThread());
+
+  if (!init_cb_.is_null())
+    base::ResetAndReturn(&init_cb_).Run(PIPELINE_ERROR_INITIALIZATION_FAILED);
+
+  if (!flush_cb_.is_null())
+    base::ResetAndReturn(&flush_cb_).Run();
+
+  if (!cdm_attached_cb_.is_null())
+    base::ResetAndReturn(&cdm_attached_cb_).Run(false);
+}
+
 }  // namespace media