Add "use-winrt-midi-api" flag to enable WinRT WebMIDI backend

media/midi/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"
 
+// TODO(shaochuan): Remove this once clang supports uuid syntax in <robuffer.h>.
+// https://reviews.llvm.org/D23895

[Shao-Chuan Lee, 2016/09/01 09:48:20]

Definition in <robuffer.h> is using

[uuid(...)] struct IBufferByteAccess;

instead of

struct __declspec(uuid("...")) IBufferByteAccess;

and is not recognized by clang.

+namespace Windows {
+namespace Storage {
+namespace Streams {
+struct __declspec(uuid("905a0fef-bc53-11df-8c49-001e4fc686da"))
+    IBufferByteAccess;
+}
+}
+}
+
 #include <comdef.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/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 "base/win/windows_version.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;
@@ skipping 134 matching lines @@
   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;
 }
 
-template <typename T, HRESULT (T::*method)(HSTRING*)>
-std::string GetStringFromObjectMethod(T* obj) {
-  HSTRING result;
-  HRESULT hr = (obj->*method)(&result);
-  if (FAILED(hr)) {
-    VLOG(1) << "GetStringFromObjectMethod failed: " << PrintHr(hr);
-    return std::string();
-  }
-
+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(result, nullptr);
+      g_combase_functions.Get().WindowsGetStringRawBuffer(hstr, nullptr);
   if (buffer)
     return base::WideToUTF8(buffer);
   return std::string();
 }
 
 template <typename T>
 std::string GetIdString(T* obj) {
-  return GetStringFromObjectMethod<T, &T::get_Id>(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) {
-  return GetStringFromObjectMethod<T, &T::get_DeviceId>(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) {
-  return GetStringFromObjectMethod<IDeviceInformation,
-                                   &IDeviceInformation::get_Name>(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;
   }
@@ skipping 582 matching lines @@
 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() {
-  if (base::win::GetVersion() < base::win::VERSION_WIN10) {
-    VLOG(1) << "WinRT MIDI backend is only supported on Windows 10 or later.";
-    CompleteInitialization(Result::INITIALIZATION_ERROR);
-    return;
-  }
-
   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(
@@ skipping 107 matching lines @@
 }
 
 void MidiManagerWinrt::OnPortManagerReady() {
   DCHECK(com_thread_checker_->CalledOnValidThread());
   DCHECK(port_manager_ready_count_ < 2);
 
   if (++port_manager_ready_count_ == 2)
     CompleteInitialization(Result::OK);
 }
 
-MidiManager* MidiManager::Create() {
-  return new MidiManagerWinrt();
-}
-
 }  // namespace midi
 }  // namespace media