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

media/mojo/services/mojo_demuxer_stream_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/services/mojo_demuxer_stream_impl.h"
+
+#include "base/bind.h"
+#include "base/macros.h"
+#include "media/base/audio_decoder_config.h"
+#include "media/mojo/interfaces/demuxer_stream.mojom.h"
+#include "media/mojo/services/media_type_converters.h"
+#include "mojo/public/cpp/bindings/interface_impl.h"
+#include "mojo/public/cpp/system/data_pipe.h"
+
+namespace media {
+
+MojoDemuxerStreamImpl::MojoDemuxerStreamImpl(media::DemuxerStream* stream)
+    : stream_(stream), weak_factory_(this) {}
+
+MojoDemuxerStreamImpl::~MojoDemuxerStreamImpl() {}
+
+void MojoDemuxerStreamImpl::Read(
+    const mojo::Callback<void(mojo::DemuxerStream::Status,
+                              mojo::MediaDecoderBufferPtr)>& callback) {
+  stream_->Read(base::Bind(&MojoDemuxerStreamImpl::OnBufferReady,
+                           weak_factory_.GetWeakPtr(),
+                           callback));

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

In media code, we don't allow unsatisfied callbacks. So in theory, when we
destroy |this| and if there's any pending callback (e.g. read cb), we should
fire that callback. Binding that callback to a weak pointer will prevent us from
being able to do that.

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

The caller of this Read(...) is the MojoDXStreamAdapter, which is a mojo
client() of this object, meaning signalling for this sort of thing is typically
handled by the OnConnectionError stuff.  

I think what you're saying is that ARI would expect the callback to be satisfied
no matter what? I think that would be handled by the fact that
MojoDXStreamAdapter has the actual callback that ARI passed in cached, so we
should fire that OnConnectionError with ABORTED Status?

+}
+
+void MojoDemuxerStreamImpl::OnBufferReady(
+      mojo::Callback<void(mojo::DemuxerStream::Status,
+                          mojo::MediaDecoderBufferPtr)> callback,
+      media::DemuxerStream::Status status,
+      const scoped_refptr<media::DecoderBuffer>& buffer) {
+  if (status == media::DemuxerStream::kConfigChanged) {

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

to keep things simple for this CL (and future ones) we could also
DCHECK/NOTIMPLEMENTED on this particular value until we get the basic
non-mid-stream-config-change scenario up and running

WDYT?

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

Maybe I need to understand this better.  I added some support to plumb the
values across (in fact it was really helpful in figuring out a better model for
DemuxerStream than what I had before).  What else needs to happen at this level
(given that I'm using ARI)?

+    // Send the config change so our client can read it once it parses the
+    // Status obtained via Run() below.
+    client()->OnAudioDecoderConfigChanged(
+        mojo::AudioDecoderConfig::From(stream_->audio_decoder_config()));
+  }
+
+  // TODO(tim): Once using DataPipe, fill via the producer handle and then
+  // read more to keep the pipe full.
+ callback.Run(static_cast<mojo::DemuxerStream::Status>(status),
+              mojo::MediaDecoderBuffer::From(buffer));
+}
+
+void MojoDemuxerStreamImpl::OnConnectionEstablished() {
+  // This is called when our DemuxerStreamClient has connected itself and is
+  // ready to receive messages.  Send an initial config and notify it that
+  // we are now ready for business.
+  client()->OnAudioDecoderConfigChanged(
+      mojo::AudioDecoderConfig::From(stream_->audio_decoder_config()));
+
+  // TODO(tim): Create a DataPipe, hold the producer handle, and pass the
+  // consumer handle here.
+  client()->OnStreamReady(mojo::ScopedDataPipeConsumerHandle());
+}
+
+}  // namespace media