Fix a crasher in the GPU process caused by the DXVA code attempting to create an instance of the Vi…

content/common/gpu/media/dxva_video_decode_accelerator.cc

 // Copyright (c) 2012 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 "content/common/gpu/media/dxva_video_decode_accelerator.h"
 
 #if !defined(OS_WIN)
 #error This file should only be built on Windows.
 #endif   // !defined(OS_WIN)
 
@@ skipping 82 matching lines @@
             0x88753b26, 0x5b24, 0x49bd, 0xb2, 0xe7, 0xc, 0x44, 0x5c, 0x78,
             0xc9, 0x82);
 
 // MF_XVP_PLAYBACK_MODE
 // Data type: UINT32 (treat as BOOL)
 // If this attribute is TRUE, the video processor will run in playback mode
 // where it allows callers to allocate output samples and allows last frame
 // regeneration (repaint).
 DEFINE_GUID(MF_XVP_PLAYBACK_MODE, 0x3c5d293f, 0xad67, 0x4e29, 0xaf, 0x12,
             0xcf, 0x3e, 0x23, 0x8a, 0xcc, 0xe9);
-}
+
+}  // namespace
 
 namespace content {
 
 static const media::VideoCodecProfile kSupportedProfiles[] = {
   media::H264PROFILE_BASELINE,
   media::H264PROFILE_MAIN,
   media::H264PROFILE_HIGH,
   media::VP8PROFILE_ANY,
   media::VP9PROFILE_ANY
 };
@@ skipping 120 matching lines @@
   base::SharedMemory shm(bitstream_buffer.handle(), true);
   RETURN_ON_FAILURE(shm.Map(bitstream_buffer.size()),
                     "Failed in base::SharedMemory::Map", NULL);
 
   return CreateInputSample(reinterpret_cast<const uint8*>(shm.memory()),
                            bitstream_buffer.size(),
                            stream_size,
                            alignment);
 }
 
