media: scaffolding and plumbing for MojoRenderer{Impl, Service}

media/mojo/services/mojo_renderer_impl.cc

Index: media/mojo/services/mojo_renderer_impl.cc
diff --git a/media/mojo/services/mojo_renderer_impl.cc b/media/mojo/services/mojo_renderer_impl.cc
new file mode 100644
index 0000000000000000000000000000000000000000..265a4afd67489bd05c6d49dd29523e6d927f5eaa
--- /dev/null
+++ b/media/mojo/services/mojo_renderer_impl.cc
@@ -0,0 +1,119 @@
+// 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_impl.h"
+
+#include "base/bind.h"
+#include "base/single_thread_task_runner.h"
+#include "media/base/demuxer.h"
+#include "media/mojo/services/mojo_demuxer_stream_impl.h"
+#include "mojo/public/cpp/application/connect.h"
+#include "mojo/public/cpp/bindings/interface_impl.h"
+#include "mojo/public/interfaces/application/service_provider.mojom.h"
+
+namespace media {
+
+MojoRendererImpl::MojoRendererImpl(
+    const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
+    Demuxer* demuxer,
+    mojo::ServiceProvider* audio_renderer_provider)
+    : task_runner_(task_runner),
+      demuxer_(demuxer),
+      weak_factory_(this) {
+  // For now we only support audio and there must be a provider.
+  DCHECK(audio_renderer_provider);

[scherkus (not reviewing), 2014/09/09 20:35:32]

would the next line crash if this was NULL?

if so ... typically just leave our the DCHECK

[tim (not reviewing), 2014/09/10 23:08:30]

I mean, it's not clear right, which is why I left the DCHECK. If it was a raw
deref on the next line I'd leave it out also, but essentially this whole class
is written (for now) with the assumption that we're here if and only if audio,
which is separate from the call to mojo::ConnectToService.

+  mojo::ConnectToService(audio_renderer_provider, &remote_audio_renderer_);
+  remote_audio_renderer_.set_client(this);
+}
+
+MojoRendererImpl::~MojoRendererImpl() {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+  // Connection to |remote_audio_renderer_| will error-out here.
+}
+
+void MojoRendererImpl::Initialize(
+    const base::Closure& init_cb,
+    const StatisticsCB& statistics_cb,
+    const base::Closure& ended_cb,
+    const PipelineStatusCB& error_cb,
+    const BufferingStateCB& buffering_state_cb,
+    const TimeDeltaCB& get_duration_cb) {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+  ended_cb_ = ended_cb;
+  error_cb_ = error_cb;
+  buffering_state_cb_ = buffering_state_cb;
+
+  // Create a mojo::DemuxerStream and bind its lifetime to the pipe.
+  mojo::DemuxerStreamPtr dx_ptr;

[xhwang, 2014/09/10 00:00:52]

s/dx/demuxer_stream/

[tim (not reviewing), 2014/09/10 23:08:30]

Done.

+  mojo::BindToProxy(new MojoDemuxerStreamImpl(
+      demuxer_->GetStream(DemuxerStream::AUDIO)), &dx_ptr);
+  remote_audio_renderer_->Initialize(dx_ptr.Pass(), init_cb);
+}
+
+void MojoRendererImpl::Flush(const base::Closure& flush_cb) {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+  remote_audio_renderer_->Flush(flush_cb);
+}
+
+void MojoRendererImpl::StartPlayingFrom(base::TimeDelta time) {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+  remote_audio_renderer_->StartPlayingFrom(time.ToInternalValue());

[xhwang, 2014/09/10 00:00:52]

ToMicroseconds()?

[tim (not reviewing), 2014/09/10 23:08:30]

Done.

+}
+
+void MojoRendererImpl::SetPlaybackRate(float playback_rate) {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+  remote_audio_renderer_->SetPlaybackRate(playback_rate);
+}
+
+void MojoRendererImpl::SetVolume(float volume) {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+  remote_audio_renderer_->SetVolume(volume);
+}
+
+base::TimeDelta MojoRendererImpl::GetMediaTime() {
+  NOTIMPLEMENTED();
+  return base::TimeDelta();
+}
+
+bool MojoRendererImpl::HasAudio() {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+  DCHECK(remote_audio_renderer_.get());  // We always bind the renderer.

[scherkus (not reviewing), 2014/09/09 20:35:32]

hrmm... will Has{Audio,Video}() eventually be methods on the
mojo::MediaRenderer()?

IOW, should we eventually just have a single |remote_renderer_|?

[tim (not reviewing), 2014/09/10 23:08:29]

I haven't really thought this through tbh; I was modelling it after RendererImpl
(see comment in .h).  If you go with two separate ones, it allows the
flexibility to connect to different applications for audio vs video (which may
or may not be useful). It also lets you return synchronously here (this may also
be useless, I don't know for sure).

[scherkus (not reviewing), 2014/09/12 19:14:41]

We can iterate in future CLs, but in general I wouldn't worry about connecting
to different services for audio vs. video -- you'd connect to a single
{audio+video} renderer service.

With respect to implementing synchronous versions of
media::Renderer::Has{Audio,Video}() -- I suspect we'd have to tweak the
mojo::Renderer IDL to have that information passed back in the initialization
callback.

IOW ... code is fine as is for now.

+  return true;
+}
+
+bool MojoRendererImpl::HasVideo() {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+  return false;
+}
+
+void MojoRendererImpl::SetCdm(MediaKeys* cdm) {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+  NOTIMPLEMENTED();
+}
+
+void MojoRendererImpl::OnTimeUpdate(int64_t time_usec,
+                                    int64_t max_time_usec) {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+  NOTIMPLEMENTED();
+}
+
+void MojoRendererImpl::OnBufferingStateChange(
+    mojo::BufferingState state) {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+  buffering_state_cb_.Run(
+      static_cast<media::BufferingState>(state));
+}
+
+void MojoRendererImpl::OnEnded() {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+  ended_cb_.Run();
+}
+
+void MojoRendererImpl::OnError() {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+  // TODO(tim): Should we have OnDecodeError and OnRenderError?

[scherkus (not reviewing), 2014/09/09 20:35:32]

I believe one day we'd want the remote mojo::MediaRenderer to be able to provide
an error code, but for now let's determine which error code to fire using the
following heuristic:
  - If OnError() is called before Initialize() callback fires, return
PIPELINE_ERROR_COULD_NOT_RENDER
  - If OnError() is called after Initialize() callback fires, return
PIPELINE_ERROR_DECODE

If you're wondering, the difference is that these error codes get translated
into HTMLMediaElement error codes (i.e,. are end-user visible) so we should try
to maintain compatibility:
https://code.google.com/p/chromium/codesearch#chromium/src/media/blink/webmed...

[tim (not reviewing), 2014/09/10 23:08:30]

Done.  Thanks for the pointer.

+  error_cb_.Run(PIPELINE_ERROR_COULD_NOT_RENDER);
+}
+
+}  // namespace media