midi_manager_winrt.cc

// Copyright 2016 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_winrt.h"

#pragma warning(disable : 4467)

#include <initguid.h>  // Required by <devpkey.h>

#include <cfgmgr32.h>
#include <comdef.h>
#include <devpkey.h>
#include <robuffer.h>
#include <windows.devices.enumeration.h>
#include <windows.devices.midi.h>
#include <wrl/event.h>

#include <iomanip>
#include <unordered_map>
#include <unordered_set>

#include "base/bind.h"
#include "base/lazy_instance.h"
#include "base/scoped_generic.h"
#include "base/strings/string_util.h"
#include "base/strings/utf_string_conversions.h"
#include "base/threading/thread_checker.h"
#include "base/threading/thread_task_runner_handle.h"
#include "base/timer/timer.h"
#include "base/win/scoped_comptr.h"
#include "media/midi/midi_scheduler.h"

namespace media {
namespace midi {
namespace {

namespace WRL = Microsoft::WRL;

using namespace ABI::Windows::Devices::Enumeration;
using namespace ABI::Windows::Devices::Midi;
using namespace ABI::Windows::Foundation;
using namespace ABI::Windows::Storage::Streams;

using base::win::ScopedComPtr;

// Helpers for printing HRESULTs.
struct PrintHr {
  PrintHr(HRESULT hr) : hr(hr) {}
  HRESULT hr;
};

std::ostream& operator<<(std::ostream& os, const PrintHr& phr) {
  std::ios_base::fmtflags ff = os.flags();
  os << _com_error(phr.hr).ErrorMessage() << " (0x" << std::hex
     << std::uppercase << std::setfill('0') << std::setw(8) << phr.hr << ")";
  os.flags(ff);
  return os;
}

// Provides access to functions in combase.dll which may not be available on
// Windows 7. Loads functions dynamically at runtime to prevent library
// dependencies. Use this class through the global LazyInstance
// |g_combase_functions|.
class CombaseFunctions {
 public:
  CombaseFunctions() = default;

  ~CombaseFunctions() {
    if (combase_dll_)
      ::FreeLibrary(combase_dll_);
  }

  bool LoadFunctions() {
    combase_dll_ = ::LoadLibrary(L"combase.dll");
    if (!combase_dll_)
      return false;

    get_factory_func_ = reinterpret_cast<decltype(&::RoGetActivationFactory)>(
        ::GetProcAddress(combase_dll_, "RoGetActivationFactory"));
    if (!get_factory_func_)
      return false;

    create_string_func_ = reinterpret_cast<decltype(&::WindowsCreateString)>(
        ::GetProcAddress(combase_dll_, "WindowsCreateString"));
    if (!create_string_func_)
      return false;

    delete_string_func_ = reinterpret_cast<decltype(&::WindowsDeleteString)>(
        ::GetProcAddress(combase_dll_, "WindowsDeleteString"));
    if (!delete_string_func_)
      return false;

    get_string_raw_buffer_func_ =
        reinterpret_cast<decltype(&::WindowsGetStringRawBuffer)>(
            ::GetProcAddress(combase_dll_, "WindowsGetStringRawBuffer"));
    if (!get_string_raw_buffer_func_)
      return false;

    return true;
  }

  HRESULT RoGetActivationFactory(HSTRING class_id,
                                 const IID& iid,
                                 void** out_factory) {
    DCHECK(get_factory_func_);
    return get_factory_func_(class_id, iid, out_factory);
  }

  HRESULT WindowsCreateString(const base::char16* src,
                              uint32_t len,
                              HSTRING* out_hstr) {
    DCHECK(create_string_func_);
    return create_string_func_(src, len, out_hstr);
  }

  HRESULT WindowsDeleteString(HSTRING hstr) {
    DCHECK(delete_string_func_);
    return delete_string_func_(hstr);
  }

  const base::char16* WindowsGetStringRawBuffer(HSTRING hstr,
                                                uint32_t* out_len) {
    DCHECK(get_string_raw_buffer_func_);
    return get_string_raw_buffer_func_(hstr, out_len);
  }

 private:
  HMODULE combase_dll_ = nullptr;

  decltype(&::RoGetActivationFactory) get_factory_func_ = nullptr;
  decltype(&::WindowsCreateString) create_string_func_ = nullptr;
  decltype(&::WindowsDeleteString) delete_string_func_ = nullptr;
  decltype(&::WindowsGetStringRawBuffer) get_string_raw_buffer_func_ = nullptr;
};

base::LazyInstance<CombaseFunctions> g_combase_functions =
    LAZY_INSTANCE_INITIALIZER;

// Scoped HSTRING class to maintain lifetime of HSTRINGs allocated with
// WindowsCreateString().
class ScopedHStringTraits {
 public:
  static HSTRING InvalidValue() { return nullptr; }

