Update Crashpad to f487da4ff2c47a129e2f8f3a7e0c769b54e4585f

third_party/crashpad/crashpad/client/crashpad_client_win.cc

 // Copyright 2015 The Crashpad Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
@@ skipping 24 matching lines @@
 #include "util/win/capture_context.h"
 #include "util/win/command_line.h"
 #include "util/win/critical_section_with_debug_info.h"
 #include "util/win/get_function.h"
 #include "util/win/handle.h"
 #include "util/win/initial_client_data.h"
 #include "util/win/nt_internals.h"
 #include "util/win/ntstatus_logging.h"
 #include "util/win/process_info.h"
 #include "util/win/registration_protocol_win.h"
+#include "util/win/safe_terminate_process.h"
 #include "util/win/scoped_process_suspend.h"
 #include "util/win/termination_codes.h"
 #include "util/win/xp_compat.h"
 
 namespace crashpad {
 
 namespace {
 
 // This handle is never closed. This is used to signal to the server that a dump
 // should be taken in the event of a crash.
@@ skipping 64 matching lines @@
   LONG status = __asan_unhandled_exception_filter(exception_pointers);
   if (status != EXCEPTION_CONTINUE_SEARCH)
     return status;
 #endif
 
   if (BlockUntilHandlerStartedOrFailed() == StartupState::kFailed) {
     // If we know for certain that the handler has failed to start, then abort
     // here, rather than trying to signal to a handler that will never arrive,
     // and then sleeping unnecessarily.
     LOG(ERROR) << "crash server failed to launch, self-terminating";
-    TerminateProcess(GetCurrentProcess(), kTerminationCodeCrashNoDump);
+    SafeTerminateProcess(GetCurrentProcess(), kTerminationCodeCrashNoDump);
     return EXCEPTION_CONTINUE_SEARCH;
   }
 
   // Otherwise, we know the handler startup has succeeded, and we can continue.
 
   // Tracks whether a thread has already entered UnhandledExceptionHandler.
   static base::subtle::AtomicWord have_crashed;
 
   // This is a per-process handler. While this handler is being invoked, other
   // threads are still executing as usual, so multiple threads could enter at
@@ skipping 24 matching lines @@
   // Time to wait for the handler to create a dump.
   const DWORD kMillisecondsUntilTerminate = 60 * 1000;
 
   // Sleep for a while to allow it to process us. Eventually, we terminate
   // ourselves in case the crash server is gone, so that we don't leave zombies
   // around. This would ideally never happen.
   Sleep(kMillisecondsUntilTerminate);
 
   LOG(ERROR) << "crash server did not respond, self-terminating";
 
-  TerminateProcess(GetCurrentProcess(), kTerminationCodeCrashNoDump);
+  SafeTerminateProcess(GetCurrentProcess(), kTerminationCodeCrashNoDump);
 
   return EXCEPTION_CONTINUE_SEARCH;
 }
 
 void HandleAbortSignal(int signum) {
   DCHECK_EQ(signum, SIGABRT);
 
   CONTEXT context;
   CaptureContext(&context);
 
@@ skipping 541 matching lines @@
     // here, as we would otherwise wait indefinitely for the
     // g_non_crash_dump_done event that would never be signalled.
     LOG(ERROR) << "crash server failed to launch, no dump captured";
     return;
   }
 
   // In the non-crashing case, we aren't concerned about avoiding calls into
   // Win32 APIs, so just use regular locking here in case of multiple threads
   // calling this function. If a crash occurs while we're in here, the worst
   // that can happen is that the server captures a partial dump for this path
-  // because on the other thread gathering a crash dump, it TerminateProcess()d,
-  // causing this one to abort.
+  // because another thread’s crash processing finished and the process was
+  // terminated before this thread’s non-crash processing could be completed.
   base::AutoLock lock(*g_non_crash_dump_lock);
 
   // Create a fake EXCEPTION_POINTERS to give the handler something to work
   // with.
   EXCEPTION_POINTERS exception_pointers = {};
 
   // This is logically const, but EXCEPTION_POINTERS does not declare it as
   // const, so we have to cast that away from the argument.
   exception_pointers.ContextRecord = const_cast<CONTEXT*>(&context);
 
@@ skipping 22 matching lines @@
   PLOG_IF(ERROR, !set_event_result) << "SetEvent";
 
   DWORD wfso_result = WaitForSingleObject(g_non_crash_dump_done, INFINITE);
   PLOG_IF(ERROR, wfso_result != WAIT_OBJECT_0) << "WaitForSingleObject";
 }
 
 // static
 void CrashpadClient::DumpAndCrash(EXCEPTION_POINTERS* exception_pointers) {
   if (g_signal_exception == INVALID_HANDLE_VALUE) {
     LOG(ERROR) << "not connected";
-    TerminateProcess(GetCurrentProcess(),
-                     kTerminationCodeNotConnectedToHandler);
+    SafeTerminateProcess(GetCurrentProcess(),
+                         kTerminationCodeNotConnectedToHandler);
     return;
   }
 
   // We don't need to check for handler startup here, as
   // UnhandledExceptionHandler() necessarily does that.
 
   UnhandledExceptionHandler(exception_pointers);
 }
 
 bool CrashpadClient::DumpAndCrashTargetProcess(HANDLE process,
@@ skipping 233 matching lines @@
   status = NtClose(injected_thread);
   if (!NT_SUCCESS(status)) {
     NTSTATUS_LOG(ERROR, status) << "NtClose";
     result = false;
   }
 
   return result;
 }
 
 }  // namespace crashpad