Remove RuntimeObject.lib dependency in Windows 10 Web MIDI 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"
 
 #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 {
@@ skipping 15 matching lines @@
 };
 
 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;
 
-  HRESULT hr = GetActivationFactory(
-      WRL::Wrappers::HStringReference(runtime_class_id).Get(),
-      com_ptr.Receive());
+  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) << "GetActivationFactory failed: " << PrintHr(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();
   }
 
   // Note: empty HSTRINGs are represent as nullptr, and instantiating
   // std::string with nullptr (in base::WideToUTF8) is undefined behavior.
-  const base::char16* buffer = WindowsGetStringRawBuffer(result, nullptr);
+  const base::char16* buffer =
+      g_combase_functions.Get().WindowsGetStringRawBuffer(result, 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);
 }
 
@@ skipping 276 matching lines @@
   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;
 
-    WRL::Wrappers::HString dev_id_hstring;
-    HRESULT hr = dev_id_hstring.Set(base::UTF8ToWide(dev_id).c_str());
-    if (FAILED(hr)) {
-      VLOG(1) << "Set failed: " << PrintHr(hr);
+    ScopedHString dev_id_hstring(base::UTF8ToWide(dev_id).c_str());
+    if (!dev_id_hstring.is_valid())
       return;
-    }
 
     IAsyncOperation<RuntimeType*>* async_op;
 
-    hr = midi_port_statics_->FromIdAsync(dev_id_hstring.Get(), &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*>>(
@@ skipping 337 matching lines @@
       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();
 
-  port_manager_in_->StopWatcher();
-  port_manager_in_.reset();
-  port_manager_out_->StopWatcher();
-  port_manager_out_.reset();
+  if (port_manager_in_) {

[Shao-Chuan Lee, 2016/09/01 06:11:35]

Additional checks in case InitializeOnComThread() fails early.

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

[Shao-Chuan Lee, 2016/09/01 06:11:35]

ditto

+    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)) {
@@ skipping 42 matching lines @@
   if (++port_manager_ready_count_ == 2)
     CompleteInitialization(Result::OK);
 }
 
 MidiManager* MidiManager::Create() {
   return new MidiManagerWinrt();
 }
 
 }  // namespace midi
 }  // namespace media