3 files changed, 56 insertions, 13 deletions

diff --git a/src/client/linux/handler/exception_handler.cc b/src/client/linux/handler/exception_handler.cc
index 7cad7756..3e2d1962 100644
--- a/src/client/linux/handler/exception_handler.cc
+++ b/src/client/linux/handler/exception_handler.cc
@@ -91,6 +91,7 @@
 #include "common/linux/linux_libc_support.h"
 #include "common/memory.h"
 #include "client/linux/log/log.h"
+#include "client/linux/microdump_writer/microdump_writer.h"
 #include "client/linux/minidump_writer/linux_dumper.h"
 #include "client/linux/minidump_writer/minidump_writer.h"
 #include "common/linux/eintr_wrapper.h"
@@ -210,7 +211,8 @@ ExceptionHandler::ExceptionHandler(const MinidumpDescriptor& descriptor,
   if (server_fd >= 0)
     crash_generation_client_.reset(CrashGenerationClient::TryCreate(server_fd));
 
-  if (!IsOutOfProcess() && !minidump_descriptor_.IsFD())
+  if (!IsOutOfProcess() && !minidump_descriptor_.IsFD() &&
+      !minidump_descriptor_.IsMicrodumpOnConsole())
     minidump_descriptor_.UpdatePath();
 
   pthread_mutex_lock(&g_handler_stack_mutex_);
@@ -548,6 +550,12 @@ void ExceptionHandler::WaitForContinueSignal() {
 // Runs on the cloned process.
 bool ExceptionHandler::DoDump(pid_t crashing_process, const void* context,
                               size_t context_size) {
+  if (minidump_descriptor_.IsMicrodumpOnConsole()) {
+    return google_breakpad::WriteMicrodump(crashing_process,
+                                           context,
+                                           context_size,
+                                           mapping_list_);
+  }
   if (minidump_descriptor_.IsFD()) {
     return google_breakpad::WriteMinidump(minidump_descriptor_.fd(),
                                           minidump_descriptor_.size_limit(),
@@ -583,7 +591,8 @@ bool ExceptionHandler::WriteMinidump(const string& dump_path,
 __attribute__((optimize("no-omit-frame-pointer")))
 #endif
 bool ExceptionHandler::WriteMinidump() {
-  if (!IsOutOfProcess() && !minidump_descriptor_.IsFD()) {
+  if (!IsOutOfProcess() && !minidump_descriptor_.IsFD() &&
+      !minidump_descriptor_.IsMicrodumpOnConsole()) {
     // Update the path of the minidump so that this can be called multiple times
     // and new files are created for each minidump.  This is done before the
     // generation happens, as clients may want to access the MinidumpDescriptor
diff --git a/src/client/linux/handler/minidump_descriptor.cc b/src/client/linux/handler/minidump_descriptor.cc
index c4618adc..029f8926 100644
--- a/src/client/linux/handler/minidump_descriptor.cc
+++ b/src/client/linux/handler/minidump_descriptor.cc
@@ -35,8 +35,12 @@
 
 namespace google_breakpad {
 
+//static
+const MinidumpDescriptor::MicrodumpOnConsole kMicrodumpOnConsole = {};
+
 MinidumpDescriptor::MinidumpDescriptor(const MinidumpDescriptor& descriptor)
-    : fd_(descriptor.fd_),
+    : mode_(descriptor.mode_),
+      fd_(descriptor.fd_),
       directory_(descriptor.directory_),
       c_path_(NULL),
       size_limit_(descriptor.size_limit_) {
@@ -50,6 +54,7 @@ MinidumpDescriptor& MinidumpDescriptor::operator=(
     const MinidumpDescriptor& descriptor) {
   assert(descriptor.path_.empty());
 
+  mode_ = descriptor.mode_;
   fd_ = descriptor.fd_;
   directory_ = descriptor.directory_;
   path_.clear();
@@ -63,7 +68,7 @@ MinidumpDescriptor& MinidumpDescriptor::operator=(
 }
 
 void MinidumpDescriptor::UpdatePath() {
-  assert(fd_ == -1 && !directory_.empty());
+  assert(mode_ == kWriteMinidumpToFile && !directory_.empty());
 
   GUID guid;
   char guid_str[kGUIDStringLength + 1];
@@ -72,7 +77,7 @@ void MinidumpDescriptor::UpdatePath() {
   }
 
   path_.clear();
-  path_ = directory_ + "/" + guid_str + ".dmp";  
+  path_ = directory_ + "/" + guid_str + ".dmp";
   c_path_ = path_.c_str();
 }
 
diff --git a/src/client/linux/handler/minidump_descriptor.h b/src/client/linux/handler/minidump_descriptor.h
index 9ffe622b..ed656cee 100644
--- a/src/client/linux/handler/minidump_descriptor.h
+++ b/src/client/linux/handler/minidump_descriptor.h
@@ -37,18 +37,25 @@
 
 #include "common/using_std_string.h"
 
-// The MinidumpDescriptor describes how to access a minidump: it can contain
-// either a file descriptor or a path.
-// Note that when using files, it is created with the path to a directory.
-// The actual path where the minidump is generated is created by this class.
+// This class describes how a crash dump should be generated, either:
+// - Writing a full minidump to a file in a given directory (the actual path,
+//   inside the directory, is determined by this class).
+// - Writing a full minidump to a given fd.
+// - Writing a reduced microdump to the console (logcat on Android).
 namespace google_breakpad {
 
 class MinidumpDescriptor {
  public:
-  MinidumpDescriptor() : fd_(-1), size_limit_(-1) {}
+  struct MicrodumpOnConsole {};
+  static const MicrodumpOnConsole kMicrodumpOnConsole;
+
+  MinidumpDescriptor() : mode_(kUninitialized),
+                         fd_(-1),
+                         size_limit_(-1) {}
 
   explicit MinidumpDescriptor(const string& directory)
-      : fd_(-1),
+      : mode_(kWriteMinidumpToFile),
+        fd_(-1),
         directory_(directory),
         c_path_(NULL),
         size_limit_(-1) {
@@ -56,16 +63,24 @@ class MinidumpDescriptor {
   }
 
   explicit MinidumpDescriptor(int fd)
-      : fd_(fd),
+      : mode_(kWriteMinidumpToFd),
+        fd_(fd),
         c_path_(NULL),
         size_limit_(-1) {
     assert(fd != -1);
   }
 
+  explicit MinidumpDescriptor(const MicrodumpOnConsole&)
+      : mode_(kWriteMicrodumpToConsole),
+        fd_(-1),
+        size_limit_(-1) {}
+
   explicit MinidumpDescriptor(const MinidumpDescriptor& descriptor);
   MinidumpDescriptor& operator=(const MinidumpDescriptor& descriptor);
 
-  bool IsFD() const { return fd_ != -1; }
+  static MinidumpDescriptor getMicrodumpDescriptor();
+
+  bool IsFD() const { return mode_ == kWriteMinidumpToFd; }
 
   int fd() const { return fd_; }
 
@@ -73,6 +88,10 @@ class MinidumpDescriptor {
 
   const char* path() const { return c_path_; }
 
+  bool IsMicrodumpOnConsole() const {
+    return mode_ == kWriteMicrodumpToConsole;
+  }
+
   // Updates the path so it is unique.
   // Should be called from a normal context: this methods uses the heap.
   void UpdatePath();
@@ -81,6 +100,16 @@ class MinidumpDescriptor {
   void set_size_limit(off_t limit) { size_limit_ = limit; }
 
  private:
+  enum DumpMode {
+    kUninitialized = 0,
+    kWriteMinidumpToFile,
+    kWriteMinidumpToFd,
+    kWriteMicrodumpToConsole
+  };
+
+  // Specifies the dump mode (see DumpMode).
+  DumpMode mode_;
+
   // The file descriptor where the minidump is generated.
   int fd_;