minidump: Change the ownership model

minidump/minidump_thread_writer.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 10 matching lines @@
 #include "minidump/minidump_memory_writer.h"
 #include "util/file/file_writer.h"
 #include "util/numeric/safe_assignment.h"
 
 namespace crashpad {
 
 MinidumpThreadWriter::MinidumpThreadWriter()
     : MinidumpWritable(), thread_(), stack_(nullptr), context_(nullptr) {
 }
 
+MinidumpThreadWriter::~MinidumpThreadWriter() {
+}
+
 const MINIDUMP_THREAD* MinidumpThreadWriter::MinidumpThread() const {
   DCHECK_EQ(state(), kStateWritable);
 
   return &thread_;
 }
 
-void MinidumpThreadWriter::SetStack(MinidumpMemoryWriter* stack) {
+void MinidumpThreadWriter::SetStack(scoped_ptr<MinidumpMemoryWriter> stack) {
   DCHECK_EQ(state(), kStateMutable);
 
-  stack_ = stack;
+  stack_ = stack.Pass();
 }
 
-void MinidumpThreadWriter::SetContext(MinidumpContextWriter* context) {
+void MinidumpThreadWriter::SetContext(
+    scoped_ptr<MinidumpContextWriter> context) {
   DCHECK_EQ(state(), kStateMutable);
 
-  context_ = context;
+  context_ = context.Pass();
 }
 
 bool MinidumpThreadWriter::Freeze() {
   DCHECK_EQ(state(), kStateMutable);
   CHECK(context_);
 
   if (!MinidumpWritable::Freeze()) {
     return false;
   }
 
@@ skipping 14 matching lines @@
   // are responsible for writing themselves.
   return 0;
 }
 
 std::vector<internal::MinidumpWritable*> MinidumpThreadWriter::Children() {
   DCHECK_GE(state(), kStateFrozen);
   DCHECK(context_);
 
   std::vector<MinidumpWritable*> children;
   if (stack_) {
-    children.push_back(stack_);
+    children.push_back(stack_.get());
   }
-  children.push_back(context_);
+  children.push_back(context_.get());
 
   return children;
 }
 
 bool MinidumpThreadWriter::WriteObject(FileWriterInterface* file_writer) {
   DCHECK_EQ(state(), kStateWritable);
 
   // This object doesn’t directly write anything itself. Its MINIDUMP_THREAD is
   // written by its parent as part of a MINIDUMP_THREAD_LIST, and its children
   // are responsible for writing themselves.
@@ skipping 11 matching lines @@
 }
 
 void MinidumpThreadListWriter::SetMemoryListWriter(
     MinidumpMemoryListWriter* memory_list_writer) {
   DCHECK_EQ(state(), kStateMutable);
   DCHECK(threads_.empty());
 
   memory_list_writer_ = memory_list_writer;
 }
 
-void MinidumpThreadListWriter::AddThread(MinidumpThreadWriter* thread) {
+void MinidumpThreadListWriter::AddThread(
+    scoped_ptr<MinidumpThreadWriter> thread) {
   DCHECK_EQ(state(), kStateMutable);
 
-  threads_.push_back(thread);
-
   if (memory_list_writer_) {
     MinidumpMemoryWriter* stack = thread->Stack();
     if (stack) {
       memory_list_writer_->AddExtraMemory(stack);
     }
   }
+
+  threads_.push_back(thread.release());
 }
 
 bool MinidumpThreadListWriter::Freeze() {
   DCHECK_EQ(state(), kStateMutable);
 
   if (!MinidumpStreamWriter::Freeze()) {
     return false;
   }
 
   size_t thread_count = threads_.size();
@@ skipping 37 matching lines @@
   }
 
   return file_writer->WriteIoVec(&iovecs);
 }
 
 MinidumpStreamType MinidumpThreadListWriter::StreamType() const {
   return kMinidumpStreamTypeThreadList;
 }
 
 }  // namespace crashpad