[DXVAVDA] Add a vectored exception handler so a dump is reported on driver error.

media/gpu/dxva_video_decode_accelerator_win.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 "media/gpu/dxva_video_decode_accelerator_win.h"
 
 #include <memory>
 
 #if !defined(OS_WIN)
 #error This file should only be built on Windows.
 #endif  // !defined(OS_WIN)
 
 #include <codecapi.h>
 #include <dxgi1_2.h>
 #include <ks.h>
 #include <mfapi.h>
 #include <mferror.h>
 #include <ntverp.h>
 #include <stddef.h>
 #include <string.h>
 #include <wmcodecdsp.h>
 
+#include "base/atomicops.h"
 #include "base/base_paths_win.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/debug/alias.h"
+#include "base/debug/dump_without_crashing.h"
 #include "base/file_version_info.h"
 #include "base/files/file_path.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/shared_memory.h"
 #include "base/path_service.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
+#include "base/threading/thread_local_storage.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/trace_event/trace_event.h"
 #include "base/win/scoped_co_mem.h"
 #include "base/win/windows_version.h"
 #include "build/build_config.h"
 #include "gpu/command_buffer/service/gpu_preferences.h"
 #include "gpu/config/gpu_driver_bug_workarounds.h"
 #include "media/base/media_switches.h"
 #include "media/base/win/mf_helpers.h"
 #include "media/base/win/mf_initializer.h"
@@ skipping 129 matching lines @@
 // Legacy Intel GPUs (Second generation) which have trouble with resolutions
 // higher than 1920 x 1088
 static const DWORD g_IntelLegacyGPUList[] = {
     0x102, 0x106, 0x116, 0x126,
 };
 
 constexpr const wchar_t* const kMediaFoundationVideoDecoderDLLs[] = {
     L"mf.dll", L"mfplat.dll", L"msmpeg2vdec.dll",
 };
 