  static void Free(HSTRING hstr) {
    g_combase_functions.Get().WindowsDeleteString(hstr);
  }
};

class ScopedHString : public base::ScopedGeneric<HSTRING, ScopedHStringTraits> {
 public:
  explicit ScopedHString(const base::char16* str) : ScopedGeneric(nullptr) {
    HSTRING hstr;
    HRESULT hr = g_combase_functions.Get().WindowsCreateString(
        str, static_cast<uint32_t>(wcslen(str)), &hstr);
    if (FAILED(hr))
      VLOG(1) << "WindowsCreateString failed: " << PrintHr(hr);
    else
      reset(hstr);
  }
};

// Factory functions that activate and create WinRT components. The caller takes
// ownership of the returning ComPtr.
template <typename InterfaceType, base::char16 const* runtime_class_id>
ScopedComPtr<InterfaceType> WrlStaticsFactory() {
  ScopedComPtr<InterfaceType> com_ptr;

  ScopedHString class_id_hstring(runtime_class_id);
  if (!class_id_hstring.is_valid()) {
    com_ptr = nullptr;
    return com_ptr;
  }

  HRESULT hr = g_combase_functions.Get().RoGetActivationFactory(
      class_id_hstring.get(), __uuidof(InterfaceType), com_ptr.ReceiveVoid());
  if (FAILED(hr)) {
    VLOG(1) << "RoGetActivationFactory failed: " << PrintHr(hr);
    com_ptr = nullptr;
  }

  return com_ptr;
}

std::string HStringToString(HSTRING hstr) {
  // Note: empty HSTRINGs are represent as nullptr, and instantiating
  // std::string with nullptr (in base::WideToUTF8) is undefined behavior.
  const base::char16* buffer =
      g_combase_functions.Get().WindowsGetStringRawBuffer(hstr, nullptr);
  if (buffer)
    return base::WideToUTF8(buffer);
  return std::string();
}

template <typename T>
std::string GetIdString(T* obj) {
  HSTRING result;
  HRESULT hr = obj->get_Id(&result);
  if (FAILED(hr)) {
    VLOG(1) << "get_Id failed: " << PrintHr(hr);
    return std::string();
  }
  return HStringToString(result);
}

template <typename T>
std::string GetDeviceIdString(T* obj) {
  HSTRING result;
  HRESULT hr = obj->get_DeviceId(&result);
  if (FAILED(hr)) {
    VLOG(1) << "get_DeviceId failed: " << PrintHr(hr);
    return std::string();
  }
  return HStringToString(result);
}

std::string GetNameString(IDeviceInformation* info) {
  HSTRING result;
  HRESULT hr = info->get_Name(&result);
  if (FAILED(hr)) {
    VLOG(1) << "get_Name failed: " << PrintHr(hr);
    return std::string();
  }
  return HStringToString(result);
}

HRESULT GetPointerToBufferData(IBuffer* buffer, uint8_t** out) {
  ScopedComPtr<Windows::Storage::Streams::IBufferByteAccess> buffer_byte_access;

  HRESULT hr = buffer_byte_access.QueryFrom(buffer);
  if (FAILED(hr)) {
    VLOG(1) << "QueryInterface failed: " << PrintHr(hr);
    return hr;
  }

  // Lifetime of the pointing buffer is controlled by the buffer object.
  hr = buffer_byte_access->Buffer(out);
  if (FAILED(hr)) {
    VLOG(1) << "Buffer failed: " << PrintHr(hr);
    return hr;
  }

  return S_OK;
}

// Checks if given DeviceInformation represent a Microsoft GS Wavetable Synth
// instance.
bool IsMicrosoftSynthesizer(IDeviceInformation* info) {
  auto midi_synthesizer_statics =
      WrlStaticsFactory<IMidiSynthesizerStatics,
                        RuntimeClass_Windows_Devices_Midi_MidiSynthesizer>();
  boolean result = FALSE;
  HRESULT hr = midi_synthesizer_statics->IsSynthesizer(info, &result);
  VLOG_IF(1, FAILED(hr)) << "IsSynthesizer failed: " << PrintHr(hr);
  return result != FALSE;
}

void GetDevPropString(DEVINST handle,
                      const DEVPROPKEY* devprop_key,
                      std::string* out) {
  DEVPROPTYPE devprop_type;
  unsigned long buffer_size = 0;

  // Retrieve |buffer_size| and allocate buffer later for receiving data.
  CONFIGRET cr = CM_Get_DevNode_Property(handle, devprop_key, &devprop_type,
                                         nullptr, &buffer_size, 0);
  if (cr != CR_BUFFER_SMALL) {
    // Here we print error codes in hex instead of using PrintHr() with
    // HRESULT_FROM_WIN32() and CM_MapCrToWin32Err(), since only a minor set of
    // CONFIGRET values are mapped to Win32 errors. Same for following VLOG()s.
    VLOG(1) << "CM_Get_DevNode_Property failed: CONFIGRET 0x" << std::hex << cr;
    return;
  }
  if (devprop_type != DEVPROP_TYPE_STRING) {
    VLOG(1) << "CM_Get_DevNode_Property returns wrong data type, "
            << "expected DEVPROP_TYPE_STRING";
    return;
  }

  std::unique_ptr<uint8_t[]> buffer(new uint8_t[buffer_size]);

  // Receive property data.
  cr = CM_Get_DevNode_Property(handle, devprop_key, &devprop_type, buffer.get(),
                               &buffer_size, 0);
  if (cr != CR_SUCCESS)
    VLOG(1) << "CM_Get_DevNode_Property failed: CONFIGRET 0x" << std::hex << cr;
  else
    *out = base::WideToUTF8(reinterpret_cast<base::char16*>(buffer.get()));
}

// Retrieves manufacturer (provider) and version information of underlying
// device driver through PnP Configuration Manager, given device (interface) ID
// provided by WinRT. |out_manufacturer| and |out_driver_version| won't be
// modified if retrieval fails.
//
// Device instance ID is extracted from device (interface) ID provided by WinRT
// APIs, for example from the following interface ID:
// \\?\SWD#MMDEVAPI#MIDII_60F39FCA.P_0002#{504be32c-ccf6-4d2c-b73f-6f8b3747e22b}
// we extract the device instance ID: SWD\MMDEVAPI\MIDII_60F39FCA.P_0002
//
// However the extracted device instance ID represent a "software device"
// provided by Microsoft, which is an interface on top of the hardware for each
// input/output port. Therefore we further locate its parent device, which is
// the actual hardware device, for driver information.
void GetDriverInfoFromDeviceId(const std::string& dev_id,
                               std::string* out_manufacturer,
                               std::string* out_driver_version) {
  base::string16 dev_instance_id =
      base::UTF8ToWide(dev_id.substr(4, dev_id.size() - 43));
  base::ReplaceChars(dev_instance_id, L"#", L"\\", &dev_instance_id);

  DEVINST dev_instance_handle;
  CONFIGRET cr = CM_Locate_DevNode(&dev_instance_handle, &dev_instance_id[0],
                                   CM_LOCATE_DEVNODE_NORMAL);
  if (cr != CR_SUCCESS) {
    VLOG(1) << "CM_Locate_DevNode failed: CONFIGRET 0x" << std::hex << cr;
    return;
  }

  DEVINST parent_handle;
  cr = CM_Get_Parent(&parent_handle, dev_instance_handle, 0);
  if (cr != CR_SUCCESS) {
    VLOG(1) << "CM_Get_Parent failed: CONFIGRET 0x" << std::hex << cr;
    return;
  }

  GetDevPropString(parent_handle, &DEVPKEY_Device_DriverProvider,
                   out_manufacturer);
  GetDevPropString(parent_handle, &DEVPKEY_Device_DriverVersion,
                   out_driver_version);
}

// Tokens with value = 0 are considered invalid (as in <wrl/event.h>).
const int64_t kInvalidTokenValue = 0;

template <typename InterfaceType>
struct MidiPort {
  MidiPort() = default;

