Web MIDI API back-end (work-in-progress)

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
new file mode 100644
index 0000000000000000000000000000000000000000..5cb796ca7c577238a514fe7a786a04630d04ca8c
--- /dev/null
+++ b/content/renderer/media/midi_message_filter.cc
@@ -0,0 +1,123 @@
+// Copyright (c) 2013 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 "content/renderer/media/midi_message_filter.h"
+
+#include "base/bind.h"
+#include "base/debug/trace_event.h"
+#include "base/message_loop_proxy.h"
+#include "content/common/media/midi_messages.h"
+#include "content/renderer/render_thread_impl.h"
+#include "ipc/ipc_logging.h"
+
+namespace content {
+
+MIDIMessageFilter* MIDIMessageFilter::g_filter = NULL;
+
+MIDIMessageFilter::MIDIMessageFilter(
+    const scoped_refptr<base::MessageLoopProxy>& io_message_loop)
+    : channel_(NULL),
+      io_message_loop_(io_message_loop),
+      client_(NULL),
+      message_loop_(NULL) {
+  DCHECK(!g_filter);
+  g_filter = this;
+}
+
+MIDIMessageFilter::~MIDIMessageFilter() {
+  DCHECK_EQ(g_filter, this);
+  g_filter = NULL;
+}
+
+// static
+MIDIMessageFilter* MIDIMessageFilter::Get() {
+  return g_filter;

[scherkus (not reviewing), 2013/06/03 22:44:59]

AFAIK you can replace this global and
RendererWebMIDIAccessorImpl::midi_message_filter() with a call to
RenderThreadImpl::Get()->midi_message_filter()

I forget why we ended up using g_filter in AudioMessageFilter ... I'm assuming
it might be legacy due to a time when we had code that needed the global but
couldn't access RenderThreadImpl::Get(). Do you happen to remember?

+}
+
+void MIDIMessageFilter::Send(IPC::Message* message) {
+  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  if (!channel_) {
+    delete message;
+  } else {
+    channel_->Send(message);
+  }
+}
+
+bool MIDIMessageFilter::OnMessageReceived(const IPC::Message& message) {
+  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  bool handled = true;
+  IPC_BEGIN_MESSAGE_MAP(MIDIMessageFilter, message)
+    IPC_MESSAGE_HANDLER(MIDIMsg_AccessApproved, OnAccessApproved)
+    IPC_MESSAGE_HANDLER(MIDIMsg_DataReceived, OnDataReceived)
+    IPC_MESSAGE_UNHANDLED(handled = false)
+  IPC_END_MESSAGE_MAP()
+  return handled;
+}
+
+void MIDIMessageFilter::OnFilterAdded(IPC::Channel* channel) {
+  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  channel_ = channel;
+}
+
+void MIDIMessageFilter::OnFilterRemoved() {
+  DCHECK(io_message_loop_->BelongsToCurrentThread());
+
+  // Once removed, a filter will not be used again.  At this time all
+  // delegates must be notified so they release their reference.
+  OnChannelClosing();
+}
+
+void MIDIMessageFilter::OnChannelClosing() {
+  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  channel_ = NULL;
+}
+
+// Received from browser.
+
+void MIDIMessageFilter::OnAccessApproved(int access, bool success) {
+}
+
+void MIDIMessageFilter::OnDataReceived(int port,
+                                       const std::vector<uint8>& data,
+                                       double timestamp) {
+  TRACE_EVENT0("midi", "MIDIMessageFilter::OnDataReceived");
+
+#if 1
+  if (message_loop_) {
+    message_loop_->PostTask(FROM_HERE,
+        base::Bind(&MIDIMessageFilter::HandleDataReceived, this,
+                   port, data, timestamp
+                   ));
+  }
+#else
+  HandleDataReceived(port, data, timestamp);
+#endif
+}
+
+void MIDIMessageFilter::HandleDataReceived(int port,
+                                             const std::vector<uint8>& data,
+                                             double timestamp) {
+    TRACE_EVENT0("midi", "MIDIMessageFilter::HandleDataReceived");
+    size_t n = data.size();
+    // printf("MIDIMessageFilter::OnDataReceived(%d %f): ", (int)n, timestamp);
+    // for (size_t i = 0; i < n; ++i) {
+    //     printf("%2x ", data[i]);
+    // }
+    // printf("\n");
+
+    if (client_ && message_loop_)
+        client_->receiveMIDIData(port, data.data(), n, timestamp);
+}
+
+void MIDIMessageFilter::AddClient(WebKit::WebMIDIAccessor::Client* client) {
+  client_ = client;
+  message_loop_ = base::MessageLoop::current();
+}
+
+void MIDIMessageFilter::RemoveClient(WebKit::WebMIDIAccessor::Client* client) {
+  if (client == client_)
+    client_ = NULL; //????????????????? multiple clients??

[scherkus (not reviewing), 2013/06/03 22:44:59]

I didn't see anything in the spec that mentioned multiple clients:
http://webaudio.github.io/web-midi-api/#requestmidiaccess

... however if the same render process had two separate tabs that accessed MIDI
we'd end up with multiple clients, so I believe this is a case you need to
handle.

It also seems this class would need to maintain a list + fan out events to
clients that were granted access as it currently seems this class receives MIDI
data regardless of whether access was approved or not

+}
+
+}  // namespace content