[not for review] Web MIDI: new backend to support dynamic instantiation on Windows

media/midi/dynamically_initialized_midi_manager_win.cc

Index: media/midi/dynamically_initialized_midi_manager_win.cc
diff --git a/media/midi/dynamically_initialized_midi_manager_win.cc b/media/midi/dynamically_initialized_midi_manager_win.cc
new file mode 100644
index 0000000000000000000000000000000000000000..619991e6b32c89beb8389e6d1e06e3bbd2e61545
--- /dev/null
+++ b/media/midi/dynamically_initialized_midi_manager_win.cc
@@ -0,0 +1,714 @@
+// 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/lazy_instance.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;
+
+// Defines SysEx message size limit.
+// TODO(crbug.com/383578): This restriction should be removed once Web MIDI
+// defines a standardized way to handle large sysex messages.
+// Note for built-in USB-MIDI driver:
+// From an observation on Windows 7/8.1 with a USB-MIDI keyboard,
+// midiOutLongMsg() will be always blocked. Sending 64 bytes or less data takes
+// roughly 300 usecs. Sending 2048 bytes or more data takes roughly
+// |message.size() / (75 * 1024)| secs in practice. Here we put 256 KB size
+// limit on SysEx message, with hoping that midiOutLongMsg will be blocked at
+// most 4 sec or so with a typical USB-MIDI device.
+// TODO(toyoshim): Consider to use linked small buffers so that midiOutReset()
+// can abort sending unhandled following buffers.
+constexpr size_t kSysExSizeLimit = 256 * 1024;
+
+// Defines input buffer size.
+constexpr size_t kBufferLength = 32 * 1024;
+
+// Global variables to identify MidiManager instance.
+constexpr int kInvalidInstanceId = -1;
+int g_active_instance_id = kInvalidInstanceId;
+int g_next_instance_id = 0;
+DynamicallyInitializedMidiManagerWin* g_manager_instance = nullptr;
+
+// Global map to resolve MIDI input port index from HMIDIIN.
+std::map<HMIDIIN, size_t> g_hmidiin_to_index_map;
+
+// Obtains base::Lock instance pointer to lock instance_id.
+base::Lock* GetInstanceIdLock() {
+  static base::Lock* lock = new base::Lock;
+  return lock;
+}
+
+// Use single TaskRunner for all tasks running outside the I/O thread.
+constexpr int kTaskRunner = 0;
+
+// Obtains base::Lock instance pointer to ensure tasks run safely on TaskRunner.
+base::Lock* GetTaskLock() {
+  static base::Lock* lock = new base::Lock;
+  return lock;
+}
+
+// Helper function to run a posted task on TaskRunner safely.
+void RunTask(int instance_id, const base::Closure& task) {
+  base::AutoLock task_lock(*GetTaskLock());
+  {
+    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 scheduler().
+
+// Utility class to handle MIDIHDR struct safely.
+class MIDIHDRDeleter {
+ public:
+  void operator()(LPMIDIHDR header) {
+    if (!header)
+      return;
+    delete[] static_cast<char*>(header->lpData);
+    delete header;
+  }
+};
+
+using ScopedMIDIHDR = std::unique_ptr<MIDIHDR, MIDIHDRDeleter>;
+
+ScopedMIDIHDR CreateMIDIHDR(size_t size) {
+  ScopedMIDIHDR hdr(new MIDIHDR);
+  ZeroMemory(hdr.get(), sizeof(*hdr));
+  hdr->lpData = new char[size];
+  hdr->dwBufferLength = static_cast<DWORD>(size);
+  return hdr;
+}
+
+ScopedMIDIHDR CreateMIDIHDR(const std::vector<uint8_t>& data) {
+  ScopedMIDIHDR hdr(CreateMIDIHDR(data.size()));
+  std::copy(data.begin(), data.end(), hdr->lpData);
+  return hdr;
+}
+
+// Helper functions to close MIDI device handles on TaskRunner asynchronously.
+void FinalizeInPort(HMIDIIN handle, LPMIDIHDR lphdr) {
+  // Resets the device. This stops receiving messages, and allows to release
+  // registered buffer headers. Otherwise, midiInUnprepareHeader() and
+  // midiInClose() will fail with MIDIERR_STILLPLAYING.
+  midiInReset(handle);
+
+  // Obtains MIDIHDR ownership to release allocated buffers.
+  ScopedMIDIHDR hdr(lphdr);
+  if (hdr)
+    midiInUnprepareHeader(handle, hdr.get(), sizeof(*hdr));
+  midiInClose(handle);
+}
+
+void FinalizeOutPort(HMIDIOUT handle) {
+  // Resets inflight buffers. This will cancel sending data that system
+  // holds and were not sent yet.
+  midiOutReset(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) {
+  if (msg != MIM_DATA && msg != MIM_LONGDATA)
+    return;
+  int instance_id = static_cast<int>(instance);
+  DynamicallyInitializedMidiManagerWin* manager = nullptr;
+
+  // Use |g_task_lock| so to ensure the instance can keep alive while running,
+  // and to access member variables that are used on TaskRunner.
+  base::AutoLock task_lock(*GetTaskLock());
+  {
+    base::AutoLock lock(*GetInstanceIdLock());
+    if (instance_id != g_active_instance_id)
+      return;
+    manager = g_manager_instance;
+  }
+
+  auto found = g_hmidiin_to_index_map.find(hmi);
+  if (found == g_hmidiin_to_index_map.end())
+    return;
+  size_t index = found->second;
+
+  if (msg == MIM_DATA) {
+    const uint8_t status_byte = static_cast<uint8_t>(param1 & 0xff);
+    const uint8_t first_data_byte = static_cast<uint8_t>((param1 >> 8) & 0xff);
+    const uint8_t second_data_byte =
+        static_cast<uint8_t>((param1 >> 16) & 0xff);
+    const size_t len = GetMessageLength(status_byte);
+    const uint8_t kData[] = {status_byte, first_data_byte, second_data_byte};
+    std::vector<uint8_t> data;
+    data.assign(kData, kData + len);
+    manager->PostReplyTask(
+        base::Bind(&DynamicallyInitializedMidiManagerWin::ReceiveMidiData,
+                   base::Unretained(manager), index, data,
+                   manager->CalculateInEventTime(index, param2)));
+  } else {  // msg == MIM_LONGDATA
+    LPMIDIHDR hdr = reinterpret_cast<LPMIDIHDR>(param1);
+    if (hdr->dwBytesRecorded > 0) {
+      const uint8_t* src = reinterpret_cast<const uint8_t*>(hdr->lpData);
+      std::vector<uint8_t> data;
+      data.assign(src, src + hdr->dwBytesRecorded);
+      manager->PostReplyTask(
+          base::Bind(&DynamicallyInitializedMidiManagerWin::ReceiveMidiData,
+                     base::Unretained(manager), index, data,
+                     manager->CalculateInEventTime(index, param2)));
+    }
+    // TODO(toyoshim): Call midiInAddBuffer outside the callback.
+    midiInAddBuffer(hmi, hdr, sizeof(*hdr));
+  }
+}
+
+// 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) {
+  if (msg == MOM_DONE) {
+    ScopedMIDIHDR hdr(reinterpret_cast<LPMIDIHDR>(param1));
+    if (!hdr)
+      return;
+    // TODO(toyoshim): Call midiOutUnprepareHeader outside the callback.
+    midiOutUnprepareHeader(hmo, hdr.get(), sizeof(*hdr));
+  }
+}
+
+enum class EnumerateState { Connected, Enumerating };
+
+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),
+        device_id_(device_id),
+        manufacturer_id_(manufacturer_id),
+        product_id_(product_id),
+        driver_version_(driver_version),
+        product_name_(product_name),
+        enumerate_state_(EnumerateState::Enumerating) {
+    info_.manufacturer = "unknown";  // TODO(toyoshim): Use USB information.
+    info_.name = product_name_;
+    info_.version = base::StringPrintf("%d.%d", HIBYTE(driver_version_),
+                                       LOBYTE(driver_version_));
+    info_.state = mojom::PortState::DISCONNECTED;
+  }
+
+  bool operator==(const Port& other) const {
+    // Should not use |device_id| for comparison because it can be changed on
+    // each enumeration.
+    // Since the GUID will be changed on each enumeration for Microsoft GS
+    // Wavetable synth and might be done for others, do not use it for device
+    // comparison.
+    return manufacturer_id_ == other.manufacturer_id_ &&
+           product_id_ == other.product_id_ &&
+           driver_version_ == other.driver_version_ &&
+           product_name_ == other.product_name_;
+  }
+
+  bool IsConnected() const {
+    return info_.state != mojom::PortState::DISCONNECTED;
+  }
+
+  void set_index(size_t index) {
+    index_ = index;
+    // TODO(toyoshim): Use hashed ID.
+    info_.id = base::StringPrintf("%s-%d", type_.c_str(), index_);
+  }
+  size_t index() { return index_; }
+  void set_device_id(uint32_t device_id) { device_id_ = device_id; }
+  void set_enumerate_state(EnumerateState state) { enumerate_state_ = state; }
+  EnumerateState enumerate_state() { return enumerate_state_; }
+  const MidiPortInfo& info() { return info_; }
+
+  virtual void Connect() {
+    info_.state = mojom::PortState::CONNECTED;
+    // TODO(toyoshim) Until open() / close() are supported, open each device on
+    // connected.
+    Open();
+  }
+
+  virtual void Disconnect() { info_.state = mojom::PortState::DISCONNECTED; }
+
+  virtual void Open() { info_.state = mojom::PortState::OPENED; }
+
+ protected:
+  size_t index_;
+  std::string type_;
+  uint32_t device_id_;
+  const uint16_t manufacturer_id_;
+  const uint16_t product_id_;
+  const uint32_t driver_version_;
+  const std::string product_name_;
+  MidiPortInfo info_;
+  EnumerateState enumerate_state_;
+};  // class Port
+
+}  // namespace
+
+class DynamicallyInitializedMidiManagerWin::InPort final : public Port {
+ public:
+  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)))),
+        in_handle_(kInvalidInHandle),
+        instance_id_(instance_id) {}
+
+  void Finalize(scoped_refptr<base::SingleThreadTaskRunner> runner) {
+    if (in_handle_ != kInvalidInHandle)
+      runner->PostTask(FROM_HERE,
+                       base::Bind(&FinalizeInPort, in_handle_, hdr_.release()));
+  }
+
+  base::TimeTicks CalculateInEventTime(uint32_t elapsed_ms) const {
+    return start_time_ + base::TimeDelta::FromMilliseconds(elapsed_ms);
+  }
+
+  // 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) {
+      hdr_ = CreateMIDIHDR(kBufferLength);
+      result = midiInPrepareHeader(in_handle_, hdr_.get(), sizeof(*hdr_));
+    }
+    if (result != MMSYSERR_NOERROR)
+      in_handle_ = kInvalidInHandle;
+    if (result == MMSYSERR_NOERROR)
+      result = midiInAddBuffer(in_handle_, hdr_.get(), sizeof(*hdr_));
+    if (result == MMSYSERR_NOERROR)
+      result = midiInStart(in_handle_);
+    if (result == MMSYSERR_NOERROR) {
+      start_time_ = base::TimeTicks::Now();
+      g_hmidiin_to_index_map[in_handle_] = index_;
+      Port::Open();
+    } else {
+      if (in_handle_ != kInvalidInHandle) {
+        midiInUnprepareHeader(in_handle_, hdr_.get(), sizeof(*hdr_));
+        midiInClose(in_handle_);
+        in_handle_ = kInvalidInHandle;
+      }
+      Disconnect();
+    }
+  }
+
+ private:
+  HMIDIIN in_handle_;
+  ScopedMIDIHDR hdr_;
+  base::TimeTicks start_time_;
+  int instance_id_;
+};
+
+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),
+        out_handle_(kInvalidOutHandle) {}
+
+  void Finalize(scoped_refptr<base::SingleThreadTaskRunner> runner) {
+    if (out_handle_ != kInvalidOutHandle)
+      runner->PostTask(FROM_HERE, base::Bind(&FinalizeOutPort, out_handle_));
+  }
+
+  void Send(const std::vector<uint8_t>& data) {
+    if (out_handle_ == kInvalidOutHandle)
+      return;
+
+    if (data.size() <= 3) {
+      DWORD message = 0;
+      for (size_t i = 0; i < data.size(); ++i)
+        message |= (static_cast<uint32_t>(data[i]) << (i * 8));
+      midiOutShortMsg(out_handle_, message);
+    } else {
+      if (data.size() > kSysExSizeLimit) {
+        LOG(ERROR) << "Ignoring SysEx message due to the size limit"
+                   << ", size = " << data.size();
+        // TODO(toyoshim): Consider to report metrics here.
+        return;
+      }
+      ScopedMIDIHDR hdr(CreateMIDIHDR(data));
+      MMRESULT result =
+          midiOutPrepareHeader(out_handle_, hdr.get(), sizeof(*hdr));
+      if (result != MMSYSERR_NOERROR)
+        return;
+      result = midiOutLongMsg(out_handle_, hdr.get(), sizeof(*hdr));
+      if (result != MMSYSERR_NOERROR)
+        midiOutUnprepareHeader(out_handle_, hdr.get(), sizeof(*hdr));
+      else
+        ignore_result(hdr.release());
+      // MIDIHDR will be released on MOM_DONE.
+    }
+  }
+
+  // Port overrides:
+  void 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;
+    }
+    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();
+    }
+  }
+
+ private:
+  const bool software_;
+  HMIDIOUT out_handle_;
+};
+
+DynamicallyInitializedMidiManagerWin::DynamicallyInitializedMidiManagerWin(
+    MidiService* service)
+    : MidiManager(service), instance_id_(kInvalidInstanceId) {
+  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();
+}
+
+DynamicallyInitializedMidiManagerWin::~DynamicallyInitializedMidiManagerWin() {
+  base::AutoLock lock(*GetInstanceIdLock());
+  CHECK_EQ(kInvalidInstanceId, g_active_instance_id);
+}
+
+base::TimeTicks DynamicallyInitializedMidiManagerWin::CalculateInEventTime(
+    size_t index,
+    uint32_t elapsed_ms) const {
+  GetTaskLock()->AssertAcquired();
+  CHECK_GT(input_ports_.size(), index);
+  return input_ports_[index]->CalculateInEventTime(elapsed_ms);
+}
+
+void DynamicallyInitializedMidiManagerWin::ReceiveMidiData(
+    uint32_t index,
+    const std::vector<uint8_t>& data,
+    base::TimeTicks time) {
+  MidiManager::ReceiveMidiData(index, data.data(), data.size(), time);
+}
+
+void DynamicallyInitializedMidiManagerWin::PostReplyTask(
+    const base::Closure& task) {
+  thread_runner_->PostTask(FROM_HERE, base::Bind(&RunTask, instance_id_, task));
+}
+
+void DynamicallyInitializedMidiManagerWin::StartInitialization() {
+  {
+    base::AutoLock lock(*GetInstanceIdLock());
+    CHECK_EQ(kInvalidInstanceId, g_active_instance_id);
+    instance_id_ = g_next_instance_id++;
+    g_active_instance_id = instance_id_;
+    CHECK_EQ(nullptr, g_manager_instance);
+    g_manager_instance = this;
+  }
+  // Registers on the I/O thread to be notified on the I/O thread.
+  CHECK(thread_runner_->BelongsToCurrentThread());
+  base::SystemMonitor::Get()->AddDevicesChangedObserver(this);
+
+  // Starts asynchronous initialization on TaskRunner.
+  PostTask(
+      base::Bind(&DynamicallyInitializedMidiManagerWin::InitializeOnTaskRunner,
+                 base::Unretained(this)));
+}
+
+void DynamicallyInitializedMidiManagerWin::Finalize() {
+  // Unregisters on the I/O thread.
+  CHECK(thread_runner_->BelongsToCurrentThread());
+  base::SystemMonitor::Get()->RemoveDevicesChangedObserver(this);
+  {
+    base::AutoLock lock(*GetInstanceIdLock());
+    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.
+  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) {
+  if (timestamp != 0.0) {
+    base::TimeTicks time =
+        base::TimeTicks() + base::TimeDelta::FromMicroseconds(
+                                timestamp * base::Time::kMicrosecondsPerSecond);
+    base::TimeTicks now = base::TimeTicks::Now();
+    if (now < time) {
+      PostDelayedTask(
+          base::Bind(&DynamicallyInitializedMidiManagerWin::SendOnTaskRunner,
+                     base::Unretained(this), client, port_index, data),
+          time - now);
+      return;
+    }
+  }
+  PostTask(base::Bind(&DynamicallyInitializedMidiManagerWin::SendOnTaskRunner,
+                      base::Unretained(this), client, port_index, data));
+}
+
+void DynamicallyInitializedMidiManagerWin::OnDevicesChanged(
+    base::SystemMonitor::DeviceType device_type) {
+  // Notified on the I/O thread.
+  CHECK(thread_runner_->BelongsToCurrentThread());
+
+  switch (device_type) {
+    case base::SystemMonitor::DEVTYPE_AUDIO:
+    case base::SystemMonitor::DEVTYPE_VIDEO_CAPTURE:
+      // Add case of other unrelated device types here.
+      return;
+    case base::SystemMonitor::DEVTYPE_UNKNOWN: {
+      base::AutoLock lock(*GetInstanceIdLock());
+      if (instance_id_ != g_active_instance_id)
+        return;
+      PostTask(base::Bind(
+          &DynamicallyInitializedMidiManagerWin::UpdateDeviceListOnTaskRunner,
+          base::Unretained(this)));
+      break;
+    }
+  }
+}
+
+void DynamicallyInitializedMidiManagerWin::PostTask(const base::Closure& task) {
+  service()
+      ->GetTaskRunner(kTaskRunner)
+      ->PostTask(FROM_HERE, base::Bind(&RunTask, instance_id_, task));
+}
+
+void DynamicallyInitializedMidiManagerWin::PostDelayedTask(
+    const base::Closure& task,
+    base::TimeDelta delay) {
+  service()
+      ->GetTaskRunner(kTaskRunner)
+      ->PostDelayedTask(FROM_HERE, base::Bind(&RunTask, instance_id_, task),
+                        delay);
+}
+
+void DynamicallyInitializedMidiManagerWin::InitializeOnTaskRunner() {
+  UpdateDeviceListOnTaskRunner();
+  PostReplyTask(
+      base::Bind(&DynamicallyInitializedMidiManagerWin::CompleteInitialization,
+                 base::Unretained(this), mojom::Result::OK));
+}
+
+void DynamicallyInitializedMidiManagerWin::UpdateDeviceListOnTaskRunner() {
+  // Update the devie list for input ports.
+  // First, mark all registered input ports to |EnumerateState::Enumerating|.
+  for (const auto& port : input_ports_)
+    port->set_enumerate_state(EnumerateState::Enumerating);
+
+  std::vector<std::unique_ptr<InPort>> new_input_ports;
+  const UINT num_in_devices = midiInGetNumDevs();
+  for (UINT device_id = 0; device_id < num_in_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;
+    }
+    std::unique_ptr<InPort> port =
+        base::MakeUnique<InPort>(instance_id_, device_id, caps);
+    const auto& found = std::find_if(
+        input_ports_.begin(), input_ports_.end(),
+        [&port](const auto& candidate) { return *candidate == *port; });
+    if (found == input_ports_.end()) {
+      new_input_ports.push_back(std::move(port));
+    } else {
+      // Update device ID which may be changed when device list is updated.
+      (*found)->set_device_id(device_id);
+      (*found)->set_enumerate_state(EnumerateState::Connected);
+    }
+  }
+  for (const auto& port : input_ports_) {
+    if (port->enumerate_state() == EnumerateState::Enumerating) {
+      // Disconnected ports have kept staying in |EnumerateState::Enumerating|
+      // state as they were marked first.
+      if (port->IsConnected()) {
+        port->Disconnect();
+        PostReplyTask(base::Bind(
+            &DynamicallyInitializedMidiManagerWin::SetInputPortState,
+            base::Unretained(this), port->index(), port->info().state));
+      }
+    } else if (port->enumerate_state() == EnumerateState::Connected) {
+      // Ports that have been connected, and are going to be connected now are
+      // in |EnumerateState::Connected| state.
+      if (!port->IsConnected()) {
+        port->Connect();
+        PostReplyTask(base::Bind(
+            &DynamicallyInitializedMidiManagerWin::SetInputPortState,
+            base::Unretained(this), port->index(), port->info().state));
+      }
+    }
+  }
+  // Assign port index to new devices and move them to the port list.
+  size_t in_index = input_ports_.size();
+  for (const auto& port : new_input_ports) {
+    port->set_index(in_index++);
+    port->Connect();
+    PostReplyTask(
+        base::Bind(&DynamicallyInitializedMidiManagerWin::AddInputPort,
+                   base::Unretained(this), port->info()));
+  }
+  input_ports_.insert(input_ports_.end(),
+                      std::make_move_iterator(new_input_ports.begin()),
+                      std::make_move_iterator(new_input_ports.end()));
+
+  // Update the devie list for output ports.
+  // First, mark all registered output ports to |EnumerateState::Enumerating|.
+  for (const auto& port : output_ports_)
+    port->set_enumerate_state(EnumerateState::Enumerating);
+
+  std::vector<std::unique_ptr<OutPort>> new_output_ports;
+  const UINT num_out_devices = midiOutGetNumDevs();
+  for (UINT device_id = 0; device_id < num_out_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;
+    }
+    std::unique_ptr<OutPort> port = base::MakeUnique<OutPort>(device_id, caps);
+    const auto& found = std::find_if(
+        output_ports_.begin(), output_ports_.end(),
+        [&port](const auto& candidate) { return *candidate == *port; });
+    if (found == output_ports_.end()) {
+      new_output_ports.push_back(std::move(port));
+    } else {
+      // Update device ID which may be changed when device list is updated.
+      (*found)->set_device_id(device_id);
+      (*found)->set_enumerate_state(EnumerateState::Connected);
+    }
+  }
+  for (const auto& port : output_ports_) {
+    if (port->enumerate_state() == EnumerateState::Enumerating) {
+      // Disconnected ports have kept staying in |EnumerateState::Enumerating|
+      // state as they were marked first.
+      if (port->IsConnected()) {
+        port->Disconnect();
+        PostReplyTask(base::Bind(
+            &DynamicallyInitializedMidiManagerWin::SetOutputPortState,
+            base::Unretained(this), port->index(), port->info().state));
+      }
+    } else if (port->enumerate_state() == EnumerateState::Connected) {
+      // Ports that have been connected, and are going to be connected now are
+      // in |EnumerateState::Connected| state.
+      if (!port->IsConnected()) {
+        port->Connect();
+        // Connect() won't change the state on output ports for software synth.
+        if (port->IsConnected()) {
+          PostReplyTask(base::Bind(
+              &DynamicallyInitializedMidiManagerWin::SetOutputPortState,
+              base::Unretained(this), port->index(), port->info().state));
+        }
+      }
+    }
+  }
+  // Assign port index to new devices and move them to the port list.
+  size_t out_index = output_ports_.size();
+  for (const auto& port : new_output_ports) {
+    port->set_index(out_index++);
+    port->Connect();
+    PostReplyTask(
+        base::Bind(&DynamicallyInitializedMidiManagerWin::AddOutputPort,
+                   base::Unretained(this), port->info()));
+  }
+  output_ports_.insert(output_ports_.end(),
+                       std::make_move_iterator(new_output_ports.begin()),
+                       std::make_move_iterator(new_output_ports.end()));
+
+  // 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.
+}
+
+void DynamicallyInitializedMidiManagerWin::SendOnTaskRunner(
+    MidiManagerClient* client,
+    uint32_t port_index,
+    const std::vector<uint8_t>& data) {
+  CHECK_GT(output_ports_.size(), port_index);
+  output_ports_[port_index]->Send(data);
+  // |client| will be checked inside MidiManager::AccumulateMidiBytesSent.
+  PostReplyTask(
+      base::Bind(&DynamicallyInitializedMidiManagerWin::AccumulateMidiBytesSent,
+                 base::Unretained(this), client, data.size()));
+}
+
+}  // namespace midi