  uint32_t index;
  ScopedComPtr<InterfaceType> handle;
  EventRegistrationToken token_MessageReceived;

 private:
  DISALLOW_COPY_AND_ASSIGN(MidiPort);
};

}  // namespace

template <typename InterfaceType,
          typename RuntimeType,
          typename StaticsInterfaceType,
          base::char16 const* runtime_class_id>
class MidiManagerWinrt::MidiPortManager {
 public:
  // MidiPortManager instances should be constructed on the COM thread.
  MidiPortManager(MidiManagerWinrt* midi_manager)
      : midi_manager_(midi_manager),
        task_runner_(base::ThreadTaskRunnerHandle::Get()) {}

  virtual ~MidiPortManager() { DCHECK(thread_checker_.CalledOnValidThread()); }

  bool StartWatcher() {
    DCHECK(thread_checker_.CalledOnValidThread());

    HRESULT hr;

    midi_port_statics_ =
        WrlStaticsFactory<StaticsInterfaceType, runtime_class_id>();
    if (!midi_port_statics_)
      return false;

    HSTRING device_selector = nullptr;
    hr = midi_port_statics_->GetDeviceSelector(&device_selector);
    if (FAILED(hr)) {
      VLOG(1) << "GetDeviceSelector failed: " << PrintHr(hr);
      return false;
    }

    auto dev_info_statics = WrlStaticsFactory<
        IDeviceInformationStatics,
        RuntimeClass_Windows_Devices_Enumeration_DeviceInformation>();
    if (!dev_info_statics)
      return false;

    hr = dev_info_statics->CreateWatcherAqsFilter(device_selector,
                                                  watcher_.Receive());
    if (FAILED(hr)) {
      VLOG(1) << "CreateWatcherAqsFilter failed: " << PrintHr(hr);
      return false;
    }

    // Register callbacks to WinRT that post state-modifying jobs back to COM
    // thread. |weak_ptr| and |task_runner| are captured by lambda callbacks for
    // posting jobs. Note that WinRT callback arguments should not be passed
    // outside the callback since the pointers may be unavailable afterwards.
    base::WeakPtr<MidiPortManager> weak_ptr = GetWeakPtrFromFactory();
    scoped_refptr<base::SingleThreadTaskRunner> task_runner = task_runner_;

    hr = watcher_->add_Added(
        WRL::Callback<ITypedEventHandler<DeviceWatcher*, DeviceInformation*>>(
            [weak_ptr, task_runner](IDeviceWatcher* watcher,
                                    IDeviceInformation* info) {
              // Disable Microsoft GS Wavetable Synth due to security reasons.
              // http://crbug.com/499279
              if (IsMicrosoftSynthesizer(info))
                return S_OK;

              std::string dev_id = GetIdString(info),
                          dev_name = GetNameString(info);

              task_runner->PostTask(
                  FROM_HERE, base::Bind(&MidiPortManager::OnAdded, weak_ptr,
                                        dev_id, dev_name));

              return S_OK;
            })
            .Get(),
        &token_Added_);
    if (FAILED(hr)) {
      VLOG(1) << "add_Added failed: " << PrintHr(hr);
      return false;
    }

    hr = watcher_->add_EnumerationCompleted(
        WRL::Callback<ITypedEventHandler<DeviceWatcher*, IInspectable*>>(
            [weak_ptr, task_runner](IDeviceWatcher* watcher,
                                    IInspectable* insp) {
              task_runner->PostTask(
                  FROM_HERE,
                  base::Bind(&MidiPortManager::OnEnumerationCompleted,
                             weak_ptr));

              return S_OK;
            })
            .Get(),
        &token_EnumerationCompleted_);
    if (FAILED(hr)) {
      VLOG(1) << "add_EnumerationCompleted failed: " << PrintHr(hr);
      return false;
    }

    hr = watcher_->add_Removed(
        WRL::Callback<
            ITypedEventHandler<DeviceWatcher*, DeviceInformationUpdate*>>(
            [weak_ptr, task_runner](IDeviceWatcher* watcher,
                                    IDeviceInformationUpdate* update) {
              std::string dev_id = GetIdString(update);

              task_runner->PostTask(
                  FROM_HERE,
                  base::Bind(&MidiPortManager::OnRemoved, weak_ptr, dev_id));

              return S_OK;
            })
            .Get(),
        &token_Removed_);
    if (FAILED(hr)) {
      VLOG(1) << "add_Removed failed: " << PrintHr(hr);
      return false;
    }

    hr = watcher_->add_Stopped(
        WRL::Callback<ITypedEventHandler<DeviceWatcher*, IInspectable*>>(
            [](IDeviceWatcher* watcher, IInspectable* insp) {
              // Placeholder, does nothing for now.
              return S_OK;
            })
            .Get(),
        &token_Stopped_);
    if (FAILED(hr)) {
      VLOG(1) << "add_Stopped failed: " << PrintHr(hr);
      return false;
    }

    hr = watcher_->add_Updated(
        WRL::Callback<
            ITypedEventHandler<DeviceWatcher*, DeviceInformationUpdate*>>(
            [](IDeviceWatcher* watcher, IDeviceInformationUpdate* update) {
              // TODO(shaochuan): Check for fields to be updated here.
              return S_OK;
            })
            .Get(),
        &token_Updated_);
    if (FAILED(hr)) {
      VLOG(1) << "add_Updated failed: " << PrintHr(hr);
      return false;
    }

    hr = watcher_->Start();
    if (FAILED(hr)) {
      VLOG(1) << "Start failed: " << PrintHr(hr);
      return false;
    }

    is_initialized_ = true;
    return true;
  }

