[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/base_paths_win.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/debug/alias.h"
+#include "base/debug/dump_without_crashing.h"

[scottmg, 2016/12/08 17:18:32]

Instead of this, #include
"third_party/crashpad/crashpad/client/crashpad_client.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/process/process.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.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"
@@ skipping 131 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",
 };
 
+LONG CALLBACK VectoredCrashHandler(EXCEPTION_POINTERS* exception_pointers) {
+  // Try to get crashpad to handle this.

[scottmg, 2016/12/08 17:18:32]

Then, replace 188-190 with

  CrashpadClient::DumpAndCrash(exception_pointers);

+  UnhandledExceptionFilter(exception_pointers);
+  base::Process::Current().Terminate(1, true);
+  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 the process will
+// crash instead. See http://crbug.com/636158
+class ScopedExceptionCrasher {
+ public:
+  ScopedExceptionCrasher(bool handle_exception) {

[scottmg, 2016/12/08 17:18:32]

explicit

+    if (handle_exception)
+      handler_ = AddVectoredExceptionHandler(TRUE, &VectoredCrashHandler);
+  }
+
+  ~ScopedExceptionCrasher() {
+    if (handler_)
+      RemoveVectoredExceptionHandler(handler_);
+  }
+
+ private:
+  void* handler_ = nullptr;

[scottmg, 2016/12/08 17:18:32]

DISALLOW...

+};
+
 }  // 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 1542 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;
+  {
+    ScopedExceptionCrasher crasher(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);
+  {
+    ScopedExceptionCrasher crasher(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