Web MIDI: distributes MIDIPort information asynchronously

content/renderer/media/midi_message_filter.cc

 // 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 <algorithm>
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/common/media/midi_messages.h"
 #include "content/renderer/render_thread_impl.h"
 #include "ipc/ipc_logging.h"
 
 using media::MidiPortInfoList;
 using base::AutoLock;
 
 // The maximum number of bytes which we're allowed to send to the browser
 // before getting acknowledgement back from the browser that they've been
 // successfully sent.
 static const size_t kMaxUnacknowledgedBytesSent = 10 * 1024 * 1024;  // 10 MB.
 
 namespace content {
 
 // TODO(crbug.com/425389): Rewrite this class as a RenderFrameObserver.
 MidiMessageFilter::MidiMessageFilter(
     const scoped_refptr<base::MessageLoopProxy>& io_message_loop)
-    : sender_(NULL),
+    : sender_(nullptr),
       io_message_loop_(io_message_loop),
       main_message_loop_(base::MessageLoopProxy::current()),
       session_result_(media::MIDI_NOT_INITIALIZED),
       unacknowledged_bytes_sent_(0u) {
 }
 
 MidiMessageFilter::~MidiMessageFilter() {}
 
 void MidiMessageFilter::AddClient(blink::WebMIDIAccessorClient* client) {
   DCHECK(main_message_loop_->BelongsToCurrentThread());
@@ skipping 10 matching lines @@
 void MidiMessageFilter::RemoveClient(blink::WebMIDIAccessorClient* client) {
   DCHECK(main_message_loop_->BelongsToCurrentThread());
   clients_.erase(client);
   ClientsQueue::iterator it = std::find(clients_waiting_session_queue_.begin(),
                                         clients_waiting_session_queue_.end(),
                                         client);
   if (it != clients_waiting_session_queue_.end())
     clients_waiting_session_queue_.erase(it);
   if (clients_.empty() && clients_waiting_session_queue_.empty()) {
     session_result_ = media::MIDI_NOT_INITIALIZED;
+    inputs_.clear();
+    outputs_.clear();
     io_message_loop_->PostTask(FROM_HERE,
         base::Bind(&MidiMessageFilter::EndSessionOnIOThread, this));
   }
 }
 
 void MidiMessageFilter::SendMidiData(uint32 port,
                                      const uint8* data,
                                      size_t length,
                                      double timestamp) {
   DCHECK(main_message_loop_->BelongsToCurrentThread());
@@ skipping 34 matching lines @@
   } else {
     sender_->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_SessionStarted, OnSessionStarted)
+    IPC_MESSAGE_HANDLER(MidiMsg_AddInputPort, OnAddInputPort)
+    IPC_MESSAGE_HANDLER(MidiMsg_AddOutputPort, OnAddOutputPort)
     IPC_MESSAGE_HANDLER(MidiMsg_DataReceived, OnDataReceived)
     IPC_MESSAGE_HANDLER(MidiMsg_AcknowledgeSentData, OnAcknowledgeSentData)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void MidiMessageFilter::OnFilterAdded(IPC::Sender* sender) {
   DCHECK(io_message_loop_->BelongsToCurrentThread());
   sender_ = sender;
 }
 
 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());
-  sender_ = NULL;
+  sender_ = nullptr;
 }
 
-void MidiMessageFilter::OnSessionStarted(media::MidiResult result,
-                                         MidiPortInfoList inputs,
-                                         MidiPortInfoList outputs) {
+void MidiMessageFilter::OnSessionStarted(media::MidiResult result) {
   TRACE_EVENT0("midi", "MidiMessageFilter::OnSessionStarted");
   DCHECK(io_message_loop_->BelongsToCurrentThread());
-  // TODO(toyoshim): |inputs_| and |outputs_| should not be updated on
-  // |io_message_loop_|. This should be fixed in a following change not to
-  // distribute MidiPortInfo via OnSessionStarted().
-  // For now, this is safe because these are not updated later.
-  inputs_ = inputs;
-  outputs_ = outputs;
   // Handle on the main JS thread.
   main_message_loop_->PostTask(
       FROM_HERE,
       base::Bind(&MidiMessageFilter::HandleClientAdded, this, result));
 }
 
+void MidiMessageFilter::OnAddInputPort(media::MidiPortInfo info) {
+  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  main_message_loop_->PostTask(
+      FROM_HERE,
+      base::Bind(&MidiMessageFilter::HandleAddInputPort, this, info));
+}
+
+void MidiMessageFilter::OnAddOutputPort(media::MidiPortInfo info) {
+  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  main_message_loop_->PostTask(
+      FROM_HERE,
+      base::Bind(&MidiMessageFilter::HandleAddOutputPort, this, info));
+}
+
 void MidiMessageFilter::OnDataReceived(uint32 port,
                                        const std::vector<uint8>& data,
                                        double timestamp) {
   TRACE_EVENT0("midi", "MidiMessageFilter::OnDataReceived");
   DCHECK(io_message_loop_->BelongsToCurrentThread());
   // Handle on the main JS thread.
   main_message_loop_->PostTask(
       FROM_HERE,
       base::Bind(&MidiMessageFilter::HandleDataReceived, this, port, data,
                  timestamp));
@@ skipping 52 matching lines @@
             base::UTF8ToUTF16(info.version),
             active);
       }
     }
     client->didStartSession(result == media::MIDI_OK, error16, message16);
     clients_.insert(client);
   }
   clients_waiting_session_queue_.clear();
 }
 
+void MidiMessageFilter::HandleAddInputPort(media::MidiPortInfo info) {
+  DCHECK(main_message_loop_->BelongsToCurrentThread());
+  inputs_.push_back(info);
+  // TODO(toyoshim): Notify to clients that were already added.
+}
+
+void MidiMessageFilter::HandleAddOutputPort(media::MidiPortInfo info) {
+  DCHECK(main_message_loop_->BelongsToCurrentThread());
+  outputs_.push_back(info);
+  // TODO(toyoshim): Notify to clients that were already added.
+}
+
 void MidiMessageFilter::HandleDataReceived(uint32 port,
                                            const std::vector<uint8>& data,
                                            double timestamp) {
   TRACE_EVENT0("midi", "MidiMessageFilter::HandleDataReceived");
   DCHECK(main_message_loop_->BelongsToCurrentThread());
   DCHECK(!data.empty());
 
   for (blink::WebMIDIAccessorClient* client : clients_)
     client->didReceiveMIDIData(port, &data[0], data.size(), timestamp);
 }
 
 void MidiMessageFilter::HandleAckknowledgeSentData(size_t bytes_sent) {
   DCHECK(main_message_loop_->BelongsToCurrentThread());
   DCHECK_GE(unacknowledged_bytes_sent_, bytes_sent);
   if (unacknowledged_bytes_sent_ >= bytes_sent)
     unacknowledged_bytes_sent_ -= bytes_sent;
 }
 
 }  // namespace content