  void StopWatcher() {
    DCHECK(thread_checker_.CalledOnValidThread());

    HRESULT hr;

    for (const auto& entry : ports_)
      RemovePortEventHandlers(entry.second.get());

    if (token_Added_.value != kInvalidTokenValue) {
      hr = watcher_->remove_Added(token_Added_);
      VLOG_IF(1, FAILED(hr)) << "remove_Added failed: " << PrintHr(hr);
      token_Added_.value = kInvalidTokenValue;
    }
    if (token_EnumerationCompleted_.value != kInvalidTokenValue) {
      hr = watcher_->remove_EnumerationCompleted(token_EnumerationCompleted_);
      VLOG_IF(1, FAILED(hr)) << "remove_EnumerationCompleted failed: "
                             << PrintHr(hr);
      token_EnumerationCompleted_.value = kInvalidTokenValue;
    }
    if (token_Removed_.value != kInvalidTokenValue) {
      hr = watcher_->remove_Removed(token_Removed_);
      VLOG_IF(1, FAILED(hr)) << "remove_Removed failed: " << PrintHr(hr);
      token_Removed_.value = kInvalidTokenValue;
    }
    if (token_Stopped_.value != kInvalidTokenValue) {
      hr = watcher_->remove_Stopped(token_Stopped_);
      VLOG_IF(1, FAILED(hr)) << "remove_Stopped failed: " << PrintHr(hr);
      token_Stopped_.value = kInvalidTokenValue;
    }
    if (token_Updated_.value != kInvalidTokenValue) {
      hr = watcher_->remove_Updated(token_Updated_);
      VLOG_IF(1, FAILED(hr)) << "remove_Updated failed: " << PrintHr(hr);
      token_Updated_.value = kInvalidTokenValue;
    }

    if (is_initialized_) {
      hr = watcher_->Stop();
      VLOG_IF(1, FAILED(hr)) << "Stop failed: " << PrintHr(hr);
      is_initialized_ = false;
    }
  }

