Add FileReaderInterface. Move StringFileWriter to StringFile and

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 15 matching lines @@
 #include "minidump/minidump_memory_writer.h"
 #include "minidump/minidump_file_writer.h"
 #include "minidump/minidump_thread_id_map.h"
 #include "minidump/test/minidump_context_test_util.h"
 #include "minidump/test/minidump_memory_writer_test_util.h"
 #include "minidump/test/minidump_file_writer_test_util.h"
 #include "minidump/test/minidump_writable_test_util.h"
 #include "snapshot/test/test_cpu_context.h"
 #include "snapshot/test/test_memory_snapshot.h"
 #include "snapshot/test/test_thread_snapshot.h"
-#include "util/file/string_file_writer.h"
+#include "util/file/string_file.h"
 
 namespace crashpad {
 namespace test {
 namespace {
 
 // This returns the MINIDUMP_THREAD_LIST stream in |thread_list|. If
 // |memory_list| is not nullptr, a MINIDUMP_MEMORY_LIST stream is also expected
 // in |file_contents|, and that stream will be returned in |memory_list|.
 void GetThreadListStream(const std::string& file_contents,
                          const MINIDUMP_THREAD_LIST** thread_list,
@@ skipping 28 matching lines @@
     ASSERT_TRUE(*memory_list);
   }
 }
 
 TEST(MinidumpThreadWriter, EmptyThreadList) {
   MinidumpFileWriter minidump_file_writer;
   auto thread_list_writer = make_scoped_ptr(new MinidumpThreadListWriter());
 
   minidump_file_writer.AddStream(thread_list_writer.Pass());
 
-  StringFileWriter file_writer;
-  ASSERT_TRUE(minidump_file_writer.WriteEverything(&file_writer));
+  StringFile string_file;
+  ASSERT_TRUE(minidump_file_writer.WriteEverything(&string_file));
 
   ASSERT_EQ(sizeof(MINIDUMP_HEADER) + sizeof(MINIDUMP_DIRECTORY) +
                 sizeof(MINIDUMP_THREAD_LIST),
-            file_writer.string().size());
+            string_file.string().size());
 
   const MINIDUMP_THREAD_LIST* thread_list = nullptr;
   ASSERT_NO_FATAL_FAILURE(
-      GetThreadListStream(file_writer.string(), &thread_list, nullptr));
+      GetThreadListStream(string_file.string(), &thread_list, nullptr));
 
   EXPECT_EQ(0u, thread_list->NumberOfThreads);
 }
 
 // The MINIDUMP_THREADs |expected| and |observed| are compared against each
 // other using gtest assertions. If |stack| is not nullptr, |observed| is
 // expected to contain a populated MINIDUMP_MEMORY_DESCRIPTOR in its Stack
 // field, otherwise, its Stack field is expected to be zeroed out. The memory
 // descriptor will be placed in |stack|. |observed| must contain a populated
 // ThreadContext field. The context will be recovered from |file_contents| and
@@ skipping 50 matching lines @@
   thread_writer->SetPriority(kPriority);
   thread_writer->SetTEB(kTEB);
 
   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.Pass());
   minidump_file_writer.AddStream(thread_list_writer.Pass());
 
