win: Implement CRASHPAD_SIMULATE_CRASH()

util/win/exception_handler_server.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 95 matching lines @@
              WinVMAddress exception_information_address,
              WAITORTIMERCALLBACK dump_request_callback,
              WAITORTIMERCALLBACK process_end_callback)
       : dump_request_thread_pool_wait_(INVALID_HANDLE_VALUE),
         process_end_thread_pool_wait_(INVALID_HANDLE_VALUE),
         lock_(),
         port_(port),
         delegate_(delegate),
         dump_requested_event_(
             CreateEvent(nullptr, false /* auto reset */, false, nullptr)),
+        dump_completed_event_(
+            CreateEvent(nullptr, false /* auto reset */, false, nullptr)),
         process_(process.Pass()),
         exception_information_address_(exception_information_address) {
     RegisterThreadPoolWaits(dump_request_callback, process_end_callback);
   }
 
   ~ClientData() {
     // It is important that this only access the threadpool waits (it's called
     // from the main thread) until the waits are unregistered, to ensure that
     // any outstanding callbacks are complete.
     UnregisterThreadPoolWaits();
   }
 
   base::Lock* lock() { return &lock_; }
   HANDLE port() const { return port_; }
   ExceptionHandlerServer::Delegate* delegate() const { return delegate_; }
   HANDLE dump_requested_event() const { return dump_requested_event_.get(); }
+  HANDLE dump_completed_event() const { return dump_completed_event_.get(); }
   WinVMAddress exception_information_address() const {
     return exception_information_address_;
   }
   HANDLE process() const { return process_.get(); }
 
  private:
   void RegisterThreadPoolWaits(WAITORTIMERCALLBACK dump_request_callback,
                                WAITORTIMERCALLBACK process_end_callback) {
     if (!RegisterWaitForSingleObject(&dump_request_thread_pool_wait_,
                                      dump_requested_event_.get(),
@@ skipping 26 matching lines @@
 
   // These are only accessed on the main thread.
   HANDLE dump_request_thread_pool_wait_;
   HANDLE process_end_thread_pool_wait_;
 
   base::Lock lock_;
   // Access to these fields must be guarded by lock_.
   HANDLE port_;  // weak
   ExceptionHandlerServer::Delegate* delegate_;  // weak
   ScopedKernelHANDLE dump_requested_event_;
+  ScopedKernelHANDLE dump_completed_event_;
   ScopedKernelHANDLE process_;
   WinVMAddress exception_information_address_;
 
   DISALLOW_COPY_AND_ASSIGN(ClientData);
 };
 
 }  // namespace internal
 
 ExceptionHandlerServer::Delegate::~Delegate() {
 }
@@ skipping 184 matching lines @@
                                  &OnDumpEvent,
                                  &OnProcessEnd);
     service_context.clients()->insert(client);
   }
 
   // Duplicate the events back to the client so they can request a dump.
   ServerToClientMessage response;
   response.registration.request_report_event =
       base::checked_cast<uint32_t>(reinterpret_cast<uintptr_t>(
           DuplicateEvent(client->process(), client->dump_requested_event())));
+  response.registration.report_completed_event =
+      base::checked_cast<uint32_t>(reinterpret_cast<uintptr_t>(
+          DuplicateEvent(client->process(), client->dump_completed_event())));
 
   if (!LoggingWriteFile(service_context.pipe(), &response, sizeof(response)))
     return false;
 
   return false;
 }
 
 // static
 DWORD __stdcall ExceptionHandlerServer::PipeServiceProc(void* ctx) {
   internal::PipeServiceContext* service_context =
@@ skipping 15 matching lines @@
   return 0;
 }
 
 // static
 void __stdcall ExceptionHandlerServer::OnDumpEvent(void* ctx, BOOLEAN) {
   // This function is executed on the thread pool.
   internal::ClientData* client = reinterpret_cast<internal::ClientData*>(ctx);
   base::AutoLock lock(*client->lock());
 
   // Capture the exception.
-  unsigned int exit_code = client->delegate()->ExceptionHandlerServerException(
+  client->delegate()->ExceptionHandlerServerException(
       client->process(), client->exception_information_address());
 
-  TerminateProcess(client->process(), exit_code);
+  // Release the client.
+  SetEvent(client->dump_completed_event());

[Mark Mentovai, 2015/09/23 20:00:52]

PLOG_IF this fails.

[scottmg, 2015/09/24 19:16:52]

Done.

 }
 
 // static
 void __stdcall ExceptionHandlerServer::OnProcessEnd(void* ctx, BOOLEAN) {
   // This function is executed on the thread pool.
   internal::ClientData* client = reinterpret_cast<internal::ClientData*>(ctx);
   base::AutoLock lock(*client->lock());
 
   // Post back to the main thread to have it delete this client record.
   PostQueuedCompletionStatus(client->port(), 0, ULONG_PTR(client), nullptr);
 }
 
 }  // namespace crashpad