  MidiPort<InterfaceType>* GetPortByDeviceId(std::string dev_id) {
    DCHECK(thread_checker_.CalledOnValidThread());
    CHECK(is_initialized_);

    auto it = ports_.find(dev_id);
    if (it == ports_.end())
      return nullptr;
    return it->second.get();
  }

  MidiPort<InterfaceType>* GetPortByIndex(uint32_t port_index) {
    DCHECK(thread_checker_.CalledOnValidThread());
    CHECK(is_initialized_);

    return GetPortByDeviceId(port_ids_[port_index]);
  }

 protected:
  // Points to the MidiManagerWinrt instance, which is expected to outlive the
  // MidiPortManager instance.
  MidiManagerWinrt* midi_manager_;

  // Task runner of the COM thread.
  scoped_refptr<base::SingleThreadTaskRunner> task_runner_;

  // Ensures all methods are called on the COM thread.
  base::ThreadChecker thread_checker_;

 private:
  // DeviceWatcher callbacks:
  void OnAdded(std::string dev_id, std::string dev_name) {
    DCHECK(thread_checker_.CalledOnValidThread());
    CHECK(is_initialized_);

    port_names_[dev_id] = dev_name;

    ScopedHString dev_id_hstring(base::UTF8ToWide(dev_id).c_str());
    if (!dev_id_hstring.is_valid())
      return;

    IAsyncOperation<RuntimeType*>* async_op;

    HRESULT hr =
        midi_port_statics_->FromIdAsync(dev_id_hstring.get(), &async_op);
    if (FAILED(hr)) {
      VLOG(1) << "FromIdAsync failed: " << PrintHr(hr);
      return;
    }

    base::WeakPtr<MidiPortManager> weak_ptr = GetWeakPtrFromFactory();
    scoped_refptr<base::SingleThreadTaskRunner> task_runner = task_runner_;

    hr = async_op->put_Completed(
        WRL::Callback<IAsyncOperationCompletedHandler<RuntimeType*>>(
            [weak_ptr, task_runner](IAsyncOperation<RuntimeType*>* async_op,
                                    AsyncStatus status) {
              InterfaceType* handle;
              HRESULT hr = async_op->GetResults(&handle);
              if (FAILED(hr)) {
                VLOG(1) << "GetResults failed: " << PrintHr(hr);
                return hr;
              }

              // A reference to |async_op| is kept in |async_ops_|, safe to pass
              // outside.
              task_runner->PostTask(
                  FROM_HERE,
                  base::Bind(&MidiPortManager::OnCompletedGetPortFromIdAsync,
                             weak_ptr, handle, async_op));

              return S_OK;
            })
            .Get());
    if (FAILED(hr)) {
      VLOG(1) << "put_Completed failed: " << PrintHr(hr);
      return;
    }

    // Keep a reference to incompleted |async_op| for releasing later.
    async_ops_.insert(async_op);
  }

  void OnEnumerationCompleted() {
    DCHECK(thread_checker_.CalledOnValidThread());
    CHECK(is_initialized_);

    if (async_ops_.empty())
      midi_manager_->OnPortManagerReady();
    else
      enumeration_completed_not_ready_ = true;
  }

  void OnRemoved(std::string dev_id) {
    DCHECK(thread_checker_.CalledOnValidThread());
    CHECK(is_initialized_);

    // Note: in case Microsoft GS Wavetable Synth triggers this event for some
    // reason, it will be ignored here with log emitted.
    MidiPort<InterfaceType>* port = GetPortByDeviceId(dev_id);
    if (!port) {
      VLOG(1) << "Removing non-existent port " << dev_id;
      return;
    }

    SetPortState(port->index, MIDI_PORT_DISCONNECTED);

    RemovePortEventHandlers(port);
    port->handle = nullptr;
  }