-  StringFileWriter file_writer;
-  ASSERT_TRUE(minidump_file_writer.WriteEverything(&file_writer));
+  StringFile string_file;
+  ASSERT_TRUE(minidump_file_writer.WriteEverything(&string_file));
 
   ASSERT_EQ(sizeof(MINIDUMP_HEADER) + sizeof(MINIDUMP_DIRECTORY) +
                 sizeof(MINIDUMP_THREAD_LIST) + 1 * sizeof(MINIDUMP_THREAD) +
                 1 * sizeof(MinidumpContextX86),
-            file_writer.string().size());
+            string_file.string().size());
 
   const MINIDUMP_THREAD_LIST* thread_list = nullptr;
   ASSERT_NO_FATAL_FAILURE(
-      GetThreadListStream(file_writer.string(), &thread_list, nullptr));
+      GetThreadListStream(string_file.string(), &thread_list, nullptr));
 
   EXPECT_EQ(1u, thread_list->NumberOfThreads);
 
   MINIDUMP_THREAD expected = {};
   expected.ThreadId = kThreadID;
   expected.SuspendCount = kSuspendCount;
   expected.PriorityClass = kPriorityClass;
   expected.Priority = kPriority;
   expected.Teb = kTEB;
   expected.ThreadContext.DataSize = sizeof(MinidumpContextX86);
 
   const MinidumpContextX86* observed_context = nullptr;
   ASSERT_NO_FATAL_FAILURE(
       ExpectThread(&expected,
                    &thread_list->Threads[0],
-                   file_writer.string(),
+                   string_file.string(),
                    nullptr,
                    reinterpret_cast<const void**>(&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());
@@ skipping 20 matching lines @@
   thread_writer->SetStack(memory_writer.Pass());
 
   MSVC_SUPPRESS_WARNING(4316);  // Object allocated on heap may not be aligned.
   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.Pass());
   minidump_file_writer.AddStream(thread_list_writer.Pass());
 
-  StringFileWriter file_writer;
-  ASSERT_TRUE(minidump_file_writer.WriteEverything(&file_writer));
+  StringFile string_file;
+  ASSERT_TRUE(minidump_file_writer.WriteEverything(&string_file));
 
   ASSERT_EQ(sizeof(MINIDUMP_HEADER) + sizeof(MINIDUMP_DIRECTORY) +
                 sizeof(MINIDUMP_THREAD_LIST) + 1 * sizeof(MINIDUMP_THREAD) +
                 1 * sizeof(MinidumpContextAMD64) + kMemorySize,
-            file_writer.string().size());
+            string_file.string().size());
 
   const MINIDUMP_THREAD_LIST* thread_list = nullptr;
   ASSERT_NO_FATAL_FAILURE(
-      GetThreadListStream(file_writer.string(), &thread_list, nullptr));
+      GetThreadListStream(string_file.string(), &thread_list, nullptr));
 
   EXPECT_EQ(1u, thread_list->NumberOfThreads);
 
   MINIDUMP_THREAD expected = {};
   expected.ThreadId = kThreadID;
   expected.SuspendCount = kSuspendCount;
   expected.PriorityClass = kPriorityClass;
   expected.Priority = kPriority;
   expected.Teb = kTEB;
   expected.Stack.StartOfMemoryRange = kMemoryBase;
   expected.Stack.Memory.DataSize = kMemorySize;
   expected.ThreadContext.DataSize = sizeof(MinidumpContextAMD64);
 
   const MINIDUMP_MEMORY_DESCRIPTOR* observed_stack = nullptr;
   const MinidumpContextAMD64* observed_context = nullptr;
   ASSERT_NO_FATAL_FAILURE(
       ExpectThread(&expected,
                    &thread_list->Threads[0],
-                   file_writer.string(),
+                   string_file.string(),
                    &observed_stack,
                    reinterpret_cast<const void**>(&observed_context)));
 
   ASSERT_NO_FATAL_FAILURE(
       ExpectMinidumpMemoryDescriptorAndContents(&expected.Stack,
                                                 observed_stack,
-                                                file_writer.string(),
+                                                string_file.string(),
                                                 kMemoryValue,
                                                 true));
   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());
@@ skipping 76 matching lines @@
 
   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.Pass());
 
   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));
+  StringFile string_file;
+  ASSERT_TRUE(minidump_file_writer.WriteEverything(&string_file));
 
   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
-            file_writer.string().size());
+            string_file.string().size());
 
   const MINIDUMP_THREAD_LIST* thread_list = nullptr;
   const MINIDUMP_MEMORY_LIST* memory_list = nullptr;
   ASSERT_NO_FATAL_FAILURE(
-      GetThreadListStream(file_writer.string(), &thread_list, &memory_list));
+      GetThreadListStream(string_file.string(), &thread_list, &memory_list));
 
   EXPECT_EQ(3u, thread_list->NumberOfThreads);
   EXPECT_EQ(3u, memory_list->NumberOfMemoryRanges);
 
   {
     SCOPED_TRACE("thread 0");
 
     MINIDUMP_THREAD expected = {};
     expected.ThreadId = kThreadID0;
     expected.SuspendCount = kSuspendCount0;
     expected.PriorityClass = kPriorityClass0;
     expected.Priority = kPriority0;
     expected.Teb = kTEB0;
     expected.Stack.StartOfMemoryRange = kMemoryBase0;
     expected.Stack.Memory.DataSize = kMemorySize0;
     expected.ThreadContext.DataSize = sizeof(MinidumpContextX86);
 
     const MINIDUMP_MEMORY_DESCRIPTOR* observed_stack = nullptr;
     const MinidumpContextX86* observed_context = nullptr;
     ASSERT_NO_FATAL_FAILURE(
         ExpectThread(&expected,
                      &thread_list->Threads[0],
-                     file_writer.string(),
+                     string_file.string(),
                      &observed_stack,
                      reinterpret_cast<const void**>(&observed_context)));
 
     ASSERT_NO_FATAL_FAILURE(
         ExpectMinidumpMemoryDescriptorAndContents(&expected.Stack,
                                                   observed_stack,
-                                                  file_writer.string(),
+                                                  string_file.string(),
                                                   kMemoryValue0,
                                                   false));
     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;
     expected.PriorityClass = kPriorityClass1;
     expected.Priority = kPriority1;
     expected.Teb = kTEB1;
     expected.Stack.StartOfMemoryRange = kMemoryBase1;
     expected.Stack.Memory.DataSize = kMemorySize1;
     expected.ThreadContext.DataSize = sizeof(MinidumpContextX86);
 
     const MINIDUMP_MEMORY_DESCRIPTOR* observed_stack = nullptr;
     const MinidumpContextX86* observed_context = nullptr;
     ASSERT_NO_FATAL_FAILURE(
         ExpectThread(&expected,
                      &thread_list->Threads[1],
-                     file_writer.string(),
+                     string_file.string(),
                      &observed_stack,
                      reinterpret_cast<const void**>(&observed_context)));
 
     ASSERT_NO_FATAL_FAILURE(
         ExpectMinidumpMemoryDescriptorAndContents(&expected.Stack,
                                                   observed_stack,
-                                                  file_writer.string(),
+                                                  string_file.string(),
                                                   kMemoryValue1,
                                                   false));
     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;
     expected.PriorityClass = kPriorityClass2;
     expected.Priority = kPriority2;
     expected.Teb = kTEB2;
     expected.Stack.StartOfMemoryRange = kMemoryBase2;
     expected.Stack.Memory.DataSize = kMemorySize2;
     expected.ThreadContext.DataSize = sizeof(MinidumpContextX86);
 
     const MINIDUMP_MEMORY_DESCRIPTOR* observed_stack = nullptr;
     const MinidumpContextX86* observed_context = nullptr;
     ASSERT_NO_FATAL_FAILURE(
         ExpectThread(&expected,
                      &thread_list->Threads[2],
-                     file_writer.string(),
+                     string_file.string(),
                      &observed_stack,
                      reinterpret_cast<const void**>(&observed_context)));
 
     ASSERT_NO_FATAL_FAILURE(
         ExpectMinidumpMemoryDescriptorAndContents(&expected.Stack,
                                                   observed_stack,
-                                                  file_writer.string(),
+                                                  string_file.string(),
                                                   kMemoryValue2,
                                                   true));
     ASSERT_NO_FATAL_FAILURE(
         ExpectMinidumpContextX86(kSeed2, observed_context, false));
     ASSERT_NO_FATAL_FAILURE(ExpectMinidumpMemoryDescriptor(
         observed_stack, &memory_list->MemoryRanges[2]));
   }
 }
 
 struct InitializeFromSnapshotX86Traits {
@@ skipping 112 matching lines @@
   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());
   MinidumpThreadIDMap thread_id_map;
   thread_list_writer->InitializeFromSnapshot(thread_snapshots, &thread_id_map);
 
   MinidumpFileWriter minidump_file_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));
