Web MIDI: use midi::TaskService in MidiManagerAlsa

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>
@@ skipping 10 matching lines @@
 #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"
+#include "media/midi/task_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;
+enum {
+  kDefaultRunnerNotUsedOnAlsa = TaskService::kDefaultRunnerId,
+  kEventTaskRunner,
+  kSendTaskRunner
+};
 
 // 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;
+constexpr 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.
 // TODO(agoode): Add proper client -> card export from the kernel to avoid
 //               hardcoding.
-const int kMinimumClientIdForCards = 16;
+constexpr int kMinimumClientIdForCards = 16;
 
 // ALSA constants.
 const char kAlsaHw[] = "hw";
 
 // udev constants.
 const char kUdev[] = "udev";
 const char kUdevSubsystemSound[] = "sound";
 const char kUdevPropertySoundInitialized[] = "SOUND_INITIALIZED";
 const char kUdevActionChange[] = "change";
 const char kUdevActionRemove[] = "remove";
@@ skipping 10 matching lines @@
 
 const char kSysattrVendorName[] = "vendor_name";
 const char kSysattrVendor[] = "vendor";
 const char kSysattrModel[] = "model";
 const char kSysattrGuid[] = "guid";
 
 const char kCardSyspath[] = "/card";
 
 // Constants for the capabilities we search for in inputs and outputs.
 // See http://www.alsa-project.org/alsa-doc/alsa-lib/seq.html.
-const unsigned int kRequiredInputPortCaps =
+constexpr unsigned int kRequiredInputPortCaps =
     SND_SEQ_PORT_CAP_READ | SND_SEQ_PORT_CAP_SUBS_READ;
-const unsigned int kRequiredOutputPortCaps =
+constexpr unsigned int kRequiredOutputPortCaps =
     SND_SEQ_PORT_CAP_WRITE | SND_SEQ_PORT_CAP_SUBS_WRITE;
 
-const unsigned int kCreateOutputPortCaps =
+constexpr unsigned int kCreateOutputPortCaps =
     SND_SEQ_PORT_CAP_READ | SND_SEQ_PORT_CAP_NO_EXPORT;
-const unsigned int kCreateInputPortCaps =
+constexpr unsigned int kCreateInputPortCaps =
     SND_SEQ_PORT_CAP_WRITE | SND_SEQ_PORT_CAP_NO_EXPORT;
-const unsigned int kCreatePortType =
+constexpr 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;
-
-struct MidiManagerLockHelper {
-  base::Lock instance_id_lock;
-
-  // Prevent current instance from quiting Finalize() while tasks run on
-  // external TaskRunners.
-  base::Lock event_task_lock;
-  base::Lock send_task_lock;
-};
-
-MidiManagerLockHelper* GetLockHelper() {
-  static MidiManagerLockHelper* lock_helper = new MidiManagerLockHelper();
-  return lock_helper;
-}
-
 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 46 matching lines @@
                          const std::string& in_value) {
   if (!in_value.empty())
     value->SetString(path, in_value);
 }
 
 }  // namespace
 
 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_);
-
-  base::AutoLock instance_id_lock(GetLockHelper()->instance_id_lock);
-  CHECK_EQ(kInvalidInstanceId, g_active_instance_id);
 }
 
 void MidiManagerAlsa::StartInitialization() {
-  {
-    base::AutoLock lock(GetLockHelper()->instance_id_lock);
-    CHECK_EQ(kInvalidInstanceId, g_active_instance_id);
-    instance_id_ = g_next_instance_id++;
-    g_active_instance_id = instance_id_;
+  if (!service()->task_service()->BindInstance()) {
+    NOTREACHED();
+    return CompleteInitialization(Result::INITIALIZATION_ERROR);
   }
 
-  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);
     return CompleteInitialization(Result::INITIALIZATION_ERROR);
   }
   ScopedSndSeqPtr in_client(tmp_seq);
   tmp_seq = nullptr;
@@ skipping 90 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.
-  service()
-      ->GetTaskRunner(kEventTaskRunner)
-      ->PostTask(FROM_HERE, base::Bind(&MidiManagerAlsa::EventLoop,
-                                       base::Unretained(this), instance_id_));
+  service()->task_service()->PostBoundTask(
+      kEventTaskRunner,
+      base::BindOnce(&MidiManagerAlsa::EventLoop, base::Unretained(this)));
 
   CompleteInitialization(Result::OK);
 }
 
 void MidiManagerAlsa::Finalize() {
-  base::AutoLock lock(lazy_init_member_lock_);
-  DCHECK(initialization_thread_checker_->CalledOnValidThread());
-
-  // 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(GetLockHelper()->instance_id_lock);
-    CHECK_EQ(instance_id_, g_active_instance_id);
-    g_active_instance_id = kInvalidInstanceId;
-  }
-
-  // Ensure that no tasks run on kSendTaskRunner.
-  base::AutoLock send_runner_lock(GetLockHelper()->send_task_lock);
-
   // Close the out client. This will trigger the event thread to stop,
   // because of SND_SEQ_EVENT_CLIENT_EXIT.
   out_client_.reset();
 
-  // Ensure that no tasks run on kEventTaskRunner.
-  base::AutoLock event_runner_lock(GetLockHelper()->event_task_lock);
+  // Ensure that no task is running any more.
+  bool result = service()->task_service()->UnbindInstance();
+  CHECK(result);
 
   // 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());
   }
 
-  service()
-      ->GetTaskRunner(kSendTaskRunner)
-      ->PostDelayedTask(
-          FROM_HERE,
-          base::Bind(&MidiManagerAlsa::SendMidiData, base::Unretained(this),
-                     instance_id_, client, port_index, data),
-          delay);
+  service()->task_service()->PostBoundDelayedTask(
+      kSendTaskRunner,
+      base::BindOnce(&MidiManagerAlsa::SendMidiData, base::Unretained(this),
+                     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(int instance_id,
-                                   MidiManagerClient* client,
+void MidiManagerAlsa::SendMidiData(MidiManagerClient* client,
                                    uint32_t port_index,
                                    const std::vector<uint8_t>& data) {
-  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(GetLockHelper()->send_task_lock);
-  {
-    // Check if Finalize() already runs. After this check, we can access |this|
-    // safely on the kEventTaskRunner.
-    base::AutoLock instance_id_lock(GetLockHelper()->instance_id_lock);
-    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::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(GetLockHelper()->event_task_lock);
-  {
-    // Check if Finalize() already runs. After this check, we can access |this|
-    // safely on the kEventTaskRunner.
-    base::AutoLock instance_id_lock(GetLockHelper()->instance_id_lock);
-    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);
@@ skipping 56 matching lines @@
           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) {
-    service()
-        ->GetTaskRunner(kEventTaskRunner)
-        ->PostTask(FROM_HERE, base::Bind(&MidiManagerAlsa::EventLoop,
-                                         base::Unretained(this), instance_id));
+    service()->task_service()->PostBoundTask(
+        kEventTaskRunner,
+        base::BindOnce(&MidiManagerAlsa::EventLoop, base::Unretained(this)));
   }
 }
 
 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) {
@@ skipping 412 matching lines @@
   // Update our map.
   source_map_[AddrToInt(client_id, port_id)] = port_index;
   return true;
 }
 
 MidiManager* MidiManager::Create(MidiService* service) {
   return new MidiManagerAlsa(service);
 }
 
 }  // namespace midi