Introduce microdump writer class.

Microdumps are a very lightweight variant of minidumps. They are meant
to dump a minimal crash report on the system log (logcat on Android),
containing only the state of the crashing thread.
This is to deal with cases where the user has opted out from crash
uploading but we still want to generate meaningful information on the
device to pull a stacktrace for development purposes.
Conversely to conventional stack traces (e.g. the one generated by
Android's debuggerd or Chromium's base::stacktrace) microdumps do NOT
require unwind tables to be present in the target binary. This allows
to save precious binary size (~1.5 MB for Chrome on Arm, ~10 MB on
arm64).
More information and design doc on crbug.com/410294

BUG=chromium:410294

git-svn-id: http://google-breakpad.googlecode.com/svn/trunk@1398 4c0a9323-5329-0410-9bdc-e9ce6186880e

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_;