Add MinidumpThreadListWriter::InitializeFromSnapshot()

minidump/minidump_thread_writer.h

 // 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.
 
 #ifndef CRASHPAD_MINIDUMP_MINIDUMP_THREAD_WRITER_H_
 #define CRASHPAD_MINIDUMP_MINIDUMP_THREAD_WRITER_H_
 
 #include <dbghelp.h>
 #include <stdint.h>
 
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 #include "minidump/minidump_stream_writer.h"
+#include "minidump/minidump_thread_id_map.h"
 #include "minidump/minidump_writable.h"
 #include "util/stdlib/pointer_container.h"
 
 namespace crashpad {
 
 class MinidumpContextWriter;
 class MinidumpMemoryListWriter;
 class MinidumpMemoryWriter;
+class ThreadSnapshot;
 
 //! \brief The writer for a MINIDUMP_THREAD object in a minidump file.
 //!
 //! Because MINIDUMP_THREAD objects only appear as elements of
 //! MINIDUMP_THREAD_LIST objects, this class does not write any data on its own.
 //! It makes its MINIDUMP_THREAD data available to its MinidumpThreadListWriter
 //! parent, which writes it as part of a MINIDUMP_THREAD_LIST.
 class MinidumpThreadWriter final : public internal::MinidumpWritable {
  public:
   MinidumpThreadWriter();
   ~MinidumpThreadWriter() override;
 
+  //! \brief Initializes the MINIDUMP_THREAD based on \a thread_snapshot.
+  //!
+  //! \param[in] thread_snapshot The thread snapshot to use as source data.
+  //! \param[in] thread_id_map A MinidumpThreadIDMap to be consulted to
+  //!     determine the 32-bit minidump thread ID to use for \a thread_snapshot.
+  //!
+  //! \note Valid in #kStateMutable. No mutator methods may be called before
+  //!     this method, and it is not normally necessary to call any mutator
+  //!     methods after this method.
+  void InitializeFromSnapshot(const ThreadSnapshot* thread_snapshot,
+                              const MinidumpThreadIDMap* thread_id_map);
+
   //! \brief Returns a MINIDUMP_THREAD referencing this object’s data.
   //!
   //! This method is expected to be called by a MinidumpThreadListWriter in
   //! order to obtain a MINIDUMP_THREAD to include in its list.
   //!
   //! \note Valid in #kStateWritable.
   const MINIDUMP_THREAD* MinidumpThread() const;
 
   //! \brief Returns a MinidumpMemoryWriter that will write the memory region
   //!     corresponding to this object’s stack.
@@ skipping 64 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(MinidumpThreadWriter);
 };
 
 //! \brief The writer for a MINIDUMP_THREAD_LIST stream in a minidump file,
 //!     containing a list of MINIDUMP_THREAD objects.
 class MinidumpThreadListWriter final : public internal::MinidumpStreamWriter {
  public:
   MinidumpThreadListWriter();
   ~MinidumpThreadListWriter() override;
 
+  //! \brief Adds an initialized MINIDUMP_THREAD for each thread in \a
+  //!     thread_snapshots to the MINIDUMP_THREAD_LIST.
+  //!
+  //! \param[in] thread_snapshots The thread snapshots to use as source data.
+  //! \param[out] thread_id_map A MinidumpThreadIDMap to be built by this
+  //!     method. This map must be empty when this method is called.
+  //!
+  //! \note Valid in #kStateMutable. AddThread() may not be called before this
+  //!     method, and it is not normally necessary to call AddThread() after
+  //!     this method.
+  void InitializeFromSnapshot(
+      const std::vector<const ThreadSnapshot*>& thread_snapshots,
+      MinidumpThreadIDMap* thread_id_map);
+
   //! \brief Sets the MinidumpMemoryListWriter that each thread’s stack memory
   //!     region should be added to as extra memory.
   //!
   //! Each MINIDUMP_THREAD object can contain a reference to a
   //! MinidumpMemoryWriter object that contains a snapshot of its stack memory.
   //! In the overall tree of internal::MinidumpWritable objects, these
   //! MinidumpMemoryWriter objects are considered children of their
   //! MINIDUMP_THREAD, and are referenced by a MINIDUMP_MEMORY_DESCRIPTOR
   //! contained in the MINIDUMP_THREAD. It is also possible for the same memory
   //! regions to have MINIDUMP_MEMORY_DESCRIPTOR objects present in a
@@ skipping 36 matching lines @@
   MINIDUMP_THREAD_LIST thread_list_base_;
   PointerVector<MinidumpThreadWriter> threads_;
   MinidumpMemoryListWriter* memory_list_writer_;  // weak
 
   DISALLOW_COPY_AND_ASSIGN(MinidumpThreadListWriter);
 };
 
 }  // namespace crashpad
 
 #endif  // CRASHPAD_MINIDUMP_MINIDUMP_THREAD_WRITER_H_