Moved exception_handler_test to the more aptly named exception_handler_death_...

src/client/windows/handler/exception_handler.cc

 // Copyright (c) 2006, Google Inc.
 // All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
@@ skipping 472 matching lines @@
 
   // Make up an exception record for the current thread and CPU context
   // to make it possible for the crash processor to classify these
   // as do regular crashes, and to make it humane for developers to
   // analyze them.
   EXCEPTION_RECORD exception_record = {};
   CONTEXT exception_context = {};
   EXCEPTION_POINTERS exception_ptrs = { &exception_record, &exception_context };
   RtlCaptureContext(&exception_context);
   exception_record.ExceptionCode = STATUS_NONCONTINUABLE_EXCEPTION;
-  
+
   // We store pointers to the the expression and function strings,
-  // and the line as exception parameters to make them easy to 
+  // and the line as exception parameters to make them easy to
   // access by the developer on the far side.
   exception_record.NumberParameters = 3;
-  exception_record.ExceptionInformation[0] = 
+  exception_record.ExceptionInformation[0] =
       reinterpret_cast<ULONG_PTR>(&assertion.expression);
   exception_record.ExceptionInformation[1] =
       reinterpret_cast<ULONG_PTR>(&assertion.file);
   exception_record.ExceptionInformation[2] = assertion.line;
 
   bool success = false;
   // In case of out-of-process dump generation, directly call
   // WriteMinidumpWithException since there is no separate thread running.
   if (current_handler->IsOutOfProcess()) {
     success = current_handler->WriteMinidumpWithException(
         GetCurrentThreadId(),
         &exception_ptrs,
         &assertion);
   } else {
-    success = current_handler->WriteMinidumpOnHandlerThread(&exception_ptrs, 
+    success = current_handler->WriteMinidumpOnHandlerThread(&exception_ptrs,
                                                             &assertion);
   }
 
   if (!success) {
     if (current_handler->previous_iph_) {
       // The handler didn't fully handle the exception.  Give it to the
       // previous invalid parameter handler.
       current_handler->previous_iph_(expression,
                                      function,
                                      file,
@@ skipping 137 matching lines @@
   // was called as a result of an exception, returning false will cause
   // HandleException to call any previous handler or return
   // EXCEPTION_CONTINUE_SEARCH on the exception thread, allowing it to appear
   // as though this handler were not present at all.
   if (filter_ && !filter_(callback_context_, exinfo, assertion)) {
     return false;
   }
 
   bool success = false;
   if (IsOutOfProcess()) {
-    // Use the EXCEPTION_POINTERS overload for RequestDump if
-    // both exinfo and assertion are NULL.
-    if (!assertion) {
-      success = crash_generation_client_->RequestDump(exinfo);
-    } else {
-      success = crash_generation_client_->RequestDump(assertion);
-    }
+    success = crash_generation_client_->RequestDump(exinfo, assertion);
   } else {
     if (minidump_write_dump_) {
       HANDLE dump_file = CreateFile(next_minidump_path_c_,
                                     GENERIC_WRITE,
                                     0,  // no sharing
                                     NULL,
                                     CREATE_NEW,  // fail if exists
                                     FILE_ATTRIBUTE_NORMAL,
                                     NULL);
       if (dump_file != INVALID_HANDLE_VALUE) {
         MINIDUMP_EXCEPTION_INFORMATION except_info;
         except_info.ThreadId = requesting_thread_id;
         except_info.ExceptionPointers = exinfo;
         except_info.ClientPointers = FALSE;
 
-        // Add an MDRawBreakpadInfo stream to the minidump, to provide additional
-        // information about the exception handler to the Breakpad processor.  The
-        // information will help the processor determine which threads are
-        // relevant.  The Breakpad processor does not require this information but
-        // can function better with Breakpad-generated dumps when it is present.
-        // The native debugger is not harmed by the presence of this information.
+        // Add an MDRawBreakpadInfo stream to the minidump, to provide
+        // additional information about the exception handler to the Breakpad
+        // processor. The information will help the processor determine which
+        // threads are relevant.  The Breakpad processor does not require this
+        // information but can function better with Breakpad-generated dumps
+        // when it is present. The native debugger is not harmed by the
+        // presence of this information.
         MDRawBreakpadInfo breakpad_info;
         breakpad_info.validity = MD_BREAKPAD_INFO_VALID_DUMP_THREAD_ID |
                                MD_BREAKPAD_INFO_VALID_REQUESTING_THREAD_ID;
         breakpad_info.dump_thread_id = GetCurrentThreadId();
         breakpad_info.requesting_thread_id = requesting_thread_id;
 
         // Leave room in user_stream_array for a possible assertion info stream.
         MINIDUMP_USER_STREAM user_stream_array[2];
         user_stream_array[0].Type = MD_BREAKPAD_INFO_STREAM;
         user_stream_array[0].BufferSize = sizeof(breakpad_info);
@@ skipping 50 matching lines @@
            dump_path_c_, next_minidump_id_c_);
 
   // remove when VC++7.1 is no longer supported
   minidump_path[MAX_PATH - 1] = L'\0';
 
   next_minidump_path_ = minidump_path;
   next_minidump_path_c_ = next_minidump_path_.c_str();
 }
 
 }  // namespace google_breakpad