+// Helper function to create a COM object instance from a DLL. The alternative
+// is to use the CoCreateInstance API which requires the COM apartment to be
+// initialized which is not the case on the GPU main thread. We want to avoid
+// initializing COM as it may have sideeffects.
+HRESULT CreateCOMObjectFromDll(HMODULE dll, const CLSID& clsid, const IID& iid,
+                               void** object) {
+  if (!dll || !object)
+    return E_INVALIDARG;
+
+  using GetClassObject = HRESULT (WINAPI*)(
+      const CLSID& clsid, const IID& iid, void** object);
+
+  GetClassObject get_class_object = reinterpret_cast<GetClassObject>(
+      GetProcAddress(dll, "DllGetClassObject"));
+  RETURN_ON_FAILURE(
+      get_class_object, "Failed to get DllGetClassObject pointer", false);
+
+  base::win::ScopedComPtr<IClassFactory> factory;
+  HRESULT hr = get_class_object(
+      clsid,
+      __uuidof(IClassFactory),
+      factory.ReceiveVoid());
+  RETURN_ON_HR_FAILURE(hr, "DllGetClassObject failed", false);
+
+  hr = factory->CreateInstance(NULL, iid, object);
+  return hr;
+}
+
 // Maintains information about a DXVA picture buffer, i.e. whether it is
 // available for rendering, the texture information, etc.
 struct DXVAVideoDecodeAccelerator::DXVAPictureBuffer {
  public:
   static linked_ptr<DXVAPictureBuffer> Create(
       const DXVAVideoDecodeAccelerator& decoder,
       const media::PictureBuffer& buffer,
       EGLConfig egl_config);
   ~DXVAPictureBuffer();
 
@@ skipping 466 matching lines @@
   RETURN_ON_HR_FAILURE(hr, "Failed to reset device", false);
 
   D3D11_QUERY_DESC query_desc;
   query_desc.Query = D3D11_QUERY_EVENT;
   query_desc.MiscFlags = 0;
   hr = d3d11_device_->CreateQuery(
       &query_desc,
       d3d11_query_.Receive());
   RETURN_ON_HR_FAILURE(hr, "Failed to create DX11 device query", false);
 
-  hr = ::CoCreateInstance(
+  HMODULE video_processor_dll = ::LoadLibrary(L"msvproc.dll");
+  RETURN_ON_FAILURE(video_processor_dll, "Failed to load video processor",
+                    false);
+
+  hr = CreateCOMObjectFromDll(
+      video_processor_dll,
       CLSID_VideoProcessorMFT,
-      NULL,
-      CLSCTX_INPROC_SERVER,
-      IID_IMFTransform,
-      reinterpret_cast<void**>(video_format_converter_mft_.Receive()));
-
+      __uuidof(IMFTransform),
+      video_format_converter_mft_.ReceiveVoid());
   if (FAILED(hr)) {
     base::debug::Alias(&hr);
     // TODO(ananta)
     // Remove this CHECK when the change to use DX11 for H/W decoding
     // stablizes.
     CHECK(false);
   }
+
   RETURN_ON_HR_FAILURE(hr, "Failed to create video format converter", false);
   return true;
 }
 
 void DXVAVideoDecodeAccelerator::Decode(
     const media::BitstreamBuffer& bitstream_buffer) {
   DCHECK(main_thread_task_runner_->BelongsToCurrentThread());
 
   State state = GetState();
   RETURN_AND_NOTIFY_ON_FAILURE((state == kNormal || state == kStopped ||
@@ skipping 182 matching lines @@
     // Use 1088 to account for 16x16 macroblocks.
     profile.max_resolution.SetSize(1920, 1088);
     profiles.push_back(profile);
   }
   return profiles;
 }
 
 bool DXVAVideoDecodeAccelerator::InitDecoder(media::VideoCodecProfile profile) {
   HMODULE decoder_dll = NULL;
 
+  CLSID clsid = {};
+
   // Profile must fall within the valid range for one of the supported codecs.
   if (profile >= media::H264PROFILE_MIN && profile <= media::H264PROFILE_MAX) {
     // We mimic the steps CoCreateInstance uses to instantiate the object. This
     // was previously done because it failed inside the sandbox, and now is done
     // as a more minimal approach to avoid other side-effects CCI might have (as
     // we are still in a reduced sandbox).
     decoder_dll = ::LoadLibrary(L"msmpeg2vdec.dll");
     RETURN_ON_FAILURE(decoder_dll,
                       "msmpeg2vdec.dll required for decoding is not loaded",
                       false);
 
     // Check version of DLL, version 6.7.7140 is blacklisted due to high crash
     // rates in browsers loading that DLL. If that is the version installed we
     // fall back to software decoding. See crbug/403440.
     FileVersionInfo* version_info =
         FileVersionInfo::CreateFileVersionInfoForModule(decoder_dll);
     RETURN_ON_FAILURE(version_info,
                       "unable to get version of msmpeg2vdec.dll",
                       false);
     base::string16 file_version = version_info->file_version();
     RETURN_ON_FAILURE(file_version.find(L"6.1.7140") == base::string16::npos,
                       "blacklisted version of msmpeg2vdec.dll 6.7.7140",
                       false);
     codec_ = media::kCodecH264;
+    clsid = __uuidof(CMSH264DecoderMFT);
   } else if (profile == media::VP8PROFILE_ANY ||
              profile == media::VP9PROFILE_ANY) {
     int program_files_key = base::DIR_PROGRAM_FILES;
     if (base::win::OSInfo::GetInstance()->wow64_status() ==
         base::win::OSInfo::WOW64_ENABLED) {
       program_files_key = base::DIR_PROGRAM_FILES6432;
     }
 
     base::FilePath dll_path;
     RETURN_ON_FAILURE(PathService::Get(program_files_key, &dll_path),
         "failed to get path for Program Files", false);
 
     dll_path = dll_path.Append(kVPXDecoderDLLPath);
     if (profile == media::VP8PROFILE_ANY) {
       codec_ = media::kCodecVP8;
       dll_path = dll_path.Append(kVP8DecoderDLLName);
+      clsid = CLSID_WebmMfVp8Dec;
     } else {
       codec_ = media::kCodecVP9;
       dll_path = dll_path.Append(kVP9DecoderDLLName);
+      clsid = CLSID_WebmMfVp9Dec;
     }
     decoder_dll = ::LoadLibraryEx(dll_path.value().data(), NULL,
         LOAD_WITH_ALTERED_SEARCH_PATH);
     RETURN_ON_FAILURE(decoder_dll, "vpx decoder dll is not loaded", false);
   } else {
     RETURN_ON_FAILURE(false, "Unsupported codec.", false);
   }
 
-  typedef HRESULT(WINAPI * GetClassObject)(
-      const CLSID & clsid, const IID & iid, void * *object);
-
-  GetClassObject get_class_object = reinterpret_cast<GetClassObject>(
-      GetProcAddress(decoder_dll, "DllGetClassObject"));
-  RETURN_ON_FAILURE(
-      get_class_object, "Failed to get DllGetClassObject pointer", false);
-
-  base::win::ScopedComPtr<IClassFactory> factory;
-  HRESULT hr;
-  if (codec_ == media::kCodecH264) {
-    hr  = get_class_object(__uuidof(CMSH264DecoderMFT),
-                           __uuidof(IClassFactory),
-                           reinterpret_cast<void**>(factory.Receive()));
-  } else if (codec_ == media::kCodecVP8) {
-    hr  = get_class_object(CLSID_WebmMfVp8Dec,
-                           __uuidof(IClassFactory),
-                           reinterpret_cast<void**>(factory.Receive()));
-  } else if (codec_ == media::kCodecVP9) {
-    hr  = get_class_object(CLSID_WebmMfVp9Dec,
-                           __uuidof(IClassFactory),
-                           reinterpret_cast<void**>(factory.Receive()));
-  } else {
-    RETURN_ON_FAILURE(false, "Unsupported codec.", false);
-  }
-  RETURN_ON_HR_FAILURE(hr, "DllGetClassObject for decoder failed", false);
-
-  hr = factory->CreateInstance(NULL,
-                               __uuidof(IMFTransform),
-                               reinterpret_cast<void**>(decoder_.Receive()));
+  HRESULT hr = CreateCOMObjectFromDll(decoder_dll,
+                                      clsid,
+                                      __uuidof(IMFTransform),
+                                      decoder_.ReceiveVoid());
   RETURN_ON_HR_FAILURE(hr, "Failed to create decoder instance", false);
 
   RETURN_ON_FAILURE(CheckDecoderDxvaSupport(),
                     "Failed to check decoder DXVA support", false);
 
   ULONG_PTR device_manager_to_use = NULL;
   if (use_dx11_) {
     CHECK(create_dxgi_device_manager_);
     RETURN_AND_NOTIFY_ON_FAILURE(CreateDX11DevManager(),
                                  "Failed to initialize DX11 device and manager",
@@ skipping 1150 matching lines @@
     D3DSURFACE_DESC surface_desc;
     hr = surface->GetDesc(&surface_desc);
     RETURN_ON_HR_FAILURE(hr, "Failed to get surface description", false);
     *width = surface_desc.Width;
     *height = surface_desc.Height;
   }
   return true;
 }
 
 }  // namespace content