Add GPU fingerprint information to breakpad microdumps.

src/client/linux/handler/minidump_descriptor.h

 // Copyright (c) 2012 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 17 matching lines @@
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifndef CLIENT_LINUX_HANDLER_MINIDUMP_DESCRIPTOR_H_
 #define CLIENT_LINUX_HANDLER_MINIDUMP_DESCRIPTOR_H_
 
 #include <assert.h>
 #include <sys/types.h>
 
 #include <string>
 
+#include "client/linux/handler/microdump_extra_info.h"
 #include "common/using_std_string.h"
 
 // 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:
   struct MicrodumpOnConsole {};
   static const MicrodumpOnConsole kMicrodumpOnConsole;
 
-  MinidumpDescriptor() : mode_(kUninitialized),
-                         fd_(-1),
-                         size_limit_(-1),
-                         microdump_build_fingerprint_(NULL),
-                         microdump_product_info_(NULL) {}
+  MinidumpDescriptor()
+      : mode_(kUninitialized),
+        fd_(-1),
+        size_limit_(-1),
+        microdump_extra_info_() {}
 
   explicit MinidumpDescriptor(const string& directory)
       : mode_(kWriteMinidumpToFile),
         fd_(-1),
         directory_(directory),
         c_path_(NULL),
         size_limit_(-1),
-        microdump_build_fingerprint_(NULL),
-        microdump_product_info_(NULL) {
+        microdump_extra_info_() {
     assert(!directory.empty());
   }
 
   explicit MinidumpDescriptor(int fd)
       : mode_(kWriteMinidumpToFd),
         fd_(fd),
         c_path_(NULL),
         size_limit_(-1),
-        microdump_build_fingerprint_(NULL),
-        microdump_product_info_(NULL) {
+        microdump_extra_info_() {
     assert(fd != -1);
   }
 
+  // TODO(tobiasjs): remove this ctor and associated struct once the

[Primiano Tucci (use gerrit), 2015/09/10 12:38:58]

I think you can already remove this here and fix the code on the chromiuim side
once we roll.
I think we established that microdumps "stick" in chrome and your patch will be
unlikely to get reverted in chrome (which was the reason why I had the setters
here)

[Tobias Sargeant, 2015/09/10 13:18:38]

Done.

+  // MicrodumpExtraInfo ctor is used in Chromium.
   explicit MinidumpDescriptor(const MicrodumpOnConsole&)
       : mode_(kWriteMicrodumpToConsole),
         fd_(-1),
         size_limit_(-1),
-        microdump_build_fingerprint_(NULL),
-        microdump_product_info_(NULL) {}
+        microdump_extra_info_() {}
+
+  explicit MinidumpDescriptor(const MicrodumpExtraInfo &microdump_extra_info)
+      : mode_(kWriteMicrodumpToConsole),
+        fd_(-1),
+        size_limit_(-1),
+        microdump_extra_info_(microdump_extra_info) {}
 
   explicit MinidumpDescriptor(const MinidumpDescriptor& descriptor);
   MinidumpDescriptor& operator=(const MinidumpDescriptor& descriptor);
 
   static MinidumpDescriptor getMicrodumpDescriptor();
 
   bool IsFD() const { return mode_ == kWriteMinidumpToFd; }
 
   int fd() const { return fd_; }
 
   string directory() const { return directory_; }
 
   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();
 
   off_t size_limit() const { return size_limit_; }
   void set_size_limit(off_t limit) { size_limit_ = limit; }
 
-  // TODO(primiano): make this and product info (below) just part of the
-  // microdump ctor once it is rolled stably into Chrome. ETA: June 2015.
-  void SetMicrodumpBuildFingerprint(const char* build_fingerprint);
-  const char* microdump_build_fingerprint() const {
-    return microdump_build_fingerprint_;
-  }
-
-  void SetMicrodumpProductInfo(const char* product_info);
-  const char* microdump_product_info() const {
-    return microdump_product_info_;
-  }
+  void SetMicrodumpExtraInfo(const MicrodumpExtraInfo &microdump_extra_info);

[Primiano Tucci (use gerrit), 2015/09/10 12:38:58]

Similarly, you could remove this also

[Tobias Sargeant, 2015/09/10 13:18:39]

Done.

+  MicrodumpExtraInfo& microdump_extra_info() { return microdump_extra_info_; };
+  const MicrodumpExtraInfo& microdump_extra_info() const {
+    return microdump_extra_info_;
+  };
 
  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_;
 
   // The directory where the minidump should be generated.
   string directory_;
 
   // The full path to the generated minidump.
   string path_;
 
   // The C string of |path_|. Precomputed so it can be access from a compromised
   // context.
   const char* c_path_;
 
   off_t size_limit_;
 
   // The product name/version and build fingerprint that should be appended to

[Primiano Tucci (use gerrit), 2015/09/10 12:38:58]

Fix the comment plz, maybe just say
The extra microdump metadata (e.g., product name, version, OS information etc)

[Tobias Sargeant, 2015/09/10 13:18:39]

Done.

   // the dump (microdump only). Microdumps don't have the ability of appending
   // extra metadata after the dump is generated (as opposite to minidumps
   // MIME fields), therefore the product details must be provided upfront.
   // The string pointers are supposed to be valid through all the lifetime of
   // the process (read: the caller has to guarantee that they are stored in
   // global static storage).
-  const char* microdump_build_fingerprint_;
-  const char* microdump_product_info_;
+  MicrodumpExtraInfo microdump_extra_info_;
 };
 
 }  // namespace google_breakpad
 
 #endif  // CLIENT_LINUX_HANDLER_MINIDUMP_DESCRIPTOR_H_