Web MIDI: add dynamic MidiManager instantiation support for Linux

media/midi/midi_manager_alsa.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/midi/midi_manager_alsa.h"
 
 #include <errno.h>
 #include <poll.h>
 #include <stddef.h>
 #include <stdlib.h>
 
 #include <algorithm>
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/json/json_string_value_serializer.h"
+#include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/posix/safe_strerror.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/time/time.h"
 #include "crypto/sha2.h"
 #include "media/midi/midi_port_info.h"
+#include "media/midi/midi_service.h"
 
 namespace midi {
 
 namespace {
 
 using mojom::PortState;
 using mojom::Result;
 
+// TODO(toyoshim): use constexpr for following const values.
+const int kEventTaskRunner = 0;
+const int kSendTaskRunner = 1;
+
 // Per-output buffer. This can be smaller, but then large sysex messages
 // will be (harmlessly) split across multiple seq events. This should
 // not have any real practical effect, except perhaps to slightly reorder
 // realtime messages with respect to sysex.
 const size_t kSendBufferSize = 256;
 
 // Minimum client id for which we will have ALSA card devices for. When we
 // are searching for card devices (used to get the path, id, and manufacturer),
 // we don't want to get confused by kernel clients that do not have a card.
 // See seq_clientmgr.c in the ALSA code for this.
@@ skipping 35 matching lines @@
 const unsigned int kRequiredOutputPortCaps =
     SND_SEQ_PORT_CAP_WRITE | SND_SEQ_PORT_CAP_SUBS_WRITE;
 
 const unsigned int kCreateOutputPortCaps =
     SND_SEQ_PORT_CAP_READ | SND_SEQ_PORT_CAP_NO_EXPORT;
 const unsigned int kCreateInputPortCaps =
     SND_SEQ_PORT_CAP_WRITE | SND_SEQ_PORT_CAP_NO_EXPORT;
 const unsigned int kCreatePortType =
     SND_SEQ_PORT_TYPE_MIDI_GENERIC | SND_SEQ_PORT_TYPE_APPLICATION;
 
+// Global variables to protect tasks running on external TaskRunners from
+// running with another MidiManagerAlsa instance. These IDs can be read
+// under one of following task_runner_lock, and can be written under both
+// task_runner_lock.
+const int kInvalidManagerId = -1;
+int g_active_manager_id = kInvalidManagerId;
+int g_next_manager_id = 0;
+
+// Protects tasks that run on external TaskRunners.
+base::LazyInstance<base::Lock> g_event_task_runner_lock =
+    LAZY_INSTANCE_INITIALIZER;
+base::LazyInstance<base::Lock> g_send_task_runner_lock =
+    LAZY_INSTANCE_INITIALIZER;
+
 int AddrToInt(int client, int port) {
   return (client << 8) | port;
 }
 
 // Returns true if this client has an ALSA card associated with it.
 bool IsCardClient(snd_seq_client_type_t type, int client_id) {
   return (type == SND_SEQ_KERNEL_CLIENT) &&
          (client_id >= kMinimumClientIdForCards);
 }
 
@@ skipping 43 matching lines @@
 
 void SetStringIfNonEmpty(base::DictionaryValue* value,
                          const std::string& path,
                          const std::string& in_value) {
   if (!in_value.empty())
     value->SetString(path, in_value);
 }
 
 }  // namespace
 
-MidiManagerAlsa::MidiManagerAlsa()
-    : event_thread_("MidiEventThread"), send_thread_("MidiSendThread") {}
+MidiManagerAlsa::MidiManagerAlsa() {
+  base::AutoLock event_runner_lock(g_event_task_runner_lock.Get());
+  base::AutoLock send_runner_lock(g_send_task_runner_lock.Get());
+  instance_id_ = g_next_manager_id++;
+  g_active_manager_id = instance_id_;
+}
 
 MidiManagerAlsa::~MidiManagerAlsa() {
   // Take lock to ensure that the members initialized on the IO thread
   // are not destructed here.
   base::AutoLock lock(lazy_init_member_lock_);
 
   // Extra CHECK to verify all members are already reset.
   CHECK(!initialization_thread_checker_);
   CHECK(!in_client_);
   CHECK(!out_client_);
   CHECK(!decoder_);
   CHECK(!udev_);
   CHECK(!udev_monitor_);
-
-  CHECK(!send_thread_.IsRunning());
-  CHECK(!event_thread_.IsRunning());
 }
 
 void MidiManagerAlsa::StartInitialization() {
   base::AutoLock lock(lazy_init_member_lock_);
 
   initialization_thread_checker_.reset(new base::ThreadChecker());
 
   // Create client handles.
   snd_seq_t* tmp_seq = nullptr;
   int err =
@@ skipping 97 matching lines @@
   // TODO(agoode): Check the return value for failure.
   EnumerateAlsaPorts();
 
   // Generate hotplug events for existing udev devices. This must be done
   // after udev_monitor_enable_receiving() is called. See the algorithm
   // at http://www.signal11.us/oss/udev/.
   EnumerateUdevCards();
 
   // Start processing events. Don't do this before enumeration of both
   // ALSA and udev.
-  event_thread_.Start();
-  event_thread_.task_runner()->PostTask(
-      FROM_HERE,
-      base::Bind(&MidiManagerAlsa::ScheduleEventLoop, base::Unretained(this)));
-  send_thread_.Start();
+  MidiService::GetTaskRunner(kEventTaskRunner)
+      ->PostTask(FROM_HERE, base::Bind(&MidiManagerAlsa::EventLoop,
+                                       base::Unretained(this), instance_id_));
 
   CompleteInitialization(Result::OK);
 }
 
 void MidiManagerAlsa::Finalize() {
   base::AutoLock lock(lazy_init_member_lock_);
   DCHECK(initialization_thread_checker_->CalledOnValidThread());
 
   // Tell the event thread it will soon be time to shut down. This gives
   // us assurance the thread will stop in case the SND_SEQ_EVENT_CLIENT_EXIT
   // message is lost.
   {
     base::AutoLock lock(shutdown_lock_);
     event_thread_shutdown_ = true;
   }
 
-  // Stop the send thread.
-  send_thread_.Stop();
+  // Ensure that no tasks run on kSendTaskRunner.
+  base::AutoLock send_runner_lock(g_send_task_runner_lock.Get());
 
   // Close the out client. This will trigger the event thread to stop,
   // because of SND_SEQ_EVENT_CLIENT_EXIT.
   out_client_.reset();
 
-  // Wait for the event thread to stop.
-  event_thread_.Stop();
+  // Ensure that no tasks run on kEventTaskRunner.
+  base::AutoLock event_runner_lock(g_event_task_runner_lock.Get());
+
+  // All pending tasks including one blocked on a lock do nothing from now on.
+  g_active_manager_id = kInvalidManagerId;
 
   // Destruct the other stuff we initialized in StartInitialization().
   udev_monitor_.reset();
   udev_.reset();
   decoder_.reset();
   in_client_.reset();
   initialization_thread_checker_.reset();
 }
 
 void MidiManagerAlsa::DispatchSendMidiData(MidiManagerClient* client,
                                            uint32_t port_index,
                                            const std::vector<uint8_t>& data,
                                            double timestamp) {
   base::TimeDelta delay;
   if (timestamp != 0.0) {
     base::TimeTicks time_to_send =
         base::TimeTicks() + base::TimeDelta::FromMicroseconds(
                                 timestamp * base::Time::kMicrosecondsPerSecond);
     delay = std::max(time_to_send - base::TimeTicks::Now(), base::TimeDelta());
   }
 
-  send_thread_.task_runner()->PostDelayedTask(
-      FROM_HERE, base::Bind(&MidiManagerAlsa::SendMidiData,
-                            base::Unretained(this), port_index, data),
-      delay);
-
-  // Acknowledge send.
-  send_thread_.task_runner()->PostTask(
-      FROM_HERE, base::Bind(&MidiManagerAlsa::AccumulateMidiBytesSent,
-                            base::Unretained(this), client, data.size()));
+  MidiService::GetTaskRunner(kSendTaskRunner)
+      ->PostDelayedTask(
+          FROM_HERE,
+          base::Bind(&MidiManagerAlsa::SendMidiData, base::Unretained(this),
+                     instance_id_, client, port_index, data),
+          delay);
 }
 
 MidiManagerAlsa::MidiPort::Id::Id() = default;
 
 MidiManagerAlsa::MidiPort::Id::Id(const std::string& bus,
                                   const std::string& vendor_id,
                                   const std::string& model_id,
                                   const std::string& usb_interface_num,
                                   const std::string& serial)
     : bus_(bus),
@@ skipping 496 matching lines @@
   if (at_index && at_index != std::string::npos) {
     size_t name_index = alsa_longname.rfind(alsa_name, at_index - 1);
     if (name_index && name_index != std::string::npos)
       return alsa_longname.substr(0, name_index - 1);
   }
 
   // Failure.
   return "";
 }
 
-void MidiManagerAlsa::SendMidiData(uint32_t port_index,
+void MidiManagerAlsa::SendMidiData(int instance_id,
+                                   MidiManagerClient* client,
+                                   uint32_t port_index,
                                    const std::vector<uint8_t>& data) {
-  DCHECK(send_thread_.task_runner()->BelongsToCurrentThread());
+  DCHECK(MidiService::GetTaskRunner(kSendTaskRunner)->BelongsToCurrentThread());
+  base::AutoLock lock(g_send_task_runner_lock.Get());
+  if (instance_id != g_active_manager_id)
+    return;
 
   snd_midi_event_t* encoder;
   snd_midi_event_new(kSendBufferSize, &encoder);
   for (const auto datum : data) {
     snd_seq_event_t event;
     int result = snd_midi_event_encode_byte(encoder, datum, &event);
     if (result == 1) {
       // Full event, send it.
       base::AutoLock lock(out_ports_lock_);
       auto it = out_ports_.find(port_index);
       if (it != out_ports_.end()) {
         snd_seq_ev_set_source(&event, it->second);
         snd_seq_ev_set_subs(&event);
         snd_seq_ev_set_direct(&event);
         snd_seq_event_output_direct(out_client_.get(), &event);
       }
     }
   }
   snd_midi_event_free(encoder);
+
+  // Acknowledge send.
+  AccumulateMidiBytesSent(client, data.size());
 }
 
-void MidiManagerAlsa::ScheduleEventLoop() {
-  event_thread_.task_runner()->PostTask(
-      FROM_HERE,
-      base::Bind(&MidiManagerAlsa::EventLoop, base::Unretained(this)));
-}
+void MidiManagerAlsa::EventLoop(int instance_id) {
+  base::AutoLock lock(g_event_task_runner_lock.Get());

[Adam Goode, 2017/02/07 13:31:14]

Can you add a comment here (or above) explaining the logic?

It looks like we only want to run a single instance at any time, and need to
protect against the case where we are still shutting down one instance and then
starting another?

[Takashi Toyoshima, 2017/02/08 09:08:00]

Done.

+  if (instance_id != g_active_manager_id)
+    return;
 
-void MidiManagerAlsa::EventLoop() {
   bool loop_again = true;
 
   struct pollfd pfd[2];
   snd_seq_poll_descriptors(in_client_.get(), &pfd[0], 1, POLLIN);
   pfd[1].fd = device::udev_monitor_get_fd(udev_monitor_.get());
   pfd[1].events = POLLIN;
 
   int err = HANDLE_EINTR(poll(pfd, arraysize(pfd), -1));
   if (err < 0) {
     VLOG(1) << "poll fails: " << base::safe_strerror(errno);
@@ skipping 58 matching lines @@
       device::ScopedUdevDevicePtr dev(
           device::udev_monitor_receive_device(udev_monitor_.get()));
       if (dev.get())
         ProcessUdevEvent(dev.get());
       else
         VLOG(1) << "udev_monitor_receive_device fails";
     }
   }
 
   // Do again.
-  if (loop_again)
-    ScheduleEventLoop();
+  if (loop_again) {
+    MidiService::GetTaskRunner(kEventTaskRunner)
+        ->PostTask(FROM_HERE, base::Bind(&MidiManagerAlsa::EventLoop,
+                                         base::Unretained(this), instance_id));
+  }
 }
 
 void MidiManagerAlsa::ProcessSingleEvent(snd_seq_event_t* event,
                                          double timestamp) {
   auto source_it =
       source_map_.find(AddrToInt(event->source.client, event->source.port));
   if (source_it != source_map_.end()) {
     uint32_t source = source_it->second;
     if (event->type == SND_SEQ_EVENT_SYSEX) {
       // Special! Variable-length sysex.
@@ skipping 411 matching lines @@
   // Update our map.
   source_map_[AddrToInt(client_id, port_id)] = port_index;
   return true;
 }
 
 MidiManager* MidiManager::Create() {
   return new MidiManagerAlsa();
 }
 
 }  // namespace midi