Add FileReaderInterface. Move StringFileWriter to StringFile and

minidump/minidump_memory_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 11 matching lines @@
 #include "base/format_macros.h"
 #include "base/strings/stringprintf.h"
 #include "gtest/gtest.h"
 #include "minidump/minidump_extensions.h"
 #include "minidump/minidump_file_writer.h"
 #include "minidump/minidump_stream_writer.h"
 #include "minidump/test/minidump_file_writer_test_util.h"
 #include "minidump/test/minidump_memory_writer_test_util.h"
 #include "minidump/test/minidump_writable_test_util.h"
 #include "snapshot/test/test_memory_snapshot.h"
-#include "util/file/string_file_writer.h"
+#include "util/file/string_file.h"
 #include "util/stdlib/pointer_container.h"
 
 namespace crashpad {
 namespace test {
 namespace {
 
 const MinidumpStreamType kBogusStreamType =
     static_cast<MinidumpStreamType>(1234);
 
 // expected_streams is the expected number of streams in the file. The memory
@@ skipping 32 matching lines @@
       file_contents, directory[directory_index].Location);
   ASSERT_TRUE(memory_list);
 }
 
 TEST(MinidumpMemoryWriter, EmptyMemoryList) {
   MinidumpFileWriter minidump_file_writer;
   auto memory_list_writer = make_scoped_ptr(new MinidumpMemoryListWriter());
 
   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) + sizeof(MINIDUMP_DIRECTORY) +
                 sizeof(MINIDUMP_MEMORY_LIST),
-            file_writer.string().size());
+            string_file.string().size());
 
   const MINIDUMP_MEMORY_LIST* memory_list = nullptr;
   ASSERT_NO_FATAL_FAILURE(
-      GetMemoryListStream(file_writer.string(), &memory_list, 1));
+      GetMemoryListStream(string_file.string(), &memory_list, 1));
 
   EXPECT_EQ(0u, memory_list->NumberOfMemoryRanges);
 }
 
 TEST(MinidumpMemoryWriter, OneMemoryRegion) {
   MinidumpFileWriter minidump_file_writer;
   auto memory_list_writer = make_scoped_ptr(new MinidumpMemoryListWriter());
 
   const uint64_t kBaseAddress = 0xfedcba9876543210;
   const uint64_t kSize = 0x1000;
   const uint8_t kValue = 'm';
 
   auto memory_writer = make_scoped_ptr(
       new TestMinidumpMemoryWriter(kBaseAddress, kSize, kValue));
   memory_list_writer->AddMemory(memory_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_MEMORY_LIST* memory_list = nullptr;
   ASSERT_NO_FATAL_FAILURE(
-      GetMemoryListStream(file_writer.string(), &memory_list, 1));
+      GetMemoryListStream(string_file.string(), &memory_list, 1));
 
   MINIDUMP_MEMORY_DESCRIPTOR expected;
   expected.StartOfMemoryRange = kBaseAddress;
   expected.Memory.DataSize = kSize;
   expected.Memory.Rva =
       sizeof(MINIDUMP_HEADER) + sizeof(MINIDUMP_DIRECTORY) +
       sizeof(MINIDUMP_MEMORY_LIST) +
       memory_list->NumberOfMemoryRanges * sizeof(MINIDUMP_MEMORY_DESCRIPTOR);
   ExpectMinidumpMemoryDescriptorAndContents(&expected,
                                             &memory_list->MemoryRanges[0],
-                                            file_writer.string(),
+                                            string_file.string(),
                                             kValue,
                                             true);
 }
 
 TEST(MinidumpMemoryWriter, TwoMemoryRegions) {
   MinidumpFileWriter minidump_file_writer;
   auto memory_list_writer = make_scoped_ptr(new MinidumpMemoryListWriter());
 
   const uint64_t kBaseAddress0 = 0xc0ffee;
   const uint64_t kSize0 = 0x0100;
   const uint8_t kValue0 = '6';
   const uint64_t kBaseAddress1 = 0xfac00fac;
   const uint64_t kSize1 = 0x0200;
   const uint8_t kValue1 = '!';
 
   auto memory_writer_0 = make_scoped_ptr(
       new TestMinidumpMemoryWriter(kBaseAddress0, kSize0, kValue0));
   memory_list_writer->AddMemory(memory_writer_0.Pass());
   auto memory_writer_1 = make_scoped_ptr(
       new TestMinidumpMemoryWriter(kBaseAddress1, kSize1, kValue1));
   memory_list_writer->AddMemory(memory_writer_1.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_MEMORY_LIST* memory_list = nullptr;
   ASSERT_NO_FATAL_FAILURE(
-      GetMemoryListStream(file_writer.string(), &memory_list, 1));
+      GetMemoryListStream(string_file.string(), &memory_list, 1));
 
   EXPECT_EQ(2u, memory_list->NumberOfMemoryRanges);
 
   MINIDUMP_MEMORY_DESCRIPTOR expected;
 
   {
     SCOPED_TRACE("region 0");
 
     expected.StartOfMemoryRange = kBaseAddress0;
     expected.Memory.DataSize = kSize0;
     expected.Memory.Rva =
         sizeof(MINIDUMP_HEADER) + sizeof(MINIDUMP_DIRECTORY) +
         sizeof(MINIDUMP_MEMORY_LIST) +
         memory_list->NumberOfMemoryRanges * sizeof(MINIDUMP_MEMORY_DESCRIPTOR);
     ExpectMinidumpMemoryDescriptorAndContents(&expected,
                                               &memory_list->MemoryRanges[0],
-                                              file_writer.string(),
+                                              string_file.string(),
                                               kValue0,
                                               false);
   }
 
   {
     SCOPED_TRACE("region 1");
 
     expected.StartOfMemoryRange = kBaseAddress1;
     expected.Memory.DataSize = kSize1;
     expected.Memory.Rva = memory_list->MemoryRanges[0].Memory.Rva +
                           memory_list->MemoryRanges[0].Memory.DataSize;
     ExpectMinidumpMemoryDescriptorAndContents(&expected,
                                               &memory_list->MemoryRanges[1],
-                                              file_writer.string(),
+                                              string_file.string(),
                                               kValue1,
                                               true);
   }
 }
 
 class TestMemoryStream final : public internal::MinidumpStreamWriter {
  public:
   TestMemoryStream(uint64_t base_address, size_t size, uint8_t value)
       : MinidumpStreamWriter(), memory_(base_address, size, value) {}
 
@@ skipping 52 matching lines @@
   const uint64_t kBaseAddress1 = 0x2000;
   const size_t kSize1 = 0x0400;
   const uint8_t kValue1 = 'm';
 
   auto memory_writer = make_scoped_ptr(
       new TestMinidumpMemoryWriter(kBaseAddress1, kSize1, kValue1));
   memory_list_writer->AddMemory(memory_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_MEMORY_LIST* memory_list = nullptr;
   ASSERT_NO_FATAL_FAILURE(
-      GetMemoryListStream(file_writer.string(), &memory_list, 2));
+      GetMemoryListStream(string_file.string(), &memory_list, 2));
 
   EXPECT_EQ(2u, memory_list->NumberOfMemoryRanges);
 
   MINIDUMP_MEMORY_DESCRIPTOR expected;
 
   {
     SCOPED_TRACE("region 0");
 
     expected.StartOfMemoryRange = kBaseAddress0;
     expected.Memory.DataSize = kSize0;
     expected.Memory.Rva =
         sizeof(MINIDUMP_HEADER) + 2 * sizeof(MINIDUMP_DIRECTORY) +
         sizeof(MINIDUMP_MEMORY_LIST) +
         memory_list->NumberOfMemoryRanges * sizeof(MINIDUMP_MEMORY_DESCRIPTOR);
     ExpectMinidumpMemoryDescriptorAndContents(&expected,
                                               &memory_list->MemoryRanges[0],
-                                              file_writer.string(),
+                                              string_file.string(),
                                               kValue0,
                                               false);
   }
 
   {
     SCOPED_TRACE("region 1");
 
     expected.StartOfMemoryRange = kBaseAddress1;
     expected.Memory.DataSize = kSize1;
     expected.Memory.Rva = memory_list->MemoryRanges[0].Memory.Rva +
                           memory_list->MemoryRanges[0].Memory.DataSize;
     ExpectMinidumpMemoryDescriptorAndContents(&expected,
                                               &memory_list->MemoryRanges[1],
-                                              file_writer.string(),
+                                              string_file.string(),
                                               kValue1,
                                               true);
   }
 }
 
 TEST(MinidumpMemoryWriter, AddFromSnapshot) {
   MINIDUMP_MEMORY_DESCRIPTOR expect_memory_descriptors[3] = {};
   uint8_t values[arraysize(expect_memory_descriptors)] = {};
 
   expect_memory_descriptors[0].StartOfMemoryRange = 0;
@@ skipping 21 matching lines @@
     memory_snapshot->SetValue(values[index]);
     memory_snapshots.push_back(memory_snapshot);
   }
 
   auto memory_list_writer = make_scoped_ptr(new MinidumpMemoryListWriter());
   memory_list_writer->AddFromSnapshot(memory_snapshots);
 
   MinidumpFileWriter minidump_file_writer;
   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_MEMORY_LIST* memory_list = nullptr;
   ASSERT_NO_FATAL_FAILURE(
-      GetMemoryListStream(file_writer.string(), &memory_list, 1));
+      GetMemoryListStream(string_file.string(), &memory_list, 1));
 
   ASSERT_EQ(3u, memory_list->NumberOfMemoryRanges);
 
   for (size_t index = 0; index < memory_list->NumberOfMemoryRanges; ++index) {
     SCOPED_TRACE(base::StringPrintf("index %" PRIuS, index));
     ExpectMinidumpMemoryDescriptorAndContents(
         &expect_memory_descriptors[index],
         &memory_list->MemoryRanges[index],
-        file_writer.string(),
+        string_file.string(),
         values[index],
         index == memory_list->NumberOfMemoryRanges - 1);
   }
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace crashpad