Web MIDI: device open/close for dynamic manager instantiation on Windows

media/midi/dynamically_initialized_midi_manager_win.cc

 // Copyright 2017 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/dynamically_initialized_midi_manager_win.h"
 
 #include <windows.h>
 
 #include <mmreg.h>
 #include <mmsystem.h>
 
 #include <algorithm>
 #include <string>
 
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string16.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/lock.h"
+#include "base/time/time.h"
+#include "media/midi/message_util.h"
 #include "media/midi/midi_port_info.h"
 #include "media/midi/midi_service.h"
 
 namespace midi {
 
 namespace {
 
+// Assumes that nullptr represents an invalid MIDI handle.
+constexpr HMIDIIN kInvalidInHandle = nullptr;
+constexpr HMIDIOUT kInvalidOutHandle = nullptr;
+
 // Global variables to identify MidiManager instance.
 constexpr int kInvalidInstanceId = -1;
 int g_active_instance_id = kInvalidInstanceId;
 DynamicallyInitializedMidiManagerWin* g_manager_instance = nullptr;
 
 // Obtains base::Lock instance pointer to lock instance_id.
 base::Lock* GetInstanceIdLock() {
   static base::Lock* lock = new base::Lock;
   return lock;
 }
@@ skipping 23 matching lines @@
     base::AutoLock lock(*GetInstanceIdLock());
     if (instance_id != g_active_instance_id)
       return;
   }
   task.Run();
 }
 
 // TODO(toyoshim): Factor out TaskRunner related functionaliries above, and
 // deprecate MidiScheduler. It should be available via MidiManager::scheduler().
 
+// Helper functions to close MIDI device handles on TaskRunner asynchronously.
+void FinalizeInPort(HMIDIIN handle) {
+  midiInClose(handle);
+}
+
+void FinalizeOutPort(HMIDIOUT handle) {
+  midiOutClose(handle);
+}
+
+// Handles MIDI input port callbacks that runs on a system provided thread.
+void CALLBACK HandleMidiInCallback(HMIDIIN hmi,
+                                   UINT msg,
+                                   DWORD_PTR instance,
+                                   DWORD_PTR param1,
+                                   DWORD_PTR param2) {
+  // TODO(toyoshim): Following patches will implement actual functions.
+}
+
+// Handles MIDI output port callbacks that runs on a system provided thread.
+void CALLBACK HandleMidiOutCallback(HMIDIOUT hmo,
+                                    UINT msg,
+                                    DWORD_PTR instance,
+                                    DWORD_PTR param1,
+                                    DWORD_PTR param2) {
+  // TODO(toyoshim): Following patches will implement actual functions.
+}
+
 class Port {
  public:
   Port(const std::string& type,
        uint32_t device_id,
        uint16_t manufacturer_id,
        uint16_t product_id,
        uint32_t driver_version,
        const std::string& product_name)
       : index_(0u),
         type_(type),
@@ skipping 66 matching lines @@
   const uint32_t driver_version_;
   const std::string product_name_;
   MidiPortInfo info_;
 };  // class Port
 
 }  // namespace
 
 // TODO(toyoshim): Following patches will implement actual functions.
 class DynamicallyInitializedMidiManagerWin::InPort final : public Port {
  public:
-  InPort(UINT device_id, const MIDIINCAPS2W& caps)
+  InPort(int instance_id, UINT device_id, const MIDIINCAPS2W& caps)
       : Port("input",
              device_id,
              caps.wMid,
              caps.wPid,
              caps.vDriverVersion,
              base::WideToUTF8(
-                 base::string16(caps.szPname, wcslen(caps.szPname)))) {}
+                 base::string16(caps.szPname, wcslen(caps.szPname)))),
+        in_handle_(kInvalidInHandle),
+        instance_id_(instance_id) {}
 