  void OnCompletedGetPortFromIdAsync(InterfaceType* handle,
                                     IAsyncOperation<RuntimeType*>* async_op) {
    DCHECK(thread_checker_.CalledOnValidThread());
    CHECK(is_initialized_);

    EventRegistrationToken token = {kInvalidTokenValue};
    if (!RegisterOnMessageReceived(handle, &token))
      return;

    std::string dev_id = GetDeviceIdString(handle);

    MidiPort<InterfaceType>* port = GetPortByDeviceId(dev_id);

    if (port == nullptr) {
      std::string manufacturer = "Unknown", driver_version = "Unknown";
      GetDriverInfoFromDeviceId(dev_id, &manufacturer, &driver_version);

      AddPort(MidiPortInfo(dev_id, manufacturer, port_names_[dev_id],
                           driver_version, MIDI_PORT_OPENED));

      port = new MidiPort<InterfaceType>;
      port->index = static_cast<uint32_t>(port_ids_.size());

      ports_[dev_id].reset(port);
      port_ids_.push_back(dev_id);
    } else {
      SetPortState(port->index, MIDI_PORT_CONNECTED);
    }

    port->handle = handle;
    port->token_MessageReceived = token;

    // Manually release COM interface to completed |async_op|.
    auto it = async_ops_.find(async_op);
    CHECK(it != async_ops_.end());
    (*it)->Release();
    async_ops_.erase(it);

    if (enumeration_completed_not_ready_ && async_ops_.empty()) {
      midi_manager_->OnPortManagerReady();
      enumeration_completed_not_ready_ = false;
    }
  }

  // Overrided by MidiInPortManager to listen to input ports.
  virtual bool RegisterOnMessageReceived(InterfaceType* handle,
                                         EventRegistrationToken* p_token) {
    return true;
  }

  // Overrided by MidiInPortManager to remove MessageReceived event handler.
  virtual void RemovePortEventHandlers(MidiPort<InterfaceType>* port) {}

  // Calls midi_manager_->Add{Input,Output}Port.
  virtual void AddPort(MidiPortInfo info) = 0;

  // Calls midi_manager_->Set{Input,Output}PortState.
  virtual void SetPortState(uint32_t port_index, MidiPortState state) = 0;

  // WeakPtrFactory has to be declared in derived class, use this method to
  // retrieve upcasted WeakPtr for posting tasks.
  virtual base::WeakPtr<MidiPortManager> GetWeakPtrFromFactory() = 0;

  // Midi{In,Out}PortStatics instance.
  ScopedComPtr<StaticsInterfaceType> midi_port_statics_;

  // DeviceWatcher instance and event registration tokens for unsubscribing
  // events in destructor.
  ScopedComPtr<IDeviceWatcher> watcher_;
  EventRegistrationToken token_Added_ = {kInvalidTokenValue},
                         token_EnumerationCompleted_ = {kInvalidTokenValue},
                         token_Removed_ = {kInvalidTokenValue},
                         token_Stopped_ = {kInvalidTokenValue},
                         token_Updated_ = {kInvalidTokenValue};

  // All manipulations to these fields should be done on COM thread.
  std::unordered_map<std::string, std::unique_ptr<MidiPort<InterfaceType>>>
      ports_;
  std::vector<std::string> port_ids_;
  std::unordered_map<std::string, std::string> port_names_;

  // Keeps AsyncOperation references before the operation completes. Note that
  // raw pointers are used here and the COM interfaces should be released
  // manually.
  std::unordered_set<IAsyncOperation<RuntimeType*>*> async_ops_;

  // Set when device enumeration is completed but OnPortManagerReady() is not
  // called since some ports are not yet ready (i.e. |async_ops_| is not empty).
  // In such cases, OnPortManagerReady() will be called in
  // OnCompletedGetPortFromIdAsync() when the last pending port is ready.
  bool enumeration_completed_not_ready_ = false;