+// Vectored exception handlers are global to the entire process, so use TLS to
+// ensure only the thread with the ScopedExceptionCatcher dumps anything.
+base::ThreadLocalStorage::StaticSlot g_catcher_tls_slot = TLS_INITIALIZER;
+
+base::subtle::Atomic32 g_dump_count;
+
+LONG CALLBACK VectoredCrashHandler(EXCEPTION_POINTERS* exception_pointers) {
+  if (g_catcher_tls_slot.Get()) {
+    // Only dump first time to ensure we don't spend a lot of time doing this
+    // if the driver continually causes exceptions.
+    if (base::subtle::Barrier_AtomicIncrement(&g_dump_count, 1) == 1)
+      base::debug::DumpWithoutCrashing();
+  }
+  return EXCEPTION_CONTINUE_SEARCH;
+}
+
+// The MS VP9 MFT swallows driver exceptions and later hangs because it gets
+// into a weird state. Add a vectored exception handler so a dump will be
+// reported. See http://crbug.com/636158
+class ScopedExceptionCatcher {
+ public:
+  explicit ScopedExceptionCatcher(bool handle_exception) {
+    if (handle_exception) {
+      DCHECK(g_catcher_tls_slot.initialized());
+      g_catcher_tls_slot.Set(static_cast<void*>(this));
+      handler_ = AddVectoredExceptionHandler(1, &VectoredCrashHandler);
+    }
+  }
+
+  ~ScopedExceptionCatcher() {
+    if (handler_) {
+      g_catcher_tls_slot.Set(nullptr);
+      RemoveVectoredExceptionHandler(handler_);
+    }
+  }
+
+ private:
+  void* handler_ = nullptr;
+
+  DISALLOW_COPY_AND_ASSIGN(ScopedExceptionCatcher);
+};
+
 }  // namespace
 
 namespace media {
 
 static const VideoCodecProfile kSupportedProfiles[] = {
     H264PROFILE_BASELINE, H264PROFILE_MAIN,    H264PROFILE_HIGH,
     VP8PROFILE_ANY,       VP9PROFILE_PROFILE0, VP9PROFILE_PROFILE1,
     VP9PROFILE_PROFILE2,  VP9PROFILE_PROFILE3};
 
 CreateDXGIDeviceManager
@@ skipping 1028 matching lines @@
     profile.profile = supported_profile;
     profile.min_resolution.SetSize(min_resolution.first, min_resolution.second);
     profile.max_resolution.SetSize(max_resolution.first, max_resolution.second);
     profiles.push_back(profile);
   }
   return profiles;
 }
 
 // static
 void DXVAVideoDecodeAccelerator::PreSandboxInitialization() {
+  g_catcher_tls_slot.Initialize(nullptr);
   for (const wchar_t* mfdll : kMediaFoundationVideoDecoderDLLs)
     ::LoadLibrary(mfdll);
   ::LoadLibrary(L"dxva2.dll");
 
   if (base::win::GetVersion() > base::win::VERSION_WIN7) {
     LoadLibrary(L"msvproc.dll");
   } else {
 #if defined(ENABLE_DX11_FOR_WIN7)
     LoadLibrary(L"mshtmlmedia.dll");
 #endif
@@ skipping 494 matching lines @@
   DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread());
   // This function is also called from FlushInternal in a loop which could
   // result in the state transitioning to kStopped due to no decoded output.
   State state = GetState();
   RETURN_AND_NOTIFY_ON_FAILURE(
       (state == kNormal || state == kFlushing || state == kStopped),
       "DoDecode: not in normal/flushing/stopped state", ILLEGAL_STATE, );
 
   MFT_OUTPUT_DATA_BUFFER output_data_buffer = {0};
   DWORD status = 0;
-  HRESULT hr = decoder_->ProcessOutput(0,  // No flags
-                                       1,  // # of out streams to pull from
-                                       &output_data_buffer, &status);
+  HRESULT hr;
+  {
+    ScopedExceptionCatcher catcher(using_ms_vp9_mft_);
+    hr = decoder_->ProcessOutput(0,  // No flags
+                                 1,  // # of out streams to pull from
+                                 &output_data_buffer, &status);
+  }
   IMFCollection* events = output_data_buffer.pEvents;
   if (events != NULL) {
     DVLOG(1) << "Got events from ProcessOuput, but discarding";
     events->Release();
   }
   if (FAILED(hr)) {
     // A stream change needs further ProcessInput calls to get back decoder
     // output which is why we need to set the state to stopped.
     if (hr == MF_E_TRANSFORM_STREAM_CHANGE) {
       if (!SetDecoderOutputMediaType(MFVideoFormat_NV12) &&
@@ skipping 407 matching lines @@
     return;
   }
 
   gfx::ColorSpace color_space = config_change_detector_->current_color_space();
 
   if (!inputs_before_decode_) {
     TRACE_EVENT_ASYNC_BEGIN0("gpu", "DXVAVideoDecodeAccelerator.Decoding",
                              this);
   }
   inputs_before_decode_++;
-
-  hr = decoder_->ProcessInput(0, sample.get(), 0);
+  {
+    ScopedExceptionCatcher catcher(using_ms_vp9_mft_);
+    hr = decoder_->ProcessInput(0, sample.get(), 0);
+  }
   // As per msdn if the decoder returns MF_E_NOTACCEPTING then it means that it
   // has enough data to produce one or more output samples. In this case the
   // recommended options are to
   // 1. Generate new output by calling IMFTransform::ProcessOutput until it
   //    returns MF_E_TRANSFORM_NEED_MORE_INPUT.
   // 2. Flush the input data
   // We implement the first option, i.e to retrieve the output sample and then
   // process the input again. Failure in either of these steps is treated as a
   // decoder failure.
   if (hr == MF_E_NOTACCEPTING) {
@@ skipping 706 matching lines @@
       base::Bind(&DXVAVideoDecodeAccelerator::DecodePendingInputBuffers,
                  base::Unretained(this)));
 }
 
 uint32_t DXVAVideoDecodeAccelerator::GetTextureTarget() const {
   bool provide_nv12_textures = share_nv12_textures_ || copy_nv12_textures_;
   return provide_nv12_textures ? GL_TEXTURE_EXTERNAL_OES : GL_TEXTURE_2D;
 }
 
 }  // namespace media