Motown: Framework parts for mojo transport (producer/consumer/mediapipe) and control (audiotrack).

services/media/framework_mojo/mojo_consumer.cc

Index: services/media/framework_mojo/mojo_consumer.cc
diff --git a/services/media/framework_mojo/mojo_consumer.cc b/services/media/framework_mojo/mojo_consumer.cc
new file mode 100644
index 0000000000000000000000000000000000000000..4bd75cf9c18c61399284b70e346cfcc59906d061
--- /dev/null
+++ b/services/media/framework_mojo/mojo_consumer.cc
@@ -0,0 +1,99 @@
+// Copyright 2016 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 "base/bind.h"
+#include "base/logging.h"
+#include "base/message_loop/message_loop.h"
+#include "services/media/framework_mojo/mojo_consumer.h"
+
+namespace mojo {
+namespace media {
+
+void MojoConsumerMediaConsumer::Flush(const FlushCallback& callback) {
+  MediaConsumerFlush(callback);
+}
+
+MojoConsumer::MojoConsumer() {}
+
+MojoConsumer::~MojoConsumer() {}
+
+void MojoConsumer::AddBinding(InterfaceRequest<MediaConsumer> consumer) {
+  bindings_.AddBinding(this, consumer.Pass());
+  DCHECK(base::MessageLoop::current());
+  task_runner_ = base::MessageLoop::current()->task_runner();
+  DCHECK(task_runner_);
+}
+
+void MojoConsumer::SetFlushRequestedCallback(
+    const FlushRequestedCallback& callback) {
+  flush_requested_callback_ = callback;
+}
+
+void MojoConsumer::SetBuffer(
+    ScopedSharedBufferHandle buffer,
+    uint64_t size,
+    const SetBufferCallback& callback) {
+  buffer_.InitFromHandle(buffer.Pass(), size);
+  callback.Run();
+}
+
+void MojoConsumer::PushPacket(
+    MediaPacketPtr media_packet,
+    const PushPacketCallback& callback) {
+  DCHECK(supply_callback_);
+  supply_callback_(PacketImpl::Create(
+      media_packet.Pass(),
+      callback,
+      task_runner_,
+      buffer_));
+}
+
+void MojoConsumer::MediaConsumerFlush(const FlushCallback& callback) {
+  if (flush_requested_callback_) {
+    flush_requested_callback_(callback);
+  } else {
+    LOG(WARNING) << "flush requested but no callback registered";
+    callback.Run();
+  }
+}
+
+bool MojoConsumer::can_accept_allocator() const {
+  return false;
+}
+
+void MojoConsumer::set_allocator(PayloadAllocator* allocator) {
+  NOTREACHED();
+}
+
+void MojoConsumer::SetSupplyCallback(const SupplyCallback& supply_callback) {
+  supply_callback_ = supply_callback;
+}
+
+void MojoConsumer::SetDownstreamDemand(Demand demand) {}
+
+MojoConsumer::PacketImpl::PacketImpl(
+    MediaPacketPtr media_packet,
+    const PushPacketCallback& callback,
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner,
+    const MappedSharedBuffer& buffer) :
+    media_packet_(media_packet.Pass()),
+    callback_(callback),
+    task_runner_(task_runner),
+    payload_(buffer.PtrFromOffset(media_packet_->payload->offset)) {}
+
+MojoConsumer::PacketImpl::~PacketImpl() {}
+
+// static
+void MojoConsumer::PacketImpl::RunCallback(const PushPacketCallback& callback) {
+  callback.Run();
+}
+
+void MojoConsumer::PacketImpl::Release() {
+  // TODO(dalesat): Is there a cleaner way to do this?
+  task_runner_->PostTask(FROM_HERE, base::Bind(&RunCallback, callback_));
+  delete this;
+}
+
+} // namespace media
+} // namespace mojo