Switch the Linux minidump writer to use MDCVInfoELF for CV data.

src/client/linux/minidump_writer/linux_ptrace_dumper_unittest.cc

 // Copyright (c) 2009, 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 48 matching lines @@
 #include "common/using_std_string.h"
 
 #ifndef PR_SET_PTRACER
 #define PR_SET_PTRACER 0x59616d61
 #endif
 
 using namespace google_breakpad;
 
 namespace {
 
+typedef wasteful_vector<uint8_t> id_vector;
 typedef testing::Test LinuxPtraceDumperTest;
 
 /* Fixture for running tests in a child process. */
 class LinuxPtraceDumperChildTest : public testing::Test {
  protected:
   virtual void SetUp() {
     child_pid_ = fork();
 #ifndef __ANDROID__
     prctl(PR_SET_PTRACER, child_pid_);
 #endif
@@ skipping 19 matching lines @@
     } else if (WEXITSTATUS(status) == kNonFatalFailure) {
       GTEST_NONFATAL_FAILURE_("Test failed in child process");
     }
   }
 
   /* Gtest defines TestBody functions through its macros, but classes
    * derived from this one need to define RealTestBody instead.
    * This is achieved by defining a TestBody macro further below.
    */
   virtual void RealTestBody() = 0;
+
+  id_vector make_vector() {
+    return id_vector(&allocator, kDefaultBuildIdSize);
+  }
+
  private:
   static const int kFatalFailure = 1;
   static const int kNonFatalFailure = 2;
 
   pid_t child_pid_;
+  PageAllocator allocator;
 };
 
 }  // namespace
 
 /* Replace TestBody declarations within TEST*() with RealTestBody
  * declarations */
 #define TestBody RealTestBody
 
 TEST_F(LinuxPtraceDumperChildTest, Setup) {
   LinuxPtraceDumper dumper(getppid());
@@ skipping 180 matching lines @@
     if (!strcmp(mappings[i]->name, kLinuxGateLibraryName)) {
       found_linux_gate = true;
       index = i;
       break;
     }
   }
   ASSERT_TRUE(found_linux_gate);
 
   // Need to suspend the child so ptrace actually works.
   ASSERT_TRUE(dumper.ThreadsSuspend());
-  uint8_t identifier[sizeof(MDGUID)];
+  id_vector identifier(make_vector());
   ASSERT_TRUE(dumper.ElfFileIdentifierForMapping(*mappings[index],
                                                  true,
                                                  index,
                                                  identifier));
-  uint8_t empty_identifier[sizeof(MDGUID)];
-  memset(empty_identifier, 0, sizeof(empty_identifier));
-  EXPECT_NE(0, memcmp(empty_identifier, identifier, sizeof(identifier)));
+
+  id_vector empty_identifier(make_vector());
+  empty_identifier.resize(kDefaultBuildIdSize, 0);
+  EXPECT_NE(empty_identifier, identifier);
   EXPECT_TRUE(dumper.ThreadsResume());
 }
 #endif
 
 TEST_F(LinuxPtraceDumperChildTest, FileIDsMatch) {
   // Calculate the File ID of our binary using both
   // FileID::ElfFileIdentifier and LinuxDumper::ElfFileIdentifierForMapping
   // and ensure that we get the same result from both.
   char exe_name[PATH_MAX];
   ASSERT_TRUE(SafeReadLink("/proc/self/exe", exe_name));
 
   LinuxPtraceDumper dumper(getppid());
   ASSERT_TRUE(dumper.Init());
   const wasteful_vector<MappingInfo*> mappings = dumper.mappings();
   bool found_exe = false;
   unsigned i;
   for (i = 0; i < mappings.size(); ++i) {
     const MappingInfo* mapping = mappings[i];
     if (!strcmp(mapping->name, exe_name)) {
       found_exe = true;
       break;
     }
   }
   ASSERT_TRUE(found_exe);
 
-  uint8_t identifier1[sizeof(MDGUID)];
-  uint8_t identifier2[sizeof(MDGUID)];
+  id_vector identifier1(make_vector());
+  id_vector identifier2(make_vector());
   EXPECT_TRUE(dumper.ElfFileIdentifierForMapping(*mappings[i], true, i,
                                                  identifier1));
   FileID fileid(exe_name);
   EXPECT_TRUE(fileid.ElfFileIdentifier(identifier2));
-  char identifier_string1[37];
-  char identifier_string2[37];
-  FileID::ConvertIdentifierToString(identifier1, identifier_string1,
-                                    37);
-  FileID::ConvertIdentifierToString(identifier2, identifier_string2,
-                                    37);
-  EXPECT_STREQ(identifier_string1, identifier_string2);
+
+  string identifier_string1 =
+      FileID::ConvertIdentifierToUUIDString(identifier1);
+  string identifier_string2 =
+      FileID::ConvertIdentifierToUUIDString(identifier2);
+  EXPECT_EQ(identifier_string1, identifier_string2);
 }
 
 /* Get back to normal behavior of TEST*() macros wrt TestBody. */
 #undef TestBody
 
 TEST(LinuxPtraceDumperTest, VerifyStackReadWithMultipleThreads) {
   static const int kNumberOfThreadsInHelperProgram = 5;
   char kNumberOfThreadsArgument[2];
   sprintf(kNumberOfThreadsArgument, "%d", kNumberOfThreadsInHelperProgram);
 
@@ skipping 85 matching lines @@
   }
   EXPECT_TRUE(dumper.ThreadsResume());
   kill(child_pid, SIGKILL);
 
   // Reap child
   int status;
   ASSERT_NE(-1, HANDLE_EINTR(waitpid(child_pid, &status, 0)));
   ASSERT_TRUE(WIFSIGNALED(status));
   ASSERT_EQ(SIGKILL, WTERMSIG(status));
 }