Crash component: adds API for clients to handle the crash minidump.

components/crash/app/crash_reporter_client.h

 // Copyright 2013 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.
 
 #ifndef COMPONENTS_CRASH_APP_CRASH_REPORTER_CLIENT_H_
 #define COMPONENTS_CRASH_APP_CRASH_REPORTER_CLIENT_H_
 
 #include <string>
 
 #include "base/strings/string16.h"
@@ skipping 85 matching lines @@
   virtual void RecordCrashDumpAttempt(bool is_real_crash);
 #endif
 
 #if defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_IOS)
   // Returns a textual description of the product type and version to include
   // in the crash report. Neither out parameter should be set to NULL.
   virtual void GetProductNameAndVersion(const char** product_name,
                                         const char** version);
 
   virtual base::FilePath GetReporterLogFilename();
+
+  // Custom crash minidump handler after the minidump is generated.
+  // Returns true if the minidump is handled (client); otherwise, return false
+  // to fallback to default handler.
+  virtual bool HandleCrashDump(const char* crashdump_filename);

[Robert Sesek, 2014/11/03 22:08:58]

This should be a base::FilePath.

[gunsch, 2014/11/03 22:11:41]

Hmm, I thought the crash code went to pretty great lengths to not allocate
anything new during crash-handling time, even things as simple as std::string.
What makes FilePath okay in this case?

[Robert Sesek, 2014/11/03 22:19:02]

In the crashed context that's definitely true. Is this code going to run in a
crashed context? Are you going to enforce the non-allocating requirement on API
consumers?

[gunsch, 2014/11/03 23:40:15]

The code path I'm invoking this from in breakpad_linux.cc runs in a compromised
context (CrashDone --> HandleCrashDump -->
CrashReporterClient::HandleCrashDump). I don't feel like there would be a way to
allow a content embedder to handle the crash dump outside of a crashed context.

I can document this fact (added), but I can't really "enforce" the requirement,
no?

[Robert Sesek, 2014/11/05 18:37:23]

It depends on the crash type. A renderer crash is handled by the browser, for
example.
You can't really enforce it, no. At some point, the allocator object in
HandleCrashDump may be a good parameter to pass, but it's not required yet.

 #endif
 
   // The location where minidump files should be written. Returns true if
   // |crash_dir| was set.
   virtual bool GetCrashDumpLocation(base::FilePath* crash_dir);
 
   // Register all of the potential crash keys that can be sent to the crash
   // reporting server. Returns the size of the union of all keys.
   virtual size_t RegisterCrashKeys();
 
@@ skipping 19 matching lines @@
   virtual void InstallAdditionalFilters(BreakpadRef breakpad);
 #endif
 
   // Returns true if breakpad should run in the given process type.
   virtual bool EnableBreakpadForProcess(const std::string& process_type);
 };
 
 }  // namespace crash_reporter
 
 #endif  // COMPONENTS_CRASH_APP_CRASH_REPORTER_CLIENT_H_