minidump: Change the ownership model

minidump/minidump_thread_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 52 matching lines @@
     ASSERT_EQ(kMinidumpStreamTypeMemoryList, directory[1].StreamType);
 
     *memory_list = MinidumpWritableAtLocationDescriptor<MINIDUMP_MEMORY_LIST>(
         file_contents, directory[1].Location);
     ASSERT_TRUE(*memory_list);
   }
 }
 
 TEST(MinidumpThreadWriter, EmptyThreadList) {
   MinidumpFileWriter minidump_file_writer;
-  MinidumpThreadListWriter thread_list_writer;
+  auto thread_list_writer = make_scoped_ptr(new MinidumpThreadListWriter());
 
-  minidump_file_writer.AddStream(&thread_list_writer);
+  minidump_file_writer.AddStream(thread_list_writer.Pass());
 
   StringFileWriter file_writer;
   ASSERT_TRUE(minidump_file_writer.WriteEverything(&file_writer));
 
   ASSERT_EQ(sizeof(MINIDUMP_HEADER) + sizeof(MINIDUMP_DIRECTORY) +
                 sizeof(MINIDUMP_THREAD_LIST),
             file_writer.string().size());
 
   const MINIDUMP_THREAD_LIST* thread_list;
   ASSERT_NO_FATAL_FAILURE(
@@ skipping 38 matching lines @@
   EXPECT_EQ(expected->ThreadContext.DataSize, observed->ThreadContext.DataSize);
   ASSERT_NE(0u, observed->ThreadContext.DataSize);
   ASSERT_NE(0u, observed->ThreadContext.Rva);
   ASSERT_GE(file_contents.size(),
             observed->ThreadContext.Rva + expected->ThreadContext.DataSize);
   *context_base = &file_contents[observed->ThreadContext.Rva];
 }
 
 TEST(MinidumpThreadWriter, OneThread_x86_NoStack) {
   MinidumpFileWriter minidump_file_writer;
-  MinidumpThreadListWriter thread_list_writer;
+  auto thread_list_writer = make_scoped_ptr(new MinidumpThreadListWriter());
 
   const uint32_t kThreadID = 0x11111111;
   const uint32_t kSuspendCount = 1;
   const uint32_t kPriorityClass = 0x20;
   const uint32_t kPriority = 10;
   const uint64_t kTEB = 0x55555555;
   const uint32_t kSeed = 123;
 
-  MinidumpThreadWriter thread_writer;
-  thread_writer.SetThreadID(kThreadID);
-  thread_writer.SetSuspendCount(kSuspendCount);
-  thread_writer.SetPriorityClass(kPriorityClass);
-  thread_writer.SetPriority(kPriority);
-  thread_writer.SetTEB(kTEB);
+  auto thread_writer = make_scoped_ptr(new MinidumpThreadWriter());
+  thread_writer->SetThreadID(kThreadID);
+  thread_writer->SetSuspendCount(kSuspendCount);
+  thread_writer->SetPriorityClass(kPriorityClass);
+  thread_writer->SetPriority(kPriority);
+  thread_writer->SetTEB(kTEB);
 
-  MinidumpContextX86Writer context_x86_writer;
-  InitializeMinidumpContextX86(context_x86_writer.context(), kSeed);
-  thread_writer.SetContext(&context_x86_writer);
+  auto context_x86_writer = make_scoped_ptr(new MinidumpContextX86Writer());
+  InitializeMinidumpContextX86(context_x86_writer->context(), kSeed);
+  thread_writer->SetContext(context_x86_writer.Pass());
 
-  thread_list_writer.AddThread(&thread_writer);
-  minidump_file_writer.AddStream(&thread_list_writer);
+  thread_list_writer->AddThread(thread_writer.Pass());
+  minidump_file_writer.AddStream(thread_list_writer.Pass());
 
   StringFileWriter file_writer;
   ASSERT_TRUE(minidump_file_writer.WriteEverything(&file_writer));
 
   ASSERT_EQ(sizeof(MINIDUMP_HEADER) + sizeof(MINIDUMP_DIRECTORY) +
                 sizeof(MINIDUMP_THREAD_LIST) + 1 * sizeof(MINIDUMP_THREAD) +
                 1 * sizeof(MinidumpContextX86),
             file_writer.string().size());
 
   const MINIDUMP_THREAD_LIST* thread_list;
@@ skipping 16 matching lines @@
                    &thread_list->Threads[0],
                    file_writer.string(),
                    nullptr,
                    reinterpret_cast<const void**>(&observed_context)));
 
   ASSERT_NO_FATAL_FAILURE(ExpectMinidumpContextX86(kSeed, observed_context));
 }
 
 TEST(MinidumpThreadWriter, OneThread_AMD64_Stack) {
   MinidumpFileWriter minidump_file_writer;
-  MinidumpThreadListWriter thread_list_writer;
+  auto thread_list_writer = make_scoped_ptr(new MinidumpThreadListWriter());
 
   const uint32_t kThreadID = 0x22222222;
   const uint32_t kSuspendCount = 2;
   const uint32_t kPriorityClass = 0x30;
   const uint32_t kPriority = 20;
   const uint64_t kTEB = 0x5555555555555555;
   const uint64_t kMemoryBase = 0x765432100000;
   const size_t kMemorySize = 32;
   const uint8_t kMemoryValue = 99;
   const uint32_t kSeed = 456;
 
-  MinidumpThreadWriter thread_writer;
-  thread_writer.SetThreadID(kThreadID);
-  thread_writer.SetSuspendCount(kSuspendCount);
-  thread_writer.SetPriorityClass(kPriorityClass);
-  thread_writer.SetPriority(kPriority);
-  thread_writer.SetTEB(kTEB);
+  auto thread_writer = make_scoped_ptr(new MinidumpThreadWriter());
+  thread_writer->SetThreadID(kThreadID);
+  thread_writer->SetSuspendCount(kSuspendCount);
+  thread_writer->SetPriorityClass(kPriorityClass);
+  thread_writer->SetPriority(kPriority);
+  thread_writer->SetTEB(kTEB);
 
-  TestMinidumpMemoryWriter memory_writer(
-      kMemoryBase, kMemorySize, kMemoryValue);
-  thread_writer.SetStack(&memory_writer);
+  auto memory_writer = make_scoped_ptr(
+      new TestMinidumpMemoryWriter(kMemoryBase, kMemorySize, kMemoryValue));
+  thread_writer->SetStack(memory_writer.Pass());
 
-  MinidumpContextAMD64Writer context_amd64_writer;
-  InitializeMinidumpContextAMD64(context_amd64_writer.context(), kSeed);
-  thread_writer.SetContext(&context_amd64_writer);
+  auto context_amd64_writer = make_scoped_ptr(new MinidumpContextAMD64Writer());
+  InitializeMinidumpContextAMD64(context_amd64_writer->context(), kSeed);
+  thread_writer->SetContext(context_amd64_writer.Pass());
 
-  thread_list_writer.AddThread(&thread_writer);
-  minidump_file_writer.AddStream(&thread_list_writer);
+  thread_list_writer->AddThread(thread_writer.Pass());
+  minidump_file_writer.AddStream(thread_list_writer.Pass());
 
   StringFileWriter file_writer;
   ASSERT_TRUE(minidump_file_writer.WriteEverything(&file_writer));
 
   ASSERT_EQ(sizeof(MINIDUMP_HEADER) + sizeof(MINIDUMP_DIRECTORY) +
                 sizeof(MINIDUMP_THREAD_LIST) + 1 * sizeof(MINIDUMP_THREAD) +
                 1 * sizeof(MinidumpContextAMD64) + kMemorySize,
             file_writer.string().size());
 
   const MINIDUMP_THREAD_LIST* thread_list;
@@ skipping 25 matching lines @@
       ExpectMinidumpMemoryDescriptorAndContents(&expected.Stack,
                                                 observed_stack,
                                                 file_writer.string(),
                                                 kMemoryValue,
                                                 true));
   ASSERT_NO_FATAL_FAILURE(ExpectMinidumpContextAMD64(kSeed, observed_context));
 }
 
 TEST(MinidumpThreadWriter, ThreeThreads_x86_MemoryList) {
   MinidumpFileWriter minidump_file_writer;
-  MinidumpThreadListWriter thread_list_writer;
-  MinidumpMemoryListWriter memory_list_writer;
-  thread_list_writer.SetMemoryListWriter(&memory_list_writer);
+  auto thread_list_writer = make_scoped_ptr(new MinidumpThreadListWriter());
+  auto memory_list_writer = make_scoped_ptr(new MinidumpMemoryListWriter());
+  thread_list_writer->SetMemoryListWriter(memory_list_writer.get());
 
   const uint32_t kThreadID0 = 1111111;
   const uint32_t kSuspendCount0 = 111111;
   const uint32_t kPriorityClass0 = 11111;
   const uint32_t kPriority0 = 1111;
   const uint64_t kTEB0 = 111;
   const uint64_t kMemoryBase0 = 0x1110;
   const size_t kMemorySize0 = 16;
   const uint8_t kMemoryValue0 = 11;
   const uint32_t kSeed0 = 1;
 
-  MinidumpThreadWriter thread_writer_0;
-  thread_writer_0.SetThreadID(kThreadID0);
-  thread_writer_0.SetSuspendCount(kSuspendCount0);
-  thread_writer_0.SetPriorityClass(kPriorityClass0);
-  thread_writer_0.SetPriority(kPriority0);
-  thread_writer_0.SetTEB(kTEB0);
+  auto thread_writer_0 = make_scoped_ptr(new MinidumpThreadWriter());
+  thread_writer_0->SetThreadID(kThreadID0);
+  thread_writer_0->SetSuspendCount(kSuspendCount0);
+  thread_writer_0->SetPriorityClass(kPriorityClass0);
+  thread_writer_0->SetPriority(kPriority0);
+  thread_writer_0->SetTEB(kTEB0);
 
-  TestMinidumpMemoryWriter memory_writer_0(
-      kMemoryBase0, kMemorySize0, kMemoryValue0);
-  thread_writer_0.SetStack(&memory_writer_0);
+  auto memory_writer_0 = make_scoped_ptr(
+      new TestMinidumpMemoryWriter(kMemoryBase0, kMemorySize0, kMemoryValue0));
+  thread_writer_0->SetStack(memory_writer_0.Pass());
 
-  MinidumpContextX86Writer context_x86_writer_0;
-  InitializeMinidumpContextX86(context_x86_writer_0.context(), kSeed0);
-  thread_writer_0.SetContext(&context_x86_writer_0);
+  auto context_x86_writer_0 = make_scoped_ptr(new MinidumpContextX86Writer());
+  InitializeMinidumpContextX86(context_x86_writer_0->context(), kSeed0);
+  thread_writer_0->SetContext(context_x86_writer_0.Pass());
 
-  thread_list_writer.AddThread(&thread_writer_0);
+  thread_list_writer->AddThread(thread_writer_0.Pass());
 
   const uint32_t kThreadID1 = 2222222;
   const uint32_t kSuspendCount1 = 222222;
   const uint32_t kPriorityClass1 = 22222;
   const uint32_t kPriority1 = 2222;
   const uint64_t kTEB1 = 222;
   const uint64_t kMemoryBase1 = 0x2220;
   const size_t kMemorySize1 = 32;
   const uint8_t kMemoryValue1 = 22;
   const uint32_t kSeed1 = 2;
 
-  MinidumpThreadWriter thread_writer_1;
-  thread_writer_1.SetThreadID(kThreadID1);
-  thread_writer_1.SetSuspendCount(kSuspendCount1);
-  thread_writer_1.SetPriorityClass(kPriorityClass1);
-  thread_writer_1.SetPriority(kPriority1);
-  thread_writer_1.SetTEB(kTEB1);
+  auto thread_writer_1 = make_scoped_ptr(new MinidumpThreadWriter());
+  thread_writer_1->SetThreadID(kThreadID1);
+  thread_writer_1->SetSuspendCount(kSuspendCount1);
+  thread_writer_1->SetPriorityClass(kPriorityClass1);
+  thread_writer_1->SetPriority(kPriority1);
+  thread_writer_1->SetTEB(kTEB1);
 
-  TestMinidumpMemoryWriter memory_writer_1(
-      kMemoryBase1, kMemorySize1, kMemoryValue1);
-  thread_writer_1.SetStack(&memory_writer_1);
+  auto memory_writer_1 = make_scoped_ptr(
+      new TestMinidumpMemoryWriter(kMemoryBase1, kMemorySize1, kMemoryValue1));
+  thread_writer_1->SetStack(memory_writer_1.Pass());
 
-  MinidumpContextX86Writer context_x86_writer_1;
-  InitializeMinidumpContextX86(context_x86_writer_1.context(), kSeed1);
-  thread_writer_1.SetContext(&context_x86_writer_1);
+  auto context_x86_writer_1 = make_scoped_ptr(new MinidumpContextX86Writer());
+  InitializeMinidumpContextX86(context_x86_writer_1->context(), kSeed1);
+  thread_writer_1->SetContext(context_x86_writer_1.Pass());
 
-  thread_list_writer.AddThread(&thread_writer_1);
+  thread_list_writer->AddThread(thread_writer_1.Pass());
 
   const uint32_t kThreadID2 = 3333333;
   const uint32_t kSuspendCount2 = 333333;
   const uint32_t kPriorityClass2 = 33333;
   const uint32_t kPriority2 = 3333;
   const uint64_t kTEB2 = 333;
   const uint64_t kMemoryBase2 = 0x3330;
   const size_t kMemorySize2 = 48;
   const uint8_t kMemoryValue2 = 33;
   const uint32_t kSeed2 = 3;
 
-  MinidumpThreadWriter thread_writer_2;
-  thread_writer_2.SetThreadID(kThreadID2);
-  thread_writer_2.SetSuspendCount(kSuspendCount2);
-  thread_writer_2.SetPriorityClass(kPriorityClass2);
-  thread_writer_2.SetPriority(kPriority2);
-  thread_writer_2.SetTEB(kTEB2);
+  auto thread_writer_2 = make_scoped_ptr(new MinidumpThreadWriter());
+  thread_writer_2->SetThreadID(kThreadID2);
+  thread_writer_2->SetSuspendCount(kSuspendCount2);
+  thread_writer_2->SetPriorityClass(kPriorityClass2);
+  thread_writer_2->SetPriority(kPriority2);
+  thread_writer_2->SetTEB(kTEB2);
 
-  TestMinidumpMemoryWriter memory_writer_2(
-      kMemoryBase2, kMemorySize2, kMemoryValue2);
-  thread_writer_2.SetStack(&memory_writer_2);
+  auto memory_writer_2 = make_scoped_ptr(
+      new TestMinidumpMemoryWriter(kMemoryBase2, kMemorySize2, kMemoryValue2));
+  thread_writer_2->SetStack(memory_writer_2.Pass());
 
-  MinidumpContextX86Writer context_x86_writer_2;
-  InitializeMinidumpContextX86(context_x86_writer_2.context(), kSeed2);
-  thread_writer_2.SetContext(&context_x86_writer_2);
+  auto context_x86_writer_2 = make_scoped_ptr(new MinidumpContextX86Writer());
+  InitializeMinidumpContextX86(context_x86_writer_2->context(), kSeed2);
+  thread_writer_2->SetContext(context_x86_writer_2.Pass());
 
-  thread_list_writer.AddThread(&thread_writer_2);
+  thread_list_writer->AddThread(thread_writer_2.Pass());
 
-  minidump_file_writer.AddStream(&thread_list_writer);
-  minidump_file_writer.AddStream(&memory_list_writer);
+  minidump_file_writer.AddStream(thread_list_writer.Pass());
+  minidump_file_writer.AddStream(memory_list_writer.Pass());
 
   StringFileWriter file_writer;
   ASSERT_TRUE(minidump_file_writer.WriteEverything(&file_writer));
 
   ASSERT_EQ(sizeof(MINIDUMP_HEADER) + 2 * sizeof(MINIDUMP_DIRECTORY) +
                 sizeof(MINIDUMP_THREAD_LIST) + 3 * sizeof(MINIDUMP_THREAD) +
                 sizeof(MINIDUMP_MEMORY_LIST) +
                 3 * sizeof(MINIDUMP_MEMORY_DESCRIPTOR) +
                 3 * sizeof(MinidumpContextX86) + kMemorySize0 + kMemorySize1 +
                 kMemorySize2 + 12,  // 12 for alignment
@@ skipping 102 matching lines @@
                                                   kMemoryValue2,
                                                   true));
     ASSERT_NO_FATAL_FAILURE(ExpectMinidumpContextX86(kSeed2, observed_context));
     ASSERT_NO_FATAL_FAILURE(ExpectMinidumpMemoryDescriptor(
         observed_stack, &memory_list->MemoryRanges[2]));
   }
 }
 
 TEST(MinidumpThreadWriterDeathTest, NoContext) {
   MinidumpFileWriter minidump_file_writer;
-  MinidumpThreadListWriter thread_list_writer;
+  auto thread_list_writer = make_scoped_ptr(new MinidumpThreadListWriter());
 
-  MinidumpThreadWriter thread_writer;
+  auto thread_writer = make_scoped_ptr(new MinidumpThreadWriter());
 
-  thread_list_writer.AddThread(&thread_writer);
-  minidump_file_writer.AddStream(&thread_list_writer);
+  thread_list_writer->AddThread(thread_writer.Pass());
+  minidump_file_writer.AddStream(thread_list_writer.Pass());
 
   StringFileWriter file_writer;
   ASSERT_DEATH(minidump_file_writer.WriteEverything(&file_writer), "context_");
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace crashpad