Add FileReaderInterface. Move StringFileWriter to StringFile and

minidump/minidump_writable_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,
 // 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.
 
 #include "minidump/minidump_writable.h"
 
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "gtest/gtest.h"
-#include "util/file/string_file_writer.h"
+#include "util/file/string_file.h"
 
 namespace crashpad {
 namespace test {
 namespace {
 
 class BaseTestMinidumpWritable : public crashpad::internal::MinidumpWritable {
  public:
   BaseTestMinidumpWritable()
       : MinidumpWritable(),
         children_(),
@@ skipping 105 matching lines @@
     return rv;
   }
 
  private:
   std::string data_;
 
   DISALLOW_COPY_AND_ASSIGN(TestStringMinidumpWritable);
 };
 
 TEST(MinidumpWritable, MinidumpWritable) {
-  StringFileWriter writer;
+  StringFile string_file;
 
   {
     SCOPED_TRACE("empty");
-    writer.Reset();
+    string_file.Reset();
     TestStringMinidumpWritable string_writable;
-    EXPECT_TRUE(string_writable.WriteEverything(&writer));
-    EXPECT_TRUE(writer.string().empty());
+    EXPECT_TRUE(string_writable.WriteEverything(&string_file));
+    EXPECT_TRUE(string_file.string().empty());
     string_writable.Verify();
   }
 
   {
     SCOPED_TRACE("childless");
-    writer.Reset();
+    string_file.Reset();
     TestStringMinidumpWritable string_writable;
     string_writable.SetData("a");
-    EXPECT_TRUE(string_writable.WriteEverything(&writer));
-    EXPECT_EQ(1u, writer.string().size());
-    EXPECT_EQ("a", writer.string());
+    EXPECT_TRUE(string_writable.WriteEverything(&string_file));
+    EXPECT_EQ(1u, string_file.string().size());
+    EXPECT_EQ("a", string_file.string());
     string_writable.Verify();
   }
 
   {
     SCOPED_TRACE("parent-child");
-    writer.Reset();
+    string_file.Reset();
     TestStringMinidumpWritable parent;
     parent.SetData("b");
     TestStringMinidumpWritable child;
     child.SetData("c");
     parent.AddChild(&child);
-    EXPECT_TRUE(parent.WriteEverything(&writer));
-    EXPECT_EQ(5u, writer.string().size());
-    EXPECT_EQ(std::string("b\0\0\0c", 5), writer.string());
+    EXPECT_TRUE(parent.WriteEverything(&string_file));
+    EXPECT_EQ(5u, string_file.string().size());
+    EXPECT_EQ(std::string("b\0\0\0c", 5), string_file.string());
     parent.Verify();
   }
 
   {
     SCOPED_TRACE("base alignment 2");
-    writer.Reset();
+    string_file.Reset();
     TestStringMinidumpWritable parent;
     parent.SetData("de");
     TestStringMinidumpWritable child;
     child.SetData("f");
     parent.AddChild(&child);
-    EXPECT_TRUE(parent.WriteEverything(&writer));
-    EXPECT_EQ(5u, writer.string().size());
-    EXPECT_EQ(std::string("de\0\0f", 5), writer.string());
+    EXPECT_TRUE(parent.WriteEverything(&string_file));
+    EXPECT_EQ(5u, string_file.string().size());
+    EXPECT_EQ(std::string("de\0\0f", 5), string_file.string());
     parent.Verify();
   }
 
   {
     SCOPED_TRACE("base alignment 3");
-    writer.Reset();
+    string_file.Reset();
     TestStringMinidumpWritable parent;
     parent.SetData("ghi");
     TestStringMinidumpWritable child;
     child.SetData("j");
     parent.AddChild(&child);
-    EXPECT_TRUE(parent.WriteEverything(&writer));
-    EXPECT_EQ(5u, writer.string().size());
-    EXPECT_EQ(std::string("ghi\0j", 5), writer.string());
+    EXPECT_TRUE(parent.WriteEverything(&string_file));
+    EXPECT_EQ(5u, string_file.string().size());
+    EXPECT_EQ(std::string("ghi\0j", 5), string_file.string());
     parent.Verify();
   }
 
   {
     SCOPED_TRACE("base alignment 4");
-    writer.Reset();
+    string_file.Reset();
     TestStringMinidumpWritable parent;
     parent.SetData("klmn");
     TestStringMinidumpWritable child;
     child.SetData("o");
     parent.AddChild(&child);
-    EXPECT_TRUE(parent.WriteEverything(&writer));
-    EXPECT_EQ(5u, writer.string().size());
-    EXPECT_EQ("klmno", writer.string());
+    EXPECT_TRUE(parent.WriteEverything(&string_file));
+    EXPECT_EQ(5u, string_file.string().size());
+    EXPECT_EQ("klmno", string_file.string());
     parent.Verify();
   }
 
   {
     SCOPED_TRACE("base alignment 5");
-    writer.Reset();
+    string_file.Reset();
     TestStringMinidumpWritable parent;
     parent.SetData("pqrst");
     TestStringMinidumpWritable child;
     child.SetData("u");
     parent.AddChild(&child);
-    EXPECT_TRUE(parent.WriteEverything(&writer));
-    EXPECT_EQ(9u, writer.string().size());
-    EXPECT_EQ(std::string("pqrst\0\0\0u", 9), writer.string());
+    EXPECT_TRUE(parent.WriteEverything(&string_file));
+    EXPECT_EQ(9u, string_file.string().size());
+    EXPECT_EQ(std::string("pqrst\0\0\0u", 9), string_file.string());
     parent.Verify();
   }
 
   {
     SCOPED_TRACE("two children");
-    writer.Reset();
+    string_file.Reset();
     TestStringMinidumpWritable parent;
     parent.SetData("parent");
     TestStringMinidumpWritable child_0;
     child_0.SetData("child_0");
     parent.AddChild(&child_0);
     TestStringMinidumpWritable child_1;
     child_1.SetData("child_1");
     parent.AddChild(&child_1);
-    EXPECT_TRUE(parent.WriteEverything(&writer));
-    EXPECT_EQ(23u, writer.string().size());
-    EXPECT_EQ(std::string("parent\0\0child_0\0child_1", 23), writer.string());
+    EXPECT_TRUE(parent.WriteEverything(&string_file));
+    EXPECT_EQ(23u, string_file.string().size());
+    EXPECT_EQ(std::string("parent\0\0child_0\0child_1", 23), string_file.string());
     parent.Verify();
   }
 
   {
     SCOPED_TRACE("grandchild");
-    writer.Reset();
+    string_file.Reset();
     TestStringMinidumpWritable parent;
     parent.SetData("parent");
     TestStringMinidumpWritable child;
     child.SetData("child");
     parent.AddChild(&child);
     TestStringMinidumpWritable grandchild;
     grandchild.SetData("grandchild");
     child.AddChild(&grandchild);
-    EXPECT_TRUE(parent.WriteEverything(&writer));
-    EXPECT_EQ(26u, writer.string().size());
+    EXPECT_TRUE(parent.WriteEverything(&string_file));
+    EXPECT_EQ(26u, string_file.string().size());
     EXPECT_EQ(std::string("parent\0\0child\0\0\0grandchild", 26),
-              writer.string());
+              string_file.string());
     parent.Verify();
   }
 
   {
     SCOPED_TRACE("grandchild with empty parent");
-    writer.Reset();
+    string_file.Reset();
     TestStringMinidumpWritable parent;
     TestStringMinidumpWritable child;
     child.SetData("child");
     parent.AddChild(&child);
     TestStringMinidumpWritable grandchild;
     grandchild.SetData("grandchild");
     child.AddChild(&grandchild);
-    EXPECT_TRUE(parent.WriteEverything(&writer));
-    EXPECT_EQ(18u, writer.string().size());
-    EXPECT_EQ(std::string("child\0\0\0grandchild", 18), writer.string());
+    EXPECT_TRUE(parent.WriteEverything(&string_file));
+    EXPECT_EQ(18u, string_file.string().size());
+    EXPECT_EQ(std::string("child\0\0\0grandchild", 18), string_file.string());
     parent.Verify();
   }
 
   {
     SCOPED_TRACE("grandchild with empty child");
-    writer.Reset();
+    string_file.Reset();
     TestStringMinidumpWritable parent;
     parent.SetData("parent");
     TestStringMinidumpWritable child;
     parent.AddChild(&child);
     TestStringMinidumpWritable grandchild;
     grandchild.SetData("grandchild");
     child.AddChild(&grandchild);
-    EXPECT_TRUE(parent.WriteEverything(&writer));
-    EXPECT_EQ(18u, writer.string().size());
-    EXPECT_EQ(std::string("parent\0\0grandchild", 18), writer.string());
+    EXPECT_TRUE(parent.WriteEverything(&string_file));
+    EXPECT_EQ(18u, string_file.string().size());
+    EXPECT_EQ(std::string("parent\0\0grandchild", 18), string_file.string());
     parent.Verify();
   }
 
   {
     SCOPED_TRACE("grandchild with empty grandchild");
-    writer.Reset();
+    string_file.Reset();
     TestStringMinidumpWritable parent;
     parent.SetData("parent");
     TestStringMinidumpWritable child;
     child.SetData("child");
     parent.AddChild(&child);
     TestStringMinidumpWritable grandchild;
     child.AddChild(&grandchild);
-    EXPECT_TRUE(parent.WriteEverything(&writer));
-    EXPECT_EQ(13u, writer.string().size());
-    EXPECT_EQ(std::string("parent\0\0child", 13), writer.string());
+    EXPECT_TRUE(parent.WriteEverything(&string_file));
+    EXPECT_EQ(13u, string_file.string().size());
+    EXPECT_EQ(std::string("parent\0\0child", 13), string_file.string());
     parent.Verify();
   }
 
   {
     SCOPED_TRACE("grandchild with late-phase grandchild");
-    writer.Reset();
+    string_file.Reset();
     TestStringMinidumpWritable parent;
     parent.SetData("parent");
     TestStringMinidumpWritable child;
     child.SetData("child");
     parent.AddChild(&child);
     TestStringMinidumpWritable grandchild;
     grandchild.SetData("grandchild");
     grandchild.SetPhaseLate();
     child.AddChild(&grandchild);
-    EXPECT_TRUE(parent.WriteEverything(&writer));
-    EXPECT_EQ(26u, writer.string().size());
+    EXPECT_TRUE(parent.WriteEverything(&string_file));
+    EXPECT_EQ(26u, string_file.string().size());
     EXPECT_EQ(std::string("parent\0\0child\0\0\0grandchild", 26),
-              writer.string());
+              string_file.string());
     parent.Verify();
   }
 
   {
     SCOPED_TRACE("grandchild with late-phase child");
-    writer.Reset();
+    string_file.Reset();
     TestStringMinidumpWritable parent;
     parent.SetData("parent");
     TestStringMinidumpWritable child;
     child.SetData("child");
     child.SetPhaseLate();
     parent.AddChild(&child);
     TestStringMinidumpWritable grandchild;
     grandchild.SetData("grandchild");
     child.AddChild(&grandchild);
-    EXPECT_TRUE(parent.WriteEverything(&writer));
-    EXPECT_EQ(25u, writer.string().size());
+    EXPECT_TRUE(parent.WriteEverything(&string_file));
+    EXPECT_EQ(25u, string_file.string().size());
     EXPECT_EQ(std::string("parent\0\0grandchild\0\0child", 25),
-              writer.string());
+              string_file.string());
     parent.Verify();
   }
 
   {
     SCOPED_TRACE("family tree");
-    writer.Reset();
+    string_file.Reset();
     TestStringMinidumpWritable parent;
     parent.SetData("P..");
     TestStringMinidumpWritable child_0;
     child_0.SetData("C0.");
     parent.AddChild(&child_0);
     TestStringMinidumpWritable child_1;
     child_1.SetData("C1.");
     parent.AddChild(&child_1);
     TestStringMinidumpWritable grandchild_00;
     grandchild_00.SetData("G00");
     child_0.AddChild(&grandchild_00);
     TestStringMinidumpWritable grandchild_01;
     grandchild_01.SetData("G01");
     child_0.AddChild(&grandchild_01);
     TestStringMinidumpWritable grandchild_10;
     grandchild_10.SetData("G10");
     child_1.AddChild(&grandchild_10);
     TestStringMinidumpWritable grandchild_11;
     grandchild_11.SetData("G11");
     child_1.AddChild(&grandchild_11);
-    EXPECT_TRUE(parent.WriteEverything(&writer));
-    EXPECT_EQ(27u, writer.string().size());
+    EXPECT_TRUE(parent.WriteEverything(&string_file));
+    EXPECT_EQ(27u, string_file.string().size());
     EXPECT_EQ(std::string("P..\0C0.\0G00\0G01\0C1.\0G10\0G11", 27),
-              writer.string());
+              string_file.string());
     parent.Verify();
   }
 
   {
     SCOPED_TRACE("family tree with C0 late");
-    writer.Reset();
+    string_file.Reset();
     TestStringMinidumpWritable parent;
     parent.SetData("P..");
     TestStringMinidumpWritable child_0;
     child_0.SetData("C0.");
     child_0.SetPhaseLate();
     parent.AddChild(&child_0);
     TestStringMinidumpWritable child_1;
     child_1.SetData("C1.");
     parent.AddChild(&child_1);
     TestStringMinidumpWritable grandchild_00;
     grandchild_00.SetData("G00");
     child_0.AddChild(&grandchild_00);
     TestStringMinidumpWritable grandchild_01;
     grandchild_01.SetData("G01");
     child_0.AddChild(&grandchild_01);
     TestStringMinidumpWritable grandchild_10;
     grandchild_10.SetData("G10");
     child_1.AddChild(&grandchild_10);
     TestStringMinidumpWritable grandchild_11;
     grandchild_11.SetData("G11");
     child_1.AddChild(&grandchild_11);
-    EXPECT_TRUE(parent.WriteEverything(&writer));
-    EXPECT_EQ(27u, writer.string().size());
+    EXPECT_TRUE(parent.WriteEverything(&string_file));
+    EXPECT_EQ(27u, string_file.string().size());
     EXPECT_EQ(std::string("P..\0G00\0G01\0C1.\0G10\0G11\0C0.", 27),
-              writer.string());
+              string_file.string());
     parent.Verify();
   }
 
   {
     SCOPED_TRACE("family tree with G0 late");
-    writer.Reset();
+    string_file.Reset();
     TestStringMinidumpWritable parent;
     parent.SetData("P..");
     TestStringMinidumpWritable child_0;
     child_0.SetData("C0.");
     parent.AddChild(&child_0);
     TestStringMinidumpWritable child_1;
     child_1.SetData("C1.");
     parent.AddChild(&child_1);
     TestStringMinidumpWritable grandchild_00;
     grandchild_00.SetData("G00");
     grandchild_00.SetPhaseLate();
     child_0.AddChild(&grandchild_00);
     TestStringMinidumpWritable grandchild_01;
     grandchild_01.SetData("G01");
     grandchild_01.SetPhaseLate();
     child_0.AddChild(&grandchild_01);
     TestStringMinidumpWritable grandchild_10;
     grandchild_10.SetData("G10");
     child_1.AddChild(&grandchild_10);
     TestStringMinidumpWritable grandchild_11;
     grandchild_11.SetData("G11");
     child_1.AddChild(&grandchild_11);
-    EXPECT_TRUE(parent.WriteEverything(&writer));
-    EXPECT_EQ(27u, writer.string().size());
+    EXPECT_TRUE(parent.WriteEverything(&string_file));
+    EXPECT_EQ(27u, string_file.string().size());
     EXPECT_EQ(std::string("P..\0C0.\0C1.\0G10\0G11\0G00\0G01", 27),
-              writer.string());
+              string_file.string());
     parent.Verify();
   }
 
   {
     SCOPED_TRACE("align 1");
-    writer.Reset();
+    string_file.Reset();
     TestStringMinidumpWritable parent;
     parent.SetData("p");
     TestStringMinidumpWritable child;
     child.SetData("c");
     child.SetAlignment(1);
     parent.AddChild(&child);
-    EXPECT_TRUE(parent.WriteEverything(&writer));
-    EXPECT_EQ(2u, writer.string().size());
-    EXPECT_EQ("pc", writer.string());
+    EXPECT_TRUE(parent.WriteEverything(&string_file));
+    EXPECT_EQ(2u, string_file.string().size());
+    EXPECT_EQ("pc", string_file.string());
     parent.Verify();
   }
 
   {
     SCOPED_TRACE("align 2");
-    writer.Reset();
+    string_file.Reset();
     TestStringMinidumpWritable parent;
     parent.SetData("p");
     TestStringMinidumpWritable child;
     child.SetData("c");
     child.SetAlignment(2);
     parent.AddChild(&child);
-    EXPECT_TRUE(parent.WriteEverything(&writer));
-    EXPECT_EQ(3u, writer.string().size());
-    EXPECT_EQ(std::string("p\0c", 3), writer.string());
+    EXPECT_TRUE(parent.WriteEverything(&string_file));
+    EXPECT_EQ(3u, string_file.string().size());
+    EXPECT_EQ(std::string("p\0c", 3), string_file.string());
     parent.Verify();
   }
 }
 
 class TestRVAMinidumpWritable final : public BaseTestMinidumpWritable {
  public:
   TestRVAMinidumpWritable() : BaseTestMinidumpWritable(), rva_() {}
 
   ~TestRVAMinidumpWritable() {}
 
@@ skipping 15 matching lines @@
   RVA rva_;
 
   DISALLOW_COPY_AND_ASSIGN(TestRVAMinidumpWritable);
 };
 
 RVA RVAAtIndex(const std::string& string, size_t index) {
   return *reinterpret_cast<const RVA*>(&string[index * sizeof(RVA)]);
 }
 
 TEST(MinidumpWritable, RVA) {
-  StringFileWriter writer;
+  StringFile string_file;
 
   {
     SCOPED_TRACE("unset");
-    writer.Reset();
+    string_file.Reset();
     TestRVAMinidumpWritable rva_writable;
-    EXPECT_TRUE(rva_writable.WriteEverything(&writer));
+    EXPECT_TRUE(rva_writable.WriteEverything(&string_file));
 
-    ASSERT_EQ(sizeof(RVA), writer.string().size());
-    EXPECT_EQ(0 * sizeof(RVA), RVAAtIndex(writer.string(), 0));
+    ASSERT_EQ(sizeof(RVA), string_file.string().size());
+    EXPECT_EQ(0 * sizeof(RVA), RVAAtIndex(string_file.string(), 0));
     rva_writable.Verify();
   }
 
   {
     SCOPED_TRACE("self");
-    writer.Reset();
+    string_file.Reset();
     TestRVAMinidumpWritable rva_writable;
     rva_writable.SetRVA(&rva_writable);
-    EXPECT_TRUE(rva_writable.WriteEverything(&writer));
+    EXPECT_TRUE(rva_writable.WriteEverything(&string_file));
 
-    ASSERT_EQ(sizeof(RVA), writer.string().size());
-    EXPECT_EQ(0 * sizeof(RVA), RVAAtIndex(writer.string(), 0));
+    ASSERT_EQ(sizeof(RVA), string_file.string().size());
+    EXPECT_EQ(0 * sizeof(RVA), RVAAtIndex(string_file.string(), 0));
     rva_writable.Verify();
   }
 
   {
     SCOPED_TRACE("parent-child self");
-    writer.Reset();
+    string_file.Reset();
     TestRVAMinidumpWritable parent;
     parent.SetRVA(&parent);
     TestRVAMinidumpWritable child;
     child.SetRVA(&child);
     parent.AddChild(&child);
-    EXPECT_TRUE(parent.WriteEverything(&writer));
+    EXPECT_TRUE(parent.WriteEverything(&string_file));
 
-    ASSERT_EQ(2 * sizeof(RVA), writer.string().size());
-    EXPECT_EQ(0 * sizeof(RVA), RVAAtIndex(writer.string(), 0));
-    EXPECT_EQ(1 * sizeof(RVA), RVAAtIndex(writer.string(), 1));
+    ASSERT_EQ(2 * sizeof(RVA), string_file.string().size());
+    EXPECT_EQ(0 * sizeof(RVA), RVAAtIndex(string_file.string(), 0));
+    EXPECT_EQ(1 * sizeof(RVA), RVAAtIndex(string_file.string(), 1));
     parent.Verify();
   }
 
   {
     SCOPED_TRACE("parent-child only");
-    writer.Reset();
+    string_file.Reset();
     TestRVAMinidumpWritable parent;
     TestRVAMinidumpWritable child;
     parent.SetRVA(&child);
     parent.AddChild(&child);
-    EXPECT_TRUE(parent.WriteEverything(&writer));
+    EXPECT_TRUE(parent.WriteEverything(&string_file));
 
-    ASSERT_EQ(2 * sizeof(RVA), writer.string().size());
-    EXPECT_EQ(1 * sizeof(RVA), RVAAtIndex(writer.string(), 0));
-    EXPECT_EQ(0 * sizeof(RVA), RVAAtIndex(writer.string(), 1));
+    ASSERT_EQ(2 * sizeof(RVA), string_file.string().size());
+    EXPECT_EQ(1 * sizeof(RVA), RVAAtIndex(string_file.string(), 0));
+    EXPECT_EQ(0 * sizeof(RVA), RVAAtIndex(string_file.string(), 1));
     parent.Verify();
   }
 
   {
     SCOPED_TRACE("parent-child circular");
-    writer.Reset();
+    string_file.Reset();
     TestRVAMinidumpWritable parent;
     TestRVAMinidumpWritable child;
     parent.SetRVA(&child);
     child.SetRVA(&parent);
     parent.AddChild(&child);
-    EXPECT_TRUE(parent.WriteEverything(&writer));
+    EXPECT_TRUE(parent.WriteEverything(&string_file));
 
-    ASSERT_EQ(2 * sizeof(RVA), writer.string().size());
-    EXPECT_EQ(1 * sizeof(RVA), RVAAtIndex(writer.string(), 0));
-    EXPECT_EQ(0 * sizeof(RVA), RVAAtIndex(writer.string(), 1));
+    ASSERT_EQ(2 * sizeof(RVA), string_file.string().size());
+    EXPECT_EQ(1 * sizeof(RVA), RVAAtIndex(string_file.string(), 0));
+    EXPECT_EQ(0 * sizeof(RVA), RVAAtIndex(string_file.string(), 1));
     parent.Verify();
   }
 
   {
     SCOPED_TRACE("grandchildren");
-    writer.Reset();
+    string_file.Reset();
     TestRVAMinidumpWritable parent;
     TestRVAMinidumpWritable child;
     parent.SetRVA(&child);
     parent.AddChild(&child);
     TestRVAMinidumpWritable grandchild_0;
     grandchild_0.SetRVA(&child);
     child.AddChild(&grandchild_0);
     TestRVAMinidumpWritable grandchild_1;
     grandchild_1.SetRVA(&child);
     child.AddChild(&grandchild_1);
     TestRVAMinidumpWritable grandchild_2;
     grandchild_2.SetRVA(&child);
     child.AddChild(&grandchild_2);
-    EXPECT_TRUE(parent.WriteEverything(&writer));
+    EXPECT_TRUE(parent.WriteEverything(&string_file));
 
-    ASSERT_EQ(5 * sizeof(RVA), writer.string().size());
-    EXPECT_EQ(1 * sizeof(RVA), RVAAtIndex(writer.string(), 0));
-    EXPECT_EQ(0 * sizeof(RVA), RVAAtIndex(writer.string(), 1));
-    EXPECT_EQ(1 * sizeof(RVA), RVAAtIndex(writer.string(), 2));
-    EXPECT_EQ(1 * sizeof(RVA), RVAAtIndex(writer.string(), 3));
-    EXPECT_EQ(1 * sizeof(RVA), RVAAtIndex(writer.string(), 4));
+    ASSERT_EQ(5 * sizeof(RVA), string_file.string().size());
+    EXPECT_EQ(1 * sizeof(RVA), RVAAtIndex(string_file.string(), 0));
+    EXPECT_EQ(0 * sizeof(RVA), RVAAtIndex(string_file.string(), 1));
+    EXPECT_EQ(1 * sizeof(RVA), RVAAtIndex(string_file.string(), 2));
+    EXPECT_EQ(1 * sizeof(RVA), RVAAtIndex(string_file.string(), 3));
+    EXPECT_EQ(1 * sizeof(RVA), RVAAtIndex(string_file.string(), 4));
     parent.Verify();
   }
 }
 
 class TestLocationDescriptorMinidumpWritable final
     : public BaseTestMinidumpWritable {
  public:
   TestLocationDescriptorMinidumpWritable()
       : BaseTestMinidumpWritable(), location_descriptor_(), string_() {}
 
@@ skipping 37 matching lines @@
   MINIDUMP_LOCATION_DESCRIPTOR location_descriptor;
   char string[1];
 };
 
 const LocationDescriptorAndData* LDDAtIndex(const std::string& string,
                                             size_t index) {
   return reinterpret_cast<const LocationDescriptorAndData*>(&string[index]);
 }
 
 TEST(MinidumpWritable, LocationDescriptor) {
-  StringFileWriter writer;
+  StringFile string_file;
 
   {
     SCOPED_TRACE("unset");
-    writer.Reset();
+    string_file.Reset();
     TestLocationDescriptorMinidumpWritable location_descriptor_writable;
-    EXPECT_TRUE(location_descriptor_writable.WriteEverything(&writer));
+    EXPECT_TRUE(location_descriptor_writable.WriteEverything(&string_file));
 
-    ASSERT_EQ(9u, writer.string().size());
-    const LocationDescriptorAndData* ldd = LDDAtIndex(writer.string(), 0);
+    ASSERT_EQ(9u, string_file.string().size());
+    const LocationDescriptorAndData* ldd = LDDAtIndex(string_file.string(), 0);
     EXPECT_EQ(0u, ldd->location_descriptor.DataSize);
     EXPECT_EQ(0u, ldd->location_descriptor.Rva);
     location_descriptor_writable.Verify();
   }
 
   {
     SCOPED_TRACE("self");
-    writer.Reset();
+    string_file.Reset();
     TestLocationDescriptorMinidumpWritable location_descriptor_writable;
     location_descriptor_writable.SetLocationDescriptor(
         &location_descriptor_writable);
-    EXPECT_TRUE(location_descriptor_writable.WriteEverything(&writer));
+    EXPECT_TRUE(location_descriptor_writable.WriteEverything(&string_file));
 
-    ASSERT_EQ(9u, writer.string().size());
-    const LocationDescriptorAndData* ldd = LDDAtIndex(writer.string(), 0);
+    ASSERT_EQ(9u, string_file.string().size());
+    const LocationDescriptorAndData* ldd = LDDAtIndex(string_file.string(), 0);
     EXPECT_EQ(9u, ldd->location_descriptor.DataSize);
     EXPECT_EQ(0u, ldd->location_descriptor.Rva);
     location_descriptor_writable.Verify();
   }
 
   {
     SCOPED_TRACE("self with data");
-    writer.Reset();
+    string_file.Reset();
     TestLocationDescriptorMinidumpWritable location_descriptor_writable;
     location_descriptor_writable.SetLocationDescriptor(
         &location_descriptor_writable);
     location_descriptor_writable.SetString("zz");
-    EXPECT_TRUE(location_descriptor_writable.WriteEverything(&writer));
+    EXPECT_TRUE(location_descriptor_writable.WriteEverything(&string_file));
 
-    ASSERT_EQ(11u, writer.string().size());
-    const LocationDescriptorAndData* ldd = LDDAtIndex(writer.string(), 0);
+    ASSERT_EQ(11u, string_file.string().size());
+    const LocationDescriptorAndData* ldd = LDDAtIndex(string_file.string(), 0);
     EXPECT_EQ(11u, ldd->location_descriptor.DataSize);
     EXPECT_EQ(0u, ldd->location_descriptor.Rva);
     EXPECT_STREQ("zz", ldd->string);
     location_descriptor_writable.Verify();
   }
 
   {
     SCOPED_TRACE("parent-child self");
-    writer.Reset();
+    string_file.Reset();
     TestLocationDescriptorMinidumpWritable parent;
     parent.SetLocationDescriptor(&parent);
     parent.SetString("yy");
     TestLocationDescriptorMinidumpWritable child;
     child.SetLocationDescriptor(&child);
     child.SetString("x");
     parent.AddChild(&child);
-    EXPECT_TRUE(parent.WriteEverything(&writer));
+    EXPECT_TRUE(parent.WriteEverything(&string_file));
 
-    ASSERT_EQ(22u, writer.string().size());
-    const LocationDescriptorAndData* ldd = LDDAtIndex(writer.string(), 0);
+    ASSERT_EQ(22u, string_file.string().size());
+    const LocationDescriptorAndData* ldd = LDDAtIndex(string_file.string(), 0);
     EXPECT_EQ(11u, ldd->location_descriptor.DataSize);
     EXPECT_EQ(0u, ldd->location_descriptor.Rva);
     EXPECT_STREQ("yy", ldd->string);
-    ldd = LDDAtIndex(writer.string(), 12);
+    ldd = LDDAtIndex(string_file.string(), 12);
     EXPECT_EQ(10u, ldd->location_descriptor.DataSize);
     EXPECT_EQ(12u, ldd->location_descriptor.Rva);
     EXPECT_STREQ("x", ldd->string);
     parent.Verify();
   }
 
   {
     SCOPED_TRACE("parent-child only");
-    writer.Reset();
+    string_file.Reset();
     TestLocationDescriptorMinidumpWritable parent;
     TestLocationDescriptorMinidumpWritable child;
     parent.SetLocationDescriptor(&child);
     parent.SetString("www");
     child.SetString("vv");
     parent.AddChild(&child);
-    EXPECT_TRUE(parent.WriteEverything(&writer));
+    EXPECT_TRUE(parent.WriteEverything(&string_file));
 
-    ASSERT_EQ(23u, writer.string().size());
-    const LocationDescriptorAndData* ldd = LDDAtIndex(writer.string(), 0);
+    ASSERT_EQ(23u, string_file.string().size());
+    const LocationDescriptorAndData* ldd = LDDAtIndex(string_file.string(), 0);
     EXPECT_EQ(11u, ldd->location_descriptor.DataSize);
     EXPECT_EQ(12u, ldd->location_descriptor.Rva);
     EXPECT_STREQ("www", ldd->string);
-    ldd = LDDAtIndex(writer.string(), 12);
+    ldd = LDDAtIndex(string_file.string(), 12);
     EXPECT_EQ(0u, ldd->location_descriptor.DataSize);
     EXPECT_EQ(0u, ldd->location_descriptor.Rva);
     EXPECT_STREQ("vv", ldd->string);
     parent.Verify();
   }
 
   {
     SCOPED_TRACE("parent-child circular");
-    writer.Reset();
+    string_file.Reset();
     TestLocationDescriptorMinidumpWritable parent;
     TestLocationDescriptorMinidumpWritable child;
     parent.SetLocationDescriptor(&child);
     parent.SetString("uuuu");
     child.SetLocationDescriptor(&parent);
     child.SetString("tttt");
     parent.AddChild(&child);
-    EXPECT_TRUE(parent.WriteEverything(&writer));
+    EXPECT_TRUE(parent.WriteEverything(&string_file));
 
-    ASSERT_EQ(29u, writer.string().size());
-    const LocationDescriptorAndData* ldd = LDDAtIndex(writer.string(), 0);
+    ASSERT_EQ(29u, string_file.string().size());
+    const LocationDescriptorAndData* ldd = LDDAtIndex(string_file.string(), 0);
     EXPECT_EQ(13u, ldd->location_descriptor.DataSize);
     EXPECT_EQ(16u, ldd->location_descriptor.Rva);
     EXPECT_STREQ("uuuu", ldd->string);
-    ldd = LDDAtIndex(writer.string(), 16);
+    ldd = LDDAtIndex(string_file.string(), 16);
     EXPECT_EQ(13u, ldd->location_descriptor.DataSize);
     EXPECT_EQ(0u, ldd->location_descriptor.Rva);
     EXPECT_STREQ("tttt", ldd->string);
     parent.Verify();
   }
 
   {
     SCOPED_TRACE("grandchildren");
-    writer.Reset();
+    string_file.Reset();
     TestLocationDescriptorMinidumpWritable parent;
     TestLocationDescriptorMinidumpWritable child;
     parent.SetLocationDescriptor(&child);
     parent.SetString("s");
     parent.AddChild(&child);
     child.SetString("r");
     TestLocationDescriptorMinidumpWritable grandchild_0;
     grandchild_0.SetLocationDescriptor(&child);
     grandchild_0.SetString("q");
     child.AddChild(&grandchild_0);
     TestLocationDescriptorMinidumpWritable grandchild_1;
     grandchild_1.SetLocationDescriptor(&child);
     grandchild_1.SetString("p");
     child.AddChild(&grandchild_1);
     TestLocationDescriptorMinidumpWritable grandchild_2;
     grandchild_2.SetLocationDescriptor(&child);
     grandchild_2.SetString("o");
     child.AddChild(&grandchild_2);
-    EXPECT_TRUE(parent.WriteEverything(&writer));
+    EXPECT_TRUE(parent.WriteEverything(&string_file));
 
-    ASSERT_EQ(58u, writer.string().size());
-    const LocationDescriptorAndData* ldd = LDDAtIndex(writer.string(), 0);
+    ASSERT_EQ(58u, string_file.string().size());
+    const LocationDescriptorAndData* ldd = LDDAtIndex(string_file.string(), 0);
     EXPECT_EQ(10u, ldd->location_descriptor.DataSize);
     EXPECT_EQ(12u, ldd->location_descriptor.Rva);
     EXPECT_STREQ("s", ldd->string);
-    ldd = LDDAtIndex(writer.string(), 12);
+    ldd = LDDAtIndex(string_file.string(), 12);
     EXPECT_EQ(0u, ldd->location_descriptor.DataSize);
     EXPECT_EQ(0u, ldd->location_descriptor.Rva);
     EXPECT_STREQ("r", ldd->string);
-    ldd = LDDAtIndex(writer.string(), 24);
+    ldd = LDDAtIndex(string_file.string(), 24);
     EXPECT_EQ(10u, ldd->location_descriptor.DataSize);
     EXPECT_EQ(12u, ldd->location_descriptor.Rva);
     EXPECT_STREQ("q", ldd->string);
-    ldd = LDDAtIndex(writer.string(), 36);
+    ldd = LDDAtIndex(string_file.string(), 36);
     EXPECT_EQ(10u, ldd->location_descriptor.DataSize);
     EXPECT_EQ(12u, ldd->location_descriptor.Rva);
     EXPECT_STREQ("p", ldd->string);
-    ldd = LDDAtIndex(writer.string(), 48);
+    ldd = LDDAtIndex(string_file.string(), 48);
     EXPECT_EQ(10u, ldd->location_descriptor.DataSize);
     EXPECT_EQ(12u, ldd->location_descriptor.Rva);
     EXPECT_STREQ("o", ldd->string);
     parent.Verify();
   }
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace crashpad