Make Crashpad start asynchronous, and move back to chrome_elf

components/crash/content/app/crashpad_win.cc

 // Copyright 2015 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 "components/crash/content/app/crashpad.h"
 
 #include <memory>
 
 #include "base/debug/crash_logging.h"
 #include "base/environment.h"
@@ skipping 102 matching lines @@
       // chrome_switches.cc, below the kPrefetchArgument* constants. A constant
       // can't be used here because crashpad can't depend on Chrome.
       arguments.push_back("/prefetch:7");
     } else {
       base::FilePath exe_dir = exe_file.DirName();
       exe_file = exe_dir.Append(FILE_PATH_LITERAL("crashpad_handler.exe"));
     }
 
     g_crashpad_client.Get().StartHandler(
         exe_file, database_path, metrics_path, url, process_annotations,
-        arguments, false, false);
+        arguments, false, true);
 
     // If we're the browser, push the pipe name into the environment so child
     // processes can connect to it. If we inherited another crashpad_handler's
     // pipe name, we'll overwrite it here.
     env->SetVar(kPipeNameVar,

[Mark Mentovai, 2016/11/04 21:47:56]

I thought that we’d be able to stick the wait in the first call into a getter in
here that grabs the pipe to give to a child, but I see that this isn’t how we’re
organized, we just dump the pipe name into the environment as soon as we can.

[scottmg, 2016/11/04 22:13:42]

Yeah, we could make the call location of BlockUntilHandlerStarted() a get/set in
the environment, but I guess it amounts to about the same thing.

                 base::UTF16ToUTF8(g_crashpad_client.Get().GetHandlerIPCPipe()));
   } else {
     std::string pipe_name_utf8;
     if (env->GetVar(kPipeNameVar, &pipe_name_utf8)) {
       g_crashpad_client.Get().SetHandlerIPCPipe(
           base::UTF8ToUTF16(pipe_name_utf8));
     }
   }
 
   return database_path;
@@ skipping 44 matching lines @@
   VLOG(1) << "dumped for hang debugging";
   return 0;
 }
 
 MSVC_POP_WARNING()
 MSVC_ENABLE_OPTIMIZE()
 
 }  // namespace
 
 }  // namespace internal
+
+void BlockUntilHandlerStarted() {
+  if (!internal::g_crashpad_client.Get().WaitForHandlerStart()) {

[Mark Mentovai, 2016/11/04 21:47:56]

This isn’t valid unless StartHandler() returned true. There’s even a DCHECK()
that this will trip over.

[scottmg, 2016/11/04 22:13:41]

Ah good point, I was only considering the async part. I'm going to burn things
down rather than try to set bools and continue if the _synchronous_ part of
StartHandler() fails. That means that a simple call to CreateThread() very early
in the process lifetime failed, implying that the process is totally screwed, so
continuing probably isn't worthwhile. So I LOG(FATAL)d above at StartHandler(),
and noted the dependency in comments.

+    LOG(ERROR) << "Crashpad handler failed to start, crash reporting disabled";
+  }
+}
+
 }  // namespace crash_reporter
 
 extern "C" {
 
 // Crashes the process after generating a dump for the provided exception. Note
 // that the crash reporter should be initialized before calling this function
 // for it to do anything.
 // NOTE: This function is used by SyzyASAN to invoke a crash. If you change the
 // the name or signature of this function you will break SyzyASAN instrumented
 // releases of Chrome. Please contact syzygy-team@chromium.org before doing so!
@@ skipping 101 matching lines @@
 void __declspec(dllexport) __cdecl UnregisterNonABICompliantCodeRange(
     void* start) {
   ExceptionHandlerRecord* record =
       reinterpret_cast<ExceptionHandlerRecord*>(start);
 
   CHECK(RtlDeleteFunctionTable(&record->runtime_function));
 }
 #endif  // ARCH_CPU_X86_64
 
 }  // extern "C"