Add MinidumpMemoryListWriter::AddFromSnapshot(), everything downstream and its test

minidump/minidump_memory_writer_test.cc

 // Copyright 2014 The Crashpad Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
 #include "minidump/minidump_memory_writer.h"
 
 #include <dbghelp.h>
 #include <stdint.h>
 
 #include "base/basictypes.h"
+#include "base/strings/stringprintf.h"
 #include "gtest/gtest.h"
 #include "minidump/minidump_extensions.h"
 #include "minidump/minidump_file_writer.h"
 #include "minidump/minidump_stream_writer.h"
 #include "minidump/test/minidump_file_writer_test_util.h"
 #include "minidump/test/minidump_memory_writer_test_util.h"
 #include "minidump/test/minidump_writable_test_util.h"
+#include "snapshot/test/test_memory_snapshot.h"
 #include "util/file/string_file_writer.h"
+#include "util/stdlib/pointer_container.h"
 
 namespace crashpad {
 namespace test {
 namespace {
 
 const MinidumpStreamType kBogusStreamType =
     static_cast<MinidumpStreamType>(1234);
 
 // expected_streams is the expected number of streams in the file. The memory
 // list must be the last stream. If there is another stream, it must come first,
@@ skipping 189 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(TestMemoryStream);
 };
 
 TEST(MinidumpMemoryWriter, ExtraMemory) {
   // This tests MinidumpMemoryListWriter::AddExtraMemory(). That method adds
   // a MinidumpMemoryWriter to the MinidumpMemoryListWriter without making the
   // memory writer a child of the memory list writer.
   MinidumpFileWriter minidump_file_writer;
 
   const uint64_t kBaseAddress0 = 0x1000;
-  const uint64_t kSize0 = 0x0400;
+  const size_t kSize0 = 0x0400;
   const uint8_t kValue0 = '1';
   auto test_memory_stream =
       make_scoped_ptr(new TestMemoryStream(kBaseAddress0, kSize0, kValue0));
 
   auto memory_list_writer = make_scoped_ptr(new MinidumpMemoryListWriter());
   memory_list_writer->AddExtraMemory(test_memory_stream->memory());
 
   minidump_file_writer.AddStream(test_memory_stream.Pass());
 
   const uint64_t kBaseAddress1 = 0x2000;
-  const uint64_t kSize1 = 0x0400;
+  const size_t kSize1 = 0x0400;
   const uint8_t kValue1 = 'm';
 
   auto memory_writer = make_scoped_ptr(
       new TestMinidumpMemoryWriter(kBaseAddress1, kSize1, kValue1));
   memory_list_writer->AddMemory(memory_writer.Pass());
 
   minidump_file_writer.AddStream(memory_list_writer.Pass());
 
   StringFileWriter file_writer;
   ASSERT_TRUE(minidump_file_writer.WriteEverything(&file_writer));
@@ skipping 30 matching lines @@
     expected.Memory.Rva = memory_list->MemoryRanges[0].Memory.Rva +
                           memory_list->MemoryRanges[0].Memory.DataSize;
     ExpectMinidumpMemoryDescriptorAndContents(&expected,
                                               &memory_list->MemoryRanges[1],
                                               file_writer.string(),
                                               kValue1,
                                               true);
   }
 }
 
+TEST(MinidumpMemoryWriter, AddFromSnapshot) {
+  MINIDUMP_MEMORY_DESCRIPTOR expect_memory_descriptors[3] = {};
+  uint8_t values[arraysize(expect_memory_descriptors)] = {};
+
+  expect_memory_descriptors[0].StartOfMemoryRange = 0;
+  expect_memory_descriptors[0].Memory.DataSize = 0x1000;
+  values[0] = 0x01;
+
+  expect_memory_descriptors[1].StartOfMemoryRange = 0x1000;
+  expect_memory_descriptors[1].Memory.DataSize = 0x2000;
+  values[1] = 0xf4;
+
+  expect_memory_descriptors[2].StartOfMemoryRange = 0x7654321000000000;
+  expect_memory_descriptors[2].Memory.DataSize = 0x800;
+  values[2] = 0xa9;
+
+  PointerVector<TestMemorySnapshot> memory_snapshots_owner;
+  std::vector<const MemorySnapshot*> memory_snapshots;
+  for (size_t index = 0;
+       index < arraysize(expect_memory_descriptors);
+       ++index) {
+    TestMemorySnapshot* memory_snapshot = new TestMemorySnapshot();
+    memory_snapshots_owner.push_back(memory_snapshot);
+    memory_snapshot->SetAddress(
+        expect_memory_descriptors[index].StartOfMemoryRange);
+    memory_snapshot->SetSize(expect_memory_descriptors[index].Memory.DataSize);
+    memory_snapshot->SetValue(values[index]);
+    memory_snapshots.push_back(memory_snapshot);
+  }
+
+  auto memory_list_writer = make_scoped_ptr(new MinidumpMemoryListWriter());
+  memory_list_writer->AddFromSnapshot(memory_snapshots);
+
+  MinidumpFileWriter minidump_file_writer;
+  minidump_file_writer.AddStream(memory_list_writer.Pass());
+
+  StringFileWriter file_writer;
+  ASSERT_TRUE(minidump_file_writer.WriteEverything(&file_writer));
+
+  const MINIDUMP_MEMORY_LIST* memory_list;
+  ASSERT_NO_FATAL_FAILURE(
+      GetMemoryListStream(file_writer.string(), &memory_list, 1));
+
+  ASSERT_EQ(3u, memory_list->NumberOfMemoryRanges);
+
+  for (size_t index = 0; index < memory_list->NumberOfMemoryRanges; ++index) {
+    SCOPED_TRACE(base::StringPrintf("index %zu", index));
+    ExpectMinidumpMemoryDescriptorAndContents(
+        &expect_memory_descriptors[index],
+        &memory_list->MemoryRanges[index],
+        file_writer.string(),
+        values[index],
+        index == memory_list->NumberOfMemoryRanges - 1);
+  }
+}
+
 }  // namespace
 }  // namespace test
 }  // namespace crashpad