Add MinidumpContextWriter::CreateFromSnapshot(), everything downstream, and its test

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 166 matching lines @@
   expected.ThreadContext.DataSize = sizeof(MinidumpContextX86);
 
   const MinidumpContextX86* observed_context;
   ASSERT_NO_FATAL_FAILURE(
       ExpectThread(&expected,
                    &thread_list->Threads[0],
                    file_writer.string(),
                    nullptr,
                    reinterpret_cast<const void**>(&observed_context)));
 
-  ASSERT_NO_FATAL_FAILURE(ExpectMinidumpContextX86(kSeed, observed_context));
+  ASSERT_NO_FATAL_FAILURE(
+      ExpectMinidumpContextX86(kSeed, observed_context, false));
 }
 
 TEST(MinidumpThreadWriter, OneThread_AMD64_Stack) {
   MinidumpFileWriter minidump_file_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;
@@ skipping 53 matching lines @@
                    file_writer.string(),
                    &observed_stack,
                    reinterpret_cast<const void**>(&observed_context)));
 
   ASSERT_NO_FATAL_FAILURE(
       ExpectMinidumpMemoryDescriptorAndContents(&expected.Stack,
                                                 observed_stack,
                                                 file_writer.string(),
                                                 kMemoryValue,
                                                 true));
-  ASSERT_NO_FATAL_FAILURE(ExpectMinidumpContextAMD64(kSeed, observed_context));
+  ASSERT_NO_FATAL_FAILURE(
+      ExpectMinidumpContextAMD64(kSeed, observed_context, false));
 }
 
 TEST(MinidumpThreadWriter, ThreeThreads_x86_MemoryList) {
   MinidumpFileWriter minidump_file_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;
@@ skipping 119 matching lines @@
                      file_writer.string(),
                      &observed_stack,
                      reinterpret_cast<const void**>(&observed_context)));
 
     ASSERT_NO_FATAL_FAILURE(
         ExpectMinidumpMemoryDescriptorAndContents(&expected.Stack,
                                                   observed_stack,
                                                   file_writer.string(),
                                                   kMemoryValue0,
                                                   false));
-    ASSERT_NO_FATAL_FAILURE(ExpectMinidumpContextX86(kSeed0, observed_context));
+    ASSERT_NO_FATAL_FAILURE(
+        ExpectMinidumpContextX86(kSeed0, observed_context, false));
     ASSERT_NO_FATAL_FAILURE(ExpectMinidumpMemoryDescriptor(
         observed_stack, &memory_list->MemoryRanges[0]));
   }
 
   {
     SCOPED_TRACE("thread 1");
 
     MINIDUMP_THREAD expected = {};
     expected.ThreadId = kThreadID1;
     expected.SuspendCount = kSuspendCount1;
@@ skipping 12 matching lines @@
                      file_writer.string(),
                      &observed_stack,
                      reinterpret_cast<const void**>(&observed_context)));
 
     ASSERT_NO_FATAL_FAILURE(
         ExpectMinidumpMemoryDescriptorAndContents(&expected.Stack,
                                                   observed_stack,
                                                   file_writer.string(),
                                                   kMemoryValue1,
                                                   false));
-    ASSERT_NO_FATAL_FAILURE(ExpectMinidumpContextX86(kSeed1, observed_context));
+    ASSERT_NO_FATAL_FAILURE(
+        ExpectMinidumpContextX86(kSeed1, observed_context, false));
     ASSERT_NO_FATAL_FAILURE(ExpectMinidumpMemoryDescriptor(
         observed_stack, &memory_list->MemoryRanges[1]));
   }
 
   {
     SCOPED_TRACE("thread 2");
 
     MINIDUMP_THREAD expected = {};
     expected.ThreadId = kThreadID2;
     expected.SuspendCount = kSuspendCount2;
@@ skipping 12 matching lines @@
                      file_writer.string(),
                      &observed_stack,
                      reinterpret_cast<const void**>(&observed_context)));
 
     ASSERT_NO_FATAL_FAILURE(
         ExpectMinidumpMemoryDescriptorAndContents(&expected.Stack,
                                                   observed_stack,
                                                   file_writer.string(),
                                                   kMemoryValue2,
                                                   true));
-    ASSERT_NO_FATAL_FAILURE(ExpectMinidumpContextX86(kSeed2, observed_context));
+    ASSERT_NO_FATAL_FAILURE(
+        ExpectMinidumpContextX86(kSeed2, observed_context, false));
     ASSERT_NO_FATAL_FAILURE(ExpectMinidumpMemoryDescriptor(
         observed_stack, &memory_list->MemoryRanges[2]));
   }
 }
 
 TEST(MinidumpThreadWriterDeathTest, NoContext) {
   MinidumpFileWriter minidump_file_writer;
   auto thread_list_writer = make_scoped_ptr(new MinidumpThreadListWriter());
 
   auto thread_writer = make_scoped_ptr(new MinidumpThreadWriter());
 
   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