  // Set if the instance is initialized without error. Should be checked in all
  // methods on COM thread except StartWatcher().
  bool is_initialized_ = false;
};

class MidiManagerWinrt::MidiInPortManager final
    : public MidiPortManager<IMidiInPort,
                             MidiInPort,
                             IMidiInPortStatics,
                             RuntimeClass_Windows_Devices_Midi_MidiInPort> {
 public:
  MidiInPortManager(MidiManagerWinrt* midi_manager)
      : MidiPortManager(midi_manager), weak_factory_(this) {}

 private:
  // MidiPortManager overrides:
  bool RegisterOnMessageReceived(IMidiInPort* handle,
                                 EventRegistrationToken* p_token) override {
    DCHECK(thread_checker_.CalledOnValidThread());

    base::WeakPtr<MidiInPortManager> weak_ptr = weak_factory_.GetWeakPtr();
    scoped_refptr<base::SingleThreadTaskRunner> task_runner = task_runner_;

    HRESULT hr = handle->add_MessageReceived(
        WRL::Callback<
            ITypedEventHandler<MidiInPort*, MidiMessageReceivedEventArgs*>>(
            [weak_ptr, task_runner](IMidiInPort* handle,
                                    IMidiMessageReceivedEventArgs* args) {
              const base::TimeTicks now = base::TimeTicks::Now();

              std::string dev_id = GetDeviceIdString(handle);

              ScopedComPtr<IMidiMessage> message;
              HRESULT hr = args->get_Message(message.Receive());
              if (FAILED(hr)) {
                VLOG(1) << "get_Message failed: " << PrintHr(hr);
                return hr;
              }

              ScopedComPtr<IBuffer> buffer;
              hr = message->get_RawData(buffer.Receive());
              if (FAILED(hr)) {
                VLOG(1) << "get_RawData failed: " << PrintHr(hr);
                return hr;
              }

              uint8_t* p_buffer_data = nullptr;
              hr = GetPointerToBufferData(buffer.get(), &p_buffer_data);
              if (FAILED(hr))
                return hr;

              uint32_t data_length = 0;
              hr = buffer->get_Length(&data_length);
              if (FAILED(hr)) {
                VLOG(1) << "get_Length failed: " << PrintHr(hr);
                return hr;
              }

              std::vector<uint8_t> data(p_buffer_data,
                                        p_buffer_data + data_length);

              task_runner->PostTask(
                  FROM_HERE, base::Bind(&MidiInPortManager::OnMessageReceived,
                                        weak_ptr, dev_id, data, now));

              return S_OK;
            })
            .Get(),
        p_token);
    if (FAILED(hr)) {
      VLOG(1) << "add_MessageReceived failed: " << PrintHr(hr);
      return false;
    }

    return true;
  }

  void RemovePortEventHandlers(MidiPort<IMidiInPort>* port) override {
    if (!(port->handle &&
          port->token_MessageReceived.value != kInvalidTokenValue))
      return;

    HRESULT hr =
        port->handle->remove_MessageReceived(port->token_MessageReceived);
    VLOG_IF(1, FAILED(hr)) << "remove_MessageReceived failed: " << PrintHr(hr);
    port->token_MessageReceived.value = kInvalidTokenValue;
  }

  void AddPort(MidiPortInfo info) final { midi_manager_->AddInputPort(info); }

  void SetPortState(uint32_t port_index, MidiPortState state) final {
    midi_manager_->SetInputPortState(port_index, state);
  }

  base::WeakPtr<MidiPortManager> GetWeakPtrFromFactory() final {
    DCHECK(thread_checker_.CalledOnValidThread());

    return weak_factory_.GetWeakPtr();
  }

  // Callback on receiving MIDI input message.
  void OnMessageReceived(std::string dev_id,
                         std::vector<uint8_t> data,
                         base::TimeTicks time) {
    DCHECK(thread_checker_.CalledOnValidThread());

    MidiPort<IMidiInPort>* port = GetPortByDeviceId(dev_id);
    CHECK(port);

    midi_manager_->ReceiveMidiData(port->index, &data[0], data.size(), time);
  }

  // Last member to ensure destructed first.
  base::WeakPtrFactory<MidiInPortManager> weak_factory_;

  DISALLOW_COPY_AND_ASSIGN(MidiInPortManager);
};

class MidiManagerWinrt::MidiOutPortManager final
    : public MidiPortManager<IMidiOutPort,
                             IMidiOutPort,
                             IMidiOutPortStatics,
                             RuntimeClass_Windows_Devices_Midi_MidiOutPort> {
 public:
  MidiOutPortManager(MidiManagerWinrt* midi_manager)
      : MidiPortManager(midi_manager), weak_factory_(this) {}

 private:
  // MidiPortManager overrides:
  void AddPort(MidiPortInfo info) final { midi_manager_->AddOutputPort(info); }

  void SetPortState(uint32_t port_index, MidiPortState state) final {
    midi_manager_->SetOutputPortState(port_index, state);
  }

  base::WeakPtr<MidiPortManager> GetWeakPtrFromFactory() final {
    DCHECK(thread_checker_.CalledOnValidThread());

    return weak_factory_.GetWeakPtr();
  }

  // Last member to ensure destructed first.
  base::WeakPtrFactory<MidiOutPortManager> weak_factory_;

  DISALLOW_COPY_AND_ASSIGN(MidiOutPortManager);
};

MidiManagerWinrt::MidiManagerWinrt() : com_thread_("Windows MIDI COM Thread") {}

MidiManagerWinrt::~MidiManagerWinrt() {
  base::AutoLock auto_lock(lazy_init_member_lock_);

  CHECK(!com_thread_checker_);
  CHECK(!port_manager_in_);
  CHECK(!port_manager_out_);
  CHECK(!scheduler_);
}

void MidiManagerWinrt::StartInitialization() {
  com_thread_.init_com_with_mta(true);
  com_thread_.Start();

  com_thread_.task_runner()->PostTask(
      FROM_HERE, base::Bind(&MidiManagerWinrt::InitializeOnComThread,
                            base::Unretained(this)));
}

void MidiManagerWinrt::Finalize() {
  com_thread_.task_runner()->PostTask(
      FROM_HERE, base::Bind(&MidiManagerWinrt::FinalizeOnComThread,
                            base::Unretained(this)));

  // Blocks until FinalizeOnComThread() returns. Delayed MIDI send data tasks
  // will be ignored.
  com_thread_.Stop();
}

void MidiManagerWinrt::DispatchSendMidiData(MidiManagerClient* client,
                                            uint32_t port_index,
                                            const std::vector<uint8_t>& data,
                                            double timestamp) {
  CHECK(scheduler_);

  scheduler_->PostSendDataTask(
      client, data.size(), timestamp,
      base::Bind(&MidiManagerWinrt::SendOnComThread, base::Unretained(this),
                 port_index, data));
}

void MidiManagerWinrt::InitializeOnComThread() {
  base::AutoLock auto_lock(lazy_init_member_lock_);

  com_thread_checker_.reset(new base::ThreadChecker);

  if (!g_combase_functions.Get().LoadFunctions()) {
    VLOG(1) << "Failed loading functions from combase.dll: "
            << PrintHr(HRESULT_FROM_WIN32(GetLastError()));
    CompleteInitialization(Result::INITIALIZATION_ERROR);
    return;
  }

  port_manager_in_.reset(new MidiInPortManager(this));
  port_manager_out_.reset(new MidiOutPortManager(this));

  scheduler_.reset(new MidiScheduler(this));

  if (!(port_manager_in_->StartWatcher() &&
        port_manager_out_->StartWatcher())) {
    port_manager_in_->StopWatcher();
    port_manager_out_->StopWatcher();
    CompleteInitialization(Result::INITIALIZATION_ERROR);
  }
}

void MidiManagerWinrt::FinalizeOnComThread() {
  base::AutoLock auto_lock(lazy_init_member_lock_);

  DCHECK(com_thread_checker_->CalledOnValidThread());

  scheduler_.reset();

  if (port_manager_in_) {
    port_manager_in_->StopWatcher();
    port_manager_in_.reset();
  }

  if (port_manager_out_) {
    port_manager_out_->StopWatcher();
    port_manager_out_.reset();
  }

  com_thread_checker_.reset();
}

void MidiManagerWinrt::SendOnComThread(uint32_t port_index,
                                       const std::vector<uint8_t>& data) {
  DCHECK(com_thread_checker_->CalledOnValidThread());

  MidiPort<IMidiOutPort>* port = port_manager_out_->GetPortByIndex(port_index);
  if (!(port && port->handle)) {
    VLOG(1) << "Port not available: " << port_index;
    return;
  }

  auto buffer_factory =
      WrlStaticsFactory<IBufferFactory,
                        RuntimeClass_Windows_Storage_Streams_Buffer>();
  if (!buffer_factory)
    return;

  ScopedComPtr<IBuffer> buffer;
  HRESULT hr = buffer_factory->Create(static_cast<UINT32>(data.size()),
                                      buffer.Receive());
  if (FAILED(hr)) {
    VLOG(1) << "Create failed: " << PrintHr(hr);
    return;
  }

  hr = buffer->put_Length(static_cast<UINT32>(data.size()));
  if (FAILED(hr)) {
    VLOG(1) << "put_Length failed: " << PrintHr(hr);
    return;
  }

  uint8_t* p_buffer_data = nullptr;
  hr = GetPointerToBufferData(buffer.get(), &p_buffer_data);
  if (FAILED(hr))
    return;

  std::copy(data.begin(), data.end(), p_buffer_data);

  hr = port->handle->SendBuffer(buffer.get());
  if (FAILED(hr)) {
    VLOG(1) << "SendBuffer failed: " << PrintHr(hr);
    return;
  }
}

void MidiManagerWinrt::OnPortManagerReady() {
  DCHECK(com_thread_checker_->CalledOnValidThread());
  DCHECK(port_manager_ready_count_ < 2);

  if (++port_manager_ready_count_ == 2)
    CompleteInitialization(Result::OK);
}

}  // namespace midi
}  // namespace media