[DXVAVDA] Dump without crashing on EXCEPTION_DEBUG_EVENT

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"
@@ skipping 143 matching lines @@
 };
 
 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;
+
 uint64_t GetCurrentQPC() {
   LARGE_INTEGER perf_counter_now = {};
   // Use raw QueryPerformanceCounter to avoid grabbing locks or allocating
   // memory in an exception handler;
   ::QueryPerformanceCounter(&perf_counter_now);
   return perf_counter_now.QuadPart;
 }
 
 // This is information about the last exception. Writing into it may be racy,
 // but that should be ok because the information is only used for debugging.
 DWORD g_last_exception_code;
 uint64_t g_last_exception_time;
 uint64_t g_last_process_output_time;
 HRESULT g_last_unhandled_error;
 
 LONG CALLBACK VectoredCrashHandler(EXCEPTION_POINTERS* exception_pointers) {
   if (g_catcher_tls_slot.Get()) {
     g_last_exception_code = exception_pointers->ExceptionRecord->ExceptionCode;
     g_last_exception_time = GetCurrentQPC();
+    if (exception_pointers->ExceptionRecord->ExceptionCode ==
+        EXCEPTION_DEBUG_EVENT) {
+      base::debug::Alias(&exception_pointers);
+      // 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 information about
 // the exception can be retrieved. See http://crbug.com/636158
 class ScopedExceptionCatcher {
  public:
   explicit ScopedExceptionCatcher(bool handle_exception) {
@@ skipping 2756 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