+  StringFile string_file;
+  ASSERT_TRUE(minidump_file_writer.WriteEverything(&string_file));
 
   const MINIDUMP_THREAD_LIST* thread_list = nullptr;
   const MINIDUMP_MEMORY_LIST* memory_list = nullptr;
   ASSERT_NO_FATAL_FAILURE(
-      GetThreadListStream(file_writer.string(), &thread_list, &memory_list));
+      GetThreadListStream(string_file.string(), &thread_list, &memory_list));
 
   ASSERT_EQ(3u, thread_list->NumberOfThreads);
   ASSERT_EQ(2u, memory_list->NumberOfMemoryRanges);
 
   size_t memory_index = 0;
   for (size_t index = 0; index < thread_list->NumberOfThreads; ++index) {
     SCOPED_TRACE(base::StringPrintf("index %" PRIuS, index));
 
     const MINIDUMP_MEMORY_DESCRIPTOR* observed_stack = nullptr;
     const MINIDUMP_MEMORY_DESCRIPTOR** observed_stack_p =
         expect_threads[index].Stack.Memory.DataSize ? &observed_stack : nullptr;
     const MinidumpContextType* observed_context = nullptr;
     ASSERT_NO_FATAL_FAILURE(
         ExpectThread(&expect_threads[index],
                      &thread_list->Threads[index],
-                     file_writer.string(),
+                     string_file.string(),
                      observed_stack_p,
                      reinterpret_cast<const void**>(&observed_context)));
 
     ASSERT_NO_FATAL_FAILURE(Traits::ExpectMinidumpContext(
         context_seeds[index], observed_context, true));
 
     if (observed_stack_p) {
       ASSERT_NO_FATAL_FAILURE(ExpectMinidumpMemoryDescriptorAndContents(
           &expect_threads[index].Stack,
           observed_stack,
-          file_writer.string(),
+          string_file.string(),
           memory_values[index],
           index == thread_list->NumberOfThreads - 1));
 
       ASSERT_NO_FATAL_FAILURE(ExpectMinidumpMemoryDescriptor(
           observed_stack, &memory_list->MemoryRanges[memory_index]));
 
       ++memory_index;
     }
   }
 }
@@ skipping 12 matching lines @@
 
 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_");
+  StringFile string_file;
+  ASSERT_DEATH(minidump_file_writer.WriteEverything(&string_file), "context_");
 }
 
 TEST(MinidumpThreadWriterDeathTest, InitializeFromSnapshot_NoContext) {
   ASSERT_DEATH(
       RunInitializeFromSnapshotTest<InitializeFromSnapshotNoContextTraits>(
           false), "context_");
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace crashpad