-  static std::vector<std::unique_ptr<InPort>> EnumerateActivePorts() {
+  static std::vector<std::unique_ptr<InPort>> EnumerateActivePorts(
+      int instance_id) {
     std::vector<std::unique_ptr<InPort>> ports;
     const UINT num_devices = midiInGetNumDevs();
     for (UINT device_id = 0; device_id < num_devices; ++device_id) {
       MIDIINCAPS2W caps;
       MMRESULT result = midiInGetDevCaps(
           device_id, reinterpret_cast<LPMIDIINCAPSW>(&caps), sizeof(caps));
       if (result != MMSYSERR_NOERROR) {
         LOG(ERROR) << "midiInGetDevCaps fails on device " << device_id;
         continue;
       }
-      ports.push_back(base::MakeUnique<InPort>(device_id, caps));
+      ports.push_back(base::MakeUnique<InPort>(instance_id, device_id, caps));
     }
     return ports;
   }
 
+  void Finalize(scoped_refptr<base::SingleThreadTaskRunner> runner) {
+    if (in_handle_ != kInvalidInHandle) {
+      runner->PostTask(FROM_HERE, base::Bind(&FinalizeInPort, in_handle_));
+    }
+  }
+
   void NotifyPortStateSet(DynamicallyInitializedMidiManagerWin* manager) {
     manager->PostReplyTask(
         base::Bind(&DynamicallyInitializedMidiManagerWin::SetInputPortState,
                    base::Unretained(manager), index_, info_.state));
   }
 
   void NotifyPortAdded(DynamicallyInitializedMidiManagerWin* manager) {
     manager->PostReplyTask(
         base::Bind(&DynamicallyInitializedMidiManagerWin::AddInputPort,
                    base::Unretained(manager), info_));
   }
+
+  // Port overrides:
+  void Open() override {
+    MMRESULT result =
+        midiInOpen(&in_handle_, device_id_,
+                   reinterpret_cast<DWORD_PTR>(&HandleMidiInCallback),
+                   instance_id_, CALLBACK_FUNCTION);
+    if (result == MMSYSERR_NOERROR)
+      Port::Open();
+    else
+      Disconnect();
+  }
+
+ private:
+  HMIDIIN in_handle_;
+  int instance_id_;
 };
 
 // TODO(toyoshim): Following patches will implement actual functions.
 class DynamicallyInitializedMidiManagerWin::OutPort final : public Port {
  public:
   OutPort(UINT device_id, const MIDIOUTCAPS2W& caps)
       : Port("output",
              device_id,
              caps.wMid,
              caps.wPid,
              caps.vDriverVersion,
              base::WideToUTF8(
                  base::string16(caps.szPname, wcslen(caps.szPname)))),
-        software_(caps.wTechnology == MOD_SWSYNTH) {}
+        software_(caps.wTechnology == MOD_SWSYNTH),
+        out_handle_(kInvalidOutHandle) {}
 
   static std::vector<std::unique_ptr<OutPort>> EnumerateActivePorts() {
     std::vector<std::unique_ptr<OutPort>> ports;
     const UINT num_devices = midiOutGetNumDevs();
     for (UINT device_id = 0; device_id < num_devices; ++device_id) {
       MIDIOUTCAPS2W caps;
       MMRESULT result = midiOutGetDevCaps(
           device_id, reinterpret_cast<LPMIDIOUTCAPSW>(&caps), sizeof(caps));
       if (result != MMSYSERR_NOERROR) {
         LOG(ERROR) << "midiOutGetDevCaps fails on device " << device_id;
         continue;
       }
       ports.push_back(base::MakeUnique<OutPort>(device_id, caps));
     }
     return ports;
   }
 
-  // Port overrides:
-  bool Connect() override {
-    // Until |software| option is supported, disable Microsoft GS Wavetable
-    // Synth that has a known security issue.
-    if (software_ && manufacturer_id_ == MM_MICROSOFT &&
-        (product_id_ == MM_MSFT_WDMAUDIO_MIDIOUT ||
-         product_id_ == MM_MSFT_GENERIC_MIDISYNTH)) {
-      return false;
-    }
-    return Port::Connect();
+  void Finalize(scoped_refptr<base::SingleThreadTaskRunner> runner) {
+    if (out_handle_ != kInvalidOutHandle)
+      runner->PostTask(FROM_HERE, base::Bind(&FinalizeOutPort, out_handle_));
   }
 
-  // Port Overrides:

[Takashi Toyoshima, 2017/02/21 05:54:28]

I forgot to remove this stale line.

   void NotifyPortStateSet(DynamicallyInitializedMidiManagerWin* manager) {
     manager->PostReplyTask(
         base::Bind(&DynamicallyInitializedMidiManagerWin::SetOutputPortState,
                    base::Unretained(manager), index_, info_.state));
   }
 
   void NotifyPortAdded(DynamicallyInitializedMidiManagerWin* manager) {
     manager->PostReplyTask(
         base::Bind(&DynamicallyInitializedMidiManagerWin::AddOutputPort,
                    base::Unretained(manager), info_));
   }
 
+  // Port overrides:
+  bool Connect() override {

[Takashi Toyoshima, 2017/02/21 05:54:28]

Connect() method is just replaced here so that we can place all override methods
after other methods.

+    // Until |software| option is supported, disable Microsoft GS Wavetable
+    // Synth that has a known security issue.
+    if (software_ && manufacturer_id_ == MM_MICROSOFT &&
+        (product_id_ == MM_MSFT_WDMAUDIO_MIDIOUT ||
+         product_id_ == MM_MSFT_GENERIC_MIDISYNTH)) {
+      return false;
+    }
+    return Port::Connect();
+  }
+
+  void Open() override {
+    MMRESULT result =
+        midiOutOpen(&out_handle_, device_id_,
+                    reinterpret_cast<DWORD_PTR>(&HandleMidiOutCallback), 0,
+                    CALLBACK_FUNCTION);
+    if (result == MMSYSERR_NOERROR) {
+      Port::Open();
+    } else {
+      out_handle_ = kInvalidOutHandle;
+      Disconnect();
+    }
+  }
+
   const bool software_;
+  HMIDIOUT out_handle_;
 };
 
 DynamicallyInitializedMidiManagerWin::DynamicallyInitializedMidiManagerWin(
     MidiService* service)
     : MidiManager(service), instance_id_(IssueNextInstanceId()) {
   base::AutoLock lock(*GetInstanceIdLock());
   CHECK_EQ(kInvalidInstanceId, g_active_instance_id);
 
   // Obtains the task runner for the current thread that hosts this instnace.
   thread_runner_ = base::ThreadTaskRunnerHandle::Get();
@@ skipping 37 matching lines @@
     CHECK_EQ(instance_id_, g_active_instance_id);
     g_active_instance_id = kInvalidInstanceId;
     CHECK_EQ(this, g_manager_instance);
     g_manager_instance = nullptr;
   }
 
   // Ensures that no task runs on TaskRunner so to destruct the instance safely.
   // Tasks that did not started yet will do nothing after invalidate the
   // instance ID above.
   base::AutoLock lock(*GetTaskLock());
+
+  // Posts tasks that finalize each device port without MidiManager instance
+  // on TaskRunner. If another MidiManager instance is created, its
+  // initialization runs on the same task runner after all tasks posted here
+  // finish.
+  for (const auto& port : input_ports_)
+    port->Finalize(service()->GetTaskRunner(kTaskRunner));
+  for (const auto& port : output_ports_)
+    port->Finalize(service()->GetTaskRunner(kTaskRunner));
 }
 
 void DynamicallyInitializedMidiManagerWin::DispatchSendMidiData(
     MidiManagerClient* client,
     uint32_t port_index,
     const std::vector<uint8_t>& data,
     double timestamp) {
   // TODO(toyoshim): Following patches will implement.
 }
 
