Add FileReaderInterface. Move StringFileWriter to StringFile and

minidump/minidump_module_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 12 matching lines @@
 #include "base/format_macros.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "gtest/gtest.h"
 #include "minidump/minidump_extensions.h"
 #include "minidump/minidump_file_writer.h"
 #include "minidump/test/minidump_file_writer_test_util.h"
 #include "minidump/test/minidump_string_writer_test_util.h"
 #include "minidump/test/minidump_writable_test_util.h"
 #include "snapshot/test/test_module_snapshot.h"
-#include "util/file/string_file_writer.h"
+#include "util/file/string_file.h"
 #include "util/misc/uuid.h"
 #include "util/stdlib/pointer_container.h"
 
 namespace crashpad {
 namespace test {
 namespace {
 
 void GetModuleListStream(const std::string& file_contents,
                          const MINIDUMP_MODULE_LIST** module_list) {
   const size_t kDirectoryOffset = sizeof(MINIDUMP_HEADER);
@@ skipping 17 matching lines @@
       file_contents, directory[0].Location);
   ASSERT_TRUE(module_list);
 }
 
 TEST(MinidumpModuleWriter, EmptyModuleList) {
   MinidumpFileWriter minidump_file_writer;
   auto module_list_writer = make_scoped_ptr(new MinidumpModuleListWriter());
 
   minidump_file_writer.AddStream(module_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_MODULE_LIST),
-            file_writer.string().size());
+            string_file.string().size());
 
   const MINIDUMP_MODULE_LIST* module_list = nullptr;
   ASSERT_NO_FATAL_FAILURE(
-      GetModuleListStream(file_writer.string(), &module_list));
+      GetModuleListStream(string_file.string(), &module_list));
 
   EXPECT_EQ(0u, module_list->NumberOfModules);
 }
 
 // If |expected_pdb_name| is not nullptr, |codeview_record| is used to locate a
 // CodeView record in |file_contents|, and its fields are compared against the
 // the |expected_pdb_*| values. If |expected_pdb_uuid| is supplied, the CodeView
 // record must be a PDB 7.0 link, otherwise, it must be a PDB 2.0 link. If
 // |expected_pdb_name| is nullptr, |codeview_record| must not point to anything.
 void ExpectCodeViewRecord(const MINIDUMP_LOCATION_DESCRIPTOR* codeview_record,
@@ skipping 184 matching lines @@
   auto module_list_writer = make_scoped_ptr(new MinidumpModuleListWriter());
 
   const char kModuleName[] = "test_executable";
 
   auto module_writer = make_scoped_ptr(new MinidumpModuleWriter());
   module_writer->SetName(kModuleName);
 
   module_list_writer->AddModule(module_writer.Pass());
   minidump_file_writer.AddStream(module_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_GT(file_writer.string().size(),
+  ASSERT_GT(string_file.string().size(),
             sizeof(MINIDUMP_HEADER) + sizeof(MINIDUMP_DIRECTORY) +
                 sizeof(MINIDUMP_MODULE_LIST) + 1 * sizeof(MINIDUMP_MODULE));
 
   const MINIDUMP_MODULE_LIST* module_list = nullptr;
   ASSERT_NO_FATAL_FAILURE(
-      GetModuleListStream(file_writer.string(), &module_list));
+      GetModuleListStream(string_file.string(), &module_list));
 
   EXPECT_EQ(1u, module_list->NumberOfModules);
 
   MINIDUMP_MODULE expected = {};
   ASSERT_NO_FATAL_FAILURE(ExpectModule(&expected,
                                        &module_list->Modules[0],
-                                       file_writer.string(),
+                                       string_file.string(),
                                        kModuleName,
                                        nullptr,
                                        nullptr,
                                        0,
                                        0,
                                        nullptr,
                                        0,
                                        false));
 }
 
@@ skipping 54 matching lines @@
 
   auto misc_debug_writer =
       make_scoped_ptr(new MinidumpModuleMiscDebugRecordWriter());
   misc_debug_writer->SetDataType(kDebugType);
   misc_debug_writer->SetData(kDebugName, kDebugUTF16);
   module_writer->SetMiscDebugRecord(misc_debug_writer.Pass());
 
   module_list_writer->AddModule(module_writer.Pass());
   minidump_file_writer.AddStream(module_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_GT(file_writer.string().size(),
+  ASSERT_GT(string_file.string().size(),
             sizeof(MINIDUMP_HEADER) + sizeof(MINIDUMP_DIRECTORY) +
                 sizeof(MINIDUMP_MODULE_LIST) + 1 * sizeof(MINIDUMP_MODULE));
 
   const MINIDUMP_MODULE_LIST* module_list = nullptr;
   ASSERT_NO_FATAL_FAILURE(
-      GetModuleListStream(file_writer.string(), &module_list));
+      GetModuleListStream(string_file.string(), &module_list));
 
   EXPECT_EQ(1u, module_list->NumberOfModules);
 
   MINIDUMP_MODULE expected = {};
   expected.BaseOfImage = kModuleBase;
   expected.SizeOfImage = kModuleSize;
   expected.CheckSum = kChecksum;
   expected.TimeDateStamp = kTimestamp;
   expected.VersionInfo.dwFileVersionMS = kFileVersionMS;
   expected.VersionInfo.dwFileVersionLS = kFileVersionLS;
   expected.VersionInfo.dwProductVersionMS = kProductVersionMS;
   expected.VersionInfo.dwProductVersionLS = kProductVersionLS;
   expected.VersionInfo.dwFileFlagsMask = kFileFlagsMask;
   expected.VersionInfo.dwFileFlags = kFileFlags;
   expected.VersionInfo.dwFileOS = kFileOS;
   expected.VersionInfo.dwFileType = kFileType;
   expected.VersionInfo.dwFileSubtype = kFileSubtype;
 
   ASSERT_NO_FATAL_FAILURE(ExpectModule(&expected,
                                        &module_list->Modules[0],
-                                       file_writer.string(),
+                                       string_file.string(),
                                        kModuleName,
                                        kPDBName,
                                        &pdb_uuid,
                                        0,
                                        kPDBAge,
                                        kDebugName,
                                        kDebugType,
                                        kDebugUTF16));
 }
 
@@ skipping 24 matching lines @@
 
   auto misc_debug_writer =
       make_scoped_ptr(new MinidumpModuleMiscDebugRecordWriter());
   misc_debug_writer->SetDataType(kDebugType);
   misc_debug_writer->SetData(kDebugName, kDebugUTF16);
   module_writer->SetMiscDebugRecord(misc_debug_writer.Pass());
 
   module_list_writer->AddModule(module_writer.Pass());
   minidump_file_writer.AddStream(module_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_GT(file_writer.string().size(),
+  ASSERT_GT(string_file.string().size(),
             sizeof(MINIDUMP_HEADER) + sizeof(MINIDUMP_DIRECTORY) +
                 sizeof(MINIDUMP_MODULE_LIST) + 1 * sizeof(MINIDUMP_MODULE));
 
   const MINIDUMP_MODULE_LIST* module_list = nullptr;
   ASSERT_NO_FATAL_FAILURE(
-      GetModuleListStream(file_writer.string(), &module_list));
+      GetModuleListStream(string_file.string(), &module_list));
 
   EXPECT_EQ(1u, module_list->NumberOfModules);
 
   MINIDUMP_MODULE expected = {};
 
   ASSERT_NO_FATAL_FAILURE(ExpectModule(&expected,
                                        &module_list->Modules[0],
-                                       file_writer.string(),
+                                       string_file.string(),
                                        kModuleName,
                                        kPDBName,
                                        nullptr,
                                        kPDBTimestamp,
                                        kPDBAge,
                                        kDebugName,
                                        kDebugType,
                                        kDebugUTF16));
 }
 
@@ skipping 54 matching lines @@
   auto codeview_pdb70_writer_2 =
       make_scoped_ptr(new MinidumpModuleCodeViewRecordPDB20Writer());
   codeview_pdb70_writer_2->SetPDBName(kPDBName2);
   codeview_pdb70_writer_2->SetTimestampAndAge(kPDBTimestamp2, kPDBAge2);
   module_writer_2->SetCodeViewRecord(codeview_pdb70_writer_2.Pass());
 
   module_list_writer->AddModule(module_writer_2.Pass());
 
   minidump_file_writer.AddStream(module_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_GT(file_writer.string().size(),
+  ASSERT_GT(string_file.string().size(),
             sizeof(MINIDUMP_HEADER) + sizeof(MINIDUMP_DIRECTORY) +
                 sizeof(MINIDUMP_MODULE_LIST) + 1 * sizeof(MINIDUMP_MODULE));
 
   const MINIDUMP_MODULE_LIST* module_list = nullptr;
   ASSERT_NO_FATAL_FAILURE(
-      GetModuleListStream(file_writer.string(), &module_list));
+      GetModuleListStream(string_file.string(), &module_list));
 
   EXPECT_EQ(3u, module_list->NumberOfModules);
 
   MINIDUMP_MODULE expected = {};
 
   {
     SCOPED_TRACE("module 0");
 
     expected.BaseOfImage = kModuleBase0;
     expected.SizeOfImage = kModuleSize0;
 
     ASSERT_NO_FATAL_FAILURE(ExpectModule(&expected,
                                          &module_list->Modules[0],
-                                         file_writer.string(),
+                                         string_file.string(),
                                          kModuleName0,
                                          kPDBName0,
                                          &pdb_uuid_0,
                                          0,
                                          kPDBAge0,
                                          nullptr,
                                          0,
                                          false));
   }
 
   {
     SCOPED_TRACE("module 1");
 
     expected.BaseOfImage = kModuleBase1;
     expected.SizeOfImage = kModuleSize1;
 
     ASSERT_NO_FATAL_FAILURE(ExpectModule(&expected,
                                          &module_list->Modules[1],
-                                         file_writer.string(),
+                                         string_file.string(),
                                          kModuleName1,
                                          nullptr,
                                          nullptr,
                                          0,
                                          0,
                                          nullptr,
                                          0,
                                          false));
   }
 
   {
     SCOPED_TRACE("module 2");
 
     expected.BaseOfImage = kModuleBase2;
     expected.SizeOfImage = kModuleSize2;
 
     ASSERT_NO_FATAL_FAILURE(ExpectModule(&expected,
                                          &module_list->Modules[2],
-                                         file_writer.string(),
+                                         string_file.string(),
                                          kModuleName2,
                                          kPDBName2,
                                          nullptr,
                                          kPDBTimestamp2,
                                          kPDBAge2,
                                          nullptr,
                                          0,
                                          false));
   }
 }
@@ skipping 98 matching lines @@
                                                    uuids[index]);
     module_snapshots.push_back(module_snapshot);
   }
 
   auto module_list_writer = make_scoped_ptr(new MinidumpModuleListWriter());
   module_list_writer->InitializeFromSnapshot(module_snapshots);
 
   MinidumpFileWriter minidump_file_writer;
   minidump_file_writer.AddStream(module_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_MODULE_LIST* module_list = nullptr;
   ASSERT_NO_FATAL_FAILURE(
-      GetModuleListStream(file_writer.string(), &module_list));
+      GetModuleListStream(string_file.string(), &module_list));
 
   ASSERT_EQ(3u, module_list->NumberOfModules);
 
   for (size_t index = 0; index < module_list->NumberOfModules; ++index) {
     SCOPED_TRACE(base::StringPrintf("index %" PRIuS, index));
     ASSERT_NO_FATAL_FAILURE(ExpectModule(&expect_modules[index],
                                          &module_list->Modules[index],
-                                         file_writer.string(),
+                                         string_file.string(),
                                          module_paths[index],
                                          module_names[index],
                                          &uuids[index],
                                          0,
                                          0,
                                          nullptr,
                                          0,
                                          false));
   }
 }
 
 TEST(MinidumpModuleWriterDeathTest, NoModuleName) {
   MinidumpFileWriter minidump_file_writer;
   auto module_list_writer = make_scoped_ptr(new MinidumpModuleListWriter());
   auto module_writer = make_scoped_ptr(new MinidumpModuleWriter());
   module_list_writer->AddModule(module_writer.Pass());
   minidump_file_writer.AddStream(module_list_writer.Pass());
 
-  StringFileWriter file_writer;
-  ASSERT_DEATH(minidump_file_writer.WriteEverything(&file_writer), "name_");
+  StringFile string_file;
+  ASSERT_DEATH(minidump_file_writer.WriteEverything(&string_file), "name_");
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace crashpad