Remove LazyInstance usage from media/

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"
 
 #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 midi {
@@ skipping 19 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|.
+// dependencies.
 class CombaseFunctions {
  public:
   CombaseFunctions() = default;
 
   ~CombaseFunctions() {
     if (combase_dll_)
       ::FreeLibrary(combase_dll_);
   }
 
   bool LoadFunctions() {
@@ skipping 52 matching lines @@
 
  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;
+static CombaseFunctions* GetCombaseFunctions() {

[Mark Mentovai, 2017/01/31 21:33:56]

No need for “static” in an unnamed namespace.

+  static CombaseFunctions* functions = new CombaseFunctions();
+  return functions;
+}
 
 // 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);
+    GetCombaseFunctions()->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(
+    HRESULT hr = GetCombaseFunctions()->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(
+  HRESULT hr = GetCombaseFunctions()->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);
+      GetCombaseFunctions()->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)) {
@@ skipping 745 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()) {
+  if (!GetCombaseFunctions()->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));
@@ skipping 72 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);
 }
 
 }  // namespace midi