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 identify MidiManagerAlsa instance.
+const int kInvalidInstanceId = -1;
+int g_active_instance_id = kInvalidInstanceId;
+int g_next_instance_id = 0;
+base::LazyInstance<base::Lock> g_instance_id_lock = LAZY_INSTANCE_INITIALIZER;
+
+// Prevent current instance from quiting Finalize() while tasks run on external
+// TaskRunners.
+base::LazyInstance<base::Lock> g_event_task_lock = LAZY_INSTANCE_INITIALIZER;
+base::LazyInstance<base::Lock> g_send_task_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(MidiService* service) : MidiManager(service) {}
 
 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());
+  base::AutoLock instance_id_lock(g_instance_id_lock.Get());
+  CHECK_EQ(kInvalidInstanceId, g_active_instance_id);
 }
 
 void MidiManagerAlsa::StartInitialization() {
+  {

[Takashi Toyoshima, 2017/02/08 12:56:13]

Since Finalize() is called only when StartInitialization() is called, I need to
set g_active_instance_id here so that CHECK_EQ at line 189 can be fine.

+    base::AutoLock lock(g_instance_id_lock.Get());
+    CHECK_EQ(kInvalidInstanceId, g_active_instance_id);
+    instance_id_ = g_next_instance_id++;
+    g_active_instance_id = instance_id_;
+  }
+
   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 =
       snd_seq_open(&tmp_seq, kAlsaHw, SND_SEQ_OPEN_INPUT, SND_SEQ_NONBLOCK);
   if (err != 0) {
     VLOG(1) << "snd_seq_open fails: " << snd_strerror(err);
@@ skipping 94 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();
+  service()
+      ->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.
+  // Tell tasks running on TaskRunners it will soon be time to shut down. This
+  // gives us assurance a task running on kEventTaskRunner will stop in case the
+  // SND_SEQ_EVENT_CLIENT_EXIT message is lost.
   {
-    base::AutoLock lock(shutdown_lock_);
-    event_thread_shutdown_ = true;
+    base::AutoLock lock(g_instance_id_lock.Get());
+    CHECK_EQ(instance_id_, g_active_instance_id);
+    g_active_instance_id = kInvalidInstanceId;
   }
 
-  // Stop the send thread.
-  send_thread_.Stop();
+  // Ensure that no tasks run on kSendTaskRunner.
+  base::AutoLock send_runner_lock(g_send_task_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_lock.Get());
 
   // 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()));
+  service()
+      ->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(service()->GetTaskRunner(kSendTaskRunner)->BelongsToCurrentThread());
+
+  // Obtain the lock so that the instance could not be destructed while this
+  // method is running on the kSendTaskRunner.
+  base::AutoLock lock(g_send_task_lock.Get());
+  {
+    // Check if Finalize() already runs. After this check, we can access |this|
+    // safely on the kEventTaskRunner.
+    base::AutoLock instance_id_lock(g_instance_id_lock.Get());
+    if (instance_id != g_active_instance_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) {
+  // Obtain the lock so that the instance could not be destructed while this
+  // method is running on the kEventTaskRunner.
+  base::AutoLock lock(g_event_task_lock.Get());
+  {
+    // Check if Finalize() already runs. After this check, we can access |this|
+    // safely on the kEventTaskRunner.
+    base::AutoLock instance_id_lock(g_instance_id_lock.Get());
+    if (instance_id != g_active_instance_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);
     loop_again = false;
   } else {
     if (pfd[0].revents & POLLIN) {
       // Read available incoming MIDI data.
       int remaining;
       double timestamp =
           (base::TimeTicks::Now() - base::TimeTicks()).InSecondsF();
       do {
         snd_seq_event_t* event;
         err = snd_seq_event_input(in_client_.get(), &event);
         remaining = snd_seq_event_input_pending(in_client_.get(), 0);
 
         if (err == -ENOSPC) {
           // Handle out of space error.
           VLOG(1) << "snd_seq_event_input detected buffer overrun";
           // We've lost events: check another way to see if we need to shut
           // down.
-          base::AutoLock lock(shutdown_lock_);
-          if (event_thread_shutdown_)
-            loop_again = false;
         } else if (err == -EAGAIN) {
           // We've read all the data.
         } else if (err < 0) {
           // Handle other errors.
           VLOG(1) << "snd_seq_event_input fails: " << snd_strerror(err);
           // TODO(agoode): Use RecordAction() or similar to log this.
           loop_again = false;
         } else if (event->source.client == SND_SEQ_CLIENT_SYSTEM &&
                    event->source.port == SND_SEQ_PORT_SYSTEM_ANNOUNCE) {
           // Handle announce events.
@@ skipping 28 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) {
+    service()
+        ->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 406 matching lines @@
   if (err != 0) {
     VLOG(1) << "snd_seq_subscribe_port fails: " << snd_strerror(err);
     return false;
   }
 
   // Update our map.
   source_map_[AddrToInt(client_id, port_id)] = port_index;
   return true;
 }
 
-MidiManager* MidiManager::Create() {
-  return new MidiManagerAlsa();
+MidiManager* MidiManager::Create(MidiService* service) {
+  return new MidiManagerAlsa(service);
 }
 
 }  // namespace midi