[WIP][NotForLand]: Use Mojo for WebMIDI IPC

content/renderer/media/midi_message_filter.cc

Index: content/renderer/media/midi_message_filter.cc
diff --git a/content/renderer/media/midi_message_filter.cc b/content/renderer/media/midi_message_filter.cc
index 982281f72d60ef5af1058fb7dccd7fa7377a4e1e..d09564ef70cb5024d560f2c9fd141c7c992daf1f 100644
--- a/content/renderer/media/midi_message_filter.cc
+++ b/content/renderer/media/midi_message_filter.cc
@@ -11,6 +11,7 @@
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/common/media/midi_messages.h"
+#include "content/public/common/service_registry.h"
 #include "content/renderer/render_thread_impl.h"
 #include "ipc/ipc_logging.h"
 
@@ -24,6 +25,47 @@ static const size_t kMaxUnacknowledgedBytesSent = 10 * 1024 * 1024;  // 10 MB.
 
 namespace content {
 
+MidiServiceClientImpl::MidiServiceClientImpl(
+    MidiMessageFilter* midi_message_filter,
+    mojo::InterfaceRequest<MidiServiceClient> request)
+    : midi_message_filter_(midi_message_filter),
+      binding_(this, request.Pass()) {
+  DCHECK(midi_message_filter_.get());
+}
+
+MidiServiceClientImpl::~MidiServiceClientImpl() {
+}
+
+void MidiServiceClientImpl::AcknowledgeSentData(uint32_t bytes_sent) {
+  midi_message_filter_->HandleAckknowledgeSentData(bytes_sent);
+}
+
+void MidiServiceClientImpl::AddInputPort(
+    media::MidiPortInfoMojoPtr input_port) {
+  media::MidiPortInfo info(
+      input_port->id.get(),
+      input_port->manufacturer.get(),
+      input_port->name.get(),
+      input_port->version.get());
+  midi_message_filter_->HandleAddInputPort(info);
+}
+
+void MidiServiceClientImpl::AddOutputPort(
+    media::MidiPortInfoMojoPtr output_port) {
+  media::MidiPortInfo info(
+      output_port->id.get(),
+      output_port->manufacturer.get(),
+      output_port->name.get(),
+      output_port->version.get());
+  midi_message_filter_->HandleAddOutputPort(info);
+}
+
+void MidiServiceClientImpl::DataReceived(uint32_t port,
+                                         mojo::Array<uint8_t> data,
+                                         double timestamp) {
+  midi_message_filter_->HandleDataReceived(port, data.storage(), timestamp);
+}
+
 // TODO(crbug.com/425389): Rewrite this class as a RenderFrameObserver.
 MidiMessageFilter::MidiMessageFilter(
     const scoped_refptr<base::MessageLoopProxy>& io_message_loop)
@@ -32,6 +74,10 @@ MidiMessageFilter::MidiMessageFilter(
       main_message_loop_(base::MessageLoopProxy::current()),
       session_result_(media::MIDI_NOT_INITIALIZED),
       unacknowledged_bytes_sent_(0u) {
+  // TODO(bashi): Not sure this is the right place to do.
+  if (ServiceRegistry* registry = RenderThread::Get()->GetServiceRegistry()) {
+    registry->ConnectToRemoteService(&service_);
+  }
 }
 
 MidiMessageFilter::~MidiMessageFilter() {}
@@ -43,8 +89,17 @@ void MidiMessageFilter::AddClient(blink::WebMIDIAccessorClient* client) {
   if (session_result_ != media::MIDI_NOT_INITIALIZED) {
     HandleClientAdded(session_result_);
   } else if (clients_waiting_session_queue_.size() == 1u) {
-    io_message_loop_->PostTask(FROM_HERE,
-        base::Bind(&MidiMessageFilter::StartSessionOnIOThread, this));
+    // TODO(bashi): It's under active discussion how to create client and bound
+    // it to a message pipe.
+    // https://groups.google.com/a/chromium.org/forum/#!topic/mojo-dev/UivoBmVjnA4
+    media::MidiServiceClientPtr client_ptr;
+    mojo::InterfaceRequest<media::MidiServiceClient> request =
+        GetProxy(&client_ptr);
+    new MidiServiceClientImpl(this, request.Pass());
+    service_->StartSession(
+        client_ptr.Pass(),
+        base::Bind(&MidiMessageFilter::DidStartSession,
+                   base::Unretained(this)));
   }
 }
 
@@ -60,8 +115,7 @@ void MidiMessageFilter::RemoveClient(blink::WebMIDIAccessorClient* client) {
     session_result_ = media::MIDI_NOT_INITIALIZED;
     inputs_.clear();
     outputs_.clear();
-    io_message_loop_->PostTask(FROM_HERE,
-        base::Bind(&MidiMessageFilter::EndSessionOnIOThread, this));
+    service_->EndSession();
   }
 }
 
@@ -77,17 +131,19 @@ void MidiMessageFilter::SendMidiData(uint32 port,
   }
 
   unacknowledged_bytes_sent_ += length;
-  std::vector<uint8> v(data, data + length);
-  io_message_loop_->PostTask(FROM_HERE, base::Bind(
-        &MidiMessageFilter::SendMidiDataOnIOThread, this, port, v, timestamp));
+  std::vector<uint8_t> v(data, data + length);
+  mojo::Array<uint8_t> array = mojo::Array<uint8_t>::From(v);
+  service_->SendData(port, array.Pass(), timestamp);
 }
 
+// TODO: remove
 void MidiMessageFilter::StartSessionOnIOThread() {
   TRACE_EVENT0("midi", "MidiMessageFilter::StartSessionOnIOThread");
   DCHECK(io_message_loop_->BelongsToCurrentThread());
   Send(new MidiHostMsg_StartSession());
 }
 
+// TODO: remove
 void MidiMessageFilter::SendMidiDataOnIOThread(uint32 port,
                                                const std::vector<uint8>& data,
                                                double timestamp) {
@@ -95,6 +151,7 @@ void MidiMessageFilter::SendMidiDataOnIOThread(uint32 port,
   Send(new MidiHostMsg_SendData(port, data, timestamp));
 }
 
+// TODO: remove
 void MidiMessageFilter::EndSessionOnIOThread() {
   DCHECK(io_message_loop_->BelongsToCurrentThread());
   Send(new MidiHostMsg_EndSession());
@@ -265,4 +322,8 @@ void MidiMessageFilter::HandleAckknowledgeSentData(size_t bytes_sent) {
     unacknowledged_bytes_sent_ -= bytes_sent;
 }
 
+void MidiMessageFilter::DidStartSession(media::MidiResultMojo result) {
+  HandleClientAdded(static_cast<media::MidiResult>(result));
+}
+
 }  // namespace content