minidump: Change the ownership model

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,
@@ skipping 55 matching lines @@
             directory[directory_index].StreamType);
   EXPECT_EQ(kMemoryListStreamOffset, directory[directory_index].Location.Rva);
 
   *memory_list = MinidumpWritableAtLocationDescriptor<MINIDUMP_MEMORY_LIST>(
       file_contents, directory[directory_index].Location);
   ASSERT_TRUE(memory_list);
 }
 
 TEST(MinidumpMemoryWriter, EmptyMemoryList) {
   MinidumpFileWriter minidump_file_writer;
-  MinidumpMemoryListWriter memory_list_writer;
+  auto memory_list_writer = make_scoped_ptr(new MinidumpMemoryListWriter());
 
-  minidump_file_writer.AddStream(&memory_list_writer);
+  minidump_file_writer.AddStream(memory_list_writer.Pass());
 
   StringFileWriter file_writer;
   ASSERT_TRUE(minidump_file_writer.WriteEverything(&file_writer));
 
   ASSERT_EQ(sizeof(MINIDUMP_HEADER) + sizeof(MINIDUMP_DIRECTORY) +
                 sizeof(MINIDUMP_MEMORY_LIST),
             file_writer.string().size());
 
   const MINIDUMP_MEMORY_LIST* memory_list;
   ASSERT_NO_FATAL_FAILURE(
       GetMemoryListStream(file_writer.string(), &memory_list, 1));
 
   EXPECT_EQ(0u, memory_list->NumberOfMemoryRanges);
 }
 
 TEST(MinidumpMemoryWriter, OneMemoryRegion) {
   MinidumpFileWriter minidump_file_writer;
-  MinidumpMemoryListWriter memory_list_writer;
+  auto memory_list_writer = make_scoped_ptr(new MinidumpMemoryListWriter());
 
   const uint64_t kBaseAddress = 0xfedcba9876543210;
   const uint64_t kSize = 0x1000;
   const uint8_t kValue = 'm';
 
-  TestMinidumpMemoryWriter memory_writer(kBaseAddress, kSize, kValue);
-  memory_list_writer.AddMemory(&memory_writer);
+  auto memory_writer = make_scoped_ptr(
+      new TestMinidumpMemoryWriter(kBaseAddress, kSize, kValue));
+  memory_list_writer->AddMemory(memory_writer.Pass());
 
-  minidump_file_writer.AddStream(&memory_list_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));
 
   MINIDUMP_MEMORY_DESCRIPTOR expected;
   expected.StartOfMemoryRange = kBaseAddress;
   expected.Memory.DataSize = kSize;
   expected.Memory.Rva =
       sizeof(MINIDUMP_HEADER) + sizeof(MINIDUMP_DIRECTORY) +
       sizeof(MINIDUMP_MEMORY_LIST) +
       memory_list->NumberOfMemoryRanges * sizeof(MINIDUMP_MEMORY_DESCRIPTOR);
   ExpectMinidumpMemoryDescriptorAndContents(&expected,
                                             &memory_list->MemoryRanges[0],
                                             file_writer.string(),
                                             kValue,
                                             true);
 }
 
 TEST(MinidumpMemoryWriter, TwoMemoryRegions) {
   MinidumpFileWriter minidump_file_writer;
-  MinidumpMemoryListWriter memory_list_writer;
+  auto memory_list_writer = make_scoped_ptr(new MinidumpMemoryListWriter());
 
   const uint64_t kBaseAddress0 = 0xc0ffee;
   const uint64_t kSize0 = 0x0100;
   const uint8_t kValue0 = '6';
   const uint64_t kBaseAddress1 = 0xfac00fac;
   const uint64_t kSize1 = 0x0200;
   const uint8_t kValue1 = '!';
 
-  TestMinidumpMemoryWriter memory_writer_0(kBaseAddress0, kSize0, kValue0);
-  memory_list_writer.AddMemory(&memory_writer_0);
-  TestMinidumpMemoryWriter memory_writer_1(kBaseAddress1, kSize1, kValue1);
-  memory_list_writer.AddMemory(&memory_writer_1);
+  auto memory_writer_0 = make_scoped_ptr(
+      new TestMinidumpMemoryWriter(kBaseAddress0, kSize0, kValue0));
+  memory_list_writer->AddMemory(memory_writer_0.Pass());
+  auto memory_writer_1 = make_scoped_ptr(
+      new TestMinidumpMemoryWriter(kBaseAddress1, kSize1, kValue1));
+  memory_list_writer->AddMemory(memory_writer_1.Pass());
 
-  minidump_file_writer.AddStream(&memory_list_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));
 
   EXPECT_EQ(2u, memory_list->NumberOfMemoryRanges);
 
@@ skipping 28 matching lines @@
                                               kValue1,
                                               true);
   }
 }
 
 class TestMemoryStream final : public internal::MinidumpStreamWriter {
  public:
   TestMemoryStream(uint64_t base_address, size_t size, uint8_t value)
       : MinidumpStreamWriter(), memory_(base_address, size, value) {}
 
-  ~TestMemoryStream() {}
+  ~TestMemoryStream() override {}
 
-  TestMinidumpMemoryWriter* memory() { return &memory_; }
+  TestMinidumpMemoryWriter* memory() {
+    return &memory_;
+  }
 
   // MinidumpStreamWriter:
   MinidumpStreamType StreamType() const override {
     return kBogusStreamType;
   }
 
  protected:
   // MinidumpWritable:
   size_t SizeOfObject() override {
     EXPECT_GE(state(), kStateFrozen);
@@ skipping 19 matching lines @@
 
 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 uint8_t kValue0 = '1';
-  TestMemoryStream test_memory_stream(kBaseAddress0, kSize0, kValue0);
+  auto test_memory_stream =
+      make_scoped_ptr(new TestMemoryStream(kBaseAddress0, kSize0, kValue0));
 
-  MinidumpMemoryListWriter memory_list_writer;
-  memory_list_writer.AddExtraMemory(test_memory_stream.memory());
+  auto memory_list_writer = make_scoped_ptr(new MinidumpMemoryListWriter());
+  memory_list_writer->AddExtraMemory(test_memory_stream->memory());
 
-  minidump_file_writer.AddStream(&test_memory_stream);
+  minidump_file_writer.AddStream(test_memory_stream.Pass());
 
   const uint64_t kBaseAddress1 = 0x2000;
   const uint64_t kSize1 = 0x0400;
   const uint8_t kValue1 = 'm';
 
-  TestMinidumpMemoryWriter memory_writer(kBaseAddress1, kSize1, kValue1);
-  memory_list_writer.AddMemory(&memory_writer);
+  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);
+  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, 2));
 
   EXPECT_EQ(2u, memory_list->NumberOfMemoryRanges);
 
@@ skipping 26 matching lines @@
                                               &memory_list->MemoryRanges[1],
                                               file_writer.string(),
                                               kValue1,
                                               true);
   }
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace crashpad