@@ skipping 24 matching lines @@
 
 void DynamicallyInitializedMidiManagerWin::InitializeOnTaskRunner() {
   UpdateDeviceListOnTaskRunner();
   PostReplyTask(
       base::Bind(&DynamicallyInitializedMidiManagerWin::CompleteInitialization,
                  base::Unretained(this), mojom::Result::OK));
 }
 
 void DynamicallyInitializedMidiManagerWin::UpdateDeviceListOnTaskRunner() {
   std::vector<std::unique_ptr<InPort>> active_input_ports =
-      InPort::EnumerateActivePorts();
+      InPort::EnumerateActivePorts(instance_id_);
   ReflectActiveDeviceList(this, &input_ports_, &active_input_ports);
 
   std::vector<std::unique_ptr<OutPort>> active_output_ports =
       OutPort::EnumerateActivePorts();
   ReflectActiveDeviceList(this, &output_ports_, &active_output_ports);
 
   // TODO(toyoshim): This method may run before internal MIDI device lists that
   // Windows manages were updated. This may be because MIDI driver may be loaded
   // after the raw device list was updated. To avoid this problem, we may want
   // to retry device check later if no changes are detected here.
@@ skipping 28 matching lines @@
       size_t index = known_ports->size();
       port->set_index(index);
       known_ports->push_back(std::move(port));
       (*known_ports)[index]->Connect();
       (*known_ports)[index]->NotifyPortAdded(this);
     }
   }
 }
 
 }  // namespace midi