diff --git a/fxjs/xfa/cjx_node.cpp b/fxjs/xfa/cjx_node.cpp
index 5521d0f..98954f1 100644
--- a/fxjs/xfa/cjx_node.cpp
+++ b/fxjs/xfa/cjx_node.cpp
@@ -23,7 +23,7 @@
 #include "xfa/fxfa/cxfa_ffdoc.h"
 #include "xfa/fxfa/cxfa_ffnotify.h"
 #include "xfa/fxfa/parser/cxfa_document.h"
-#include "xfa/fxfa/parser/cxfa_document_parser.h"
+#include "xfa/fxfa/parser/cxfa_document_builder.h"
 #include "xfa/fxfa/parser/cxfa_node.h"
 #include "xfa/fxfa/parser/xfa_basic_data.h"
 #include "xfa/fxfa/parser/xfa_utils.h"
@@ -266,17 +266,17 @@
   if (params.size() >= 3)
     bOverwrite = runtime->ToBoolean(params[2]);
 
-  CFX_XMLParser xml_parser(
+  CFX_XMLParser parser(
       pdfium::MakeRetain<CFX_ReadOnlyMemoryStream>(expression.raw_span()));
 
-  auto pParser = std::make_unique<CXFA_DocumentParser>(GetDocument());
-  CFX_XMLNode* pXMLNode = pParser->ParseData(xml_parser.Parse());
+  auto builder = std::make_unique<CXFA_DocumentBuilder>(GetDocument());
+  CFX_XMLNode* pXMLNode = builder->Build(parser.Parse());
   if (!pXMLNode)
     return CJS_Result::Success();
 
   CFX_XMLDocument* top_xml_doc =
       GetXFANode()->GetDocument()->GetNotify()->GetFFDoc()->GetXMLDocument();
-  top_xml_doc->AppendNodesFrom(pParser->GetXMLDoc().get());
+  top_xml_doc->AppendNodesFrom(builder->GetXMLDoc().get());
 
   if (bIgnoreRoot &&
       (pXMLNode->GetType() != CFX_XMLNode::Type::kElement ||
@@ -317,8 +317,8 @@
     pFakeXMLRoot->AppendLastChild(pXMLNode);
   }
 
-  pParser->ConstructXFANode(pFakeRoot, pFakeXMLRoot);
-  pFakeRoot = pParser->GetRootNode();
+  builder->ConstructXFANode(pFakeRoot, pFakeXMLRoot);
+  pFakeRoot = builder->GetRootNode();
   if (!pFakeRoot)
     return CJS_Result::Success();
 
diff --git a/xfa/fxfa/cxfa_ffdoc.cpp b/xfa/fxfa/cxfa_ffdoc.cpp
index 7f2a92f..0053ba4 100644
--- a/xfa/fxfa/cxfa_ffdoc.cpp
+++ b/xfa/fxfa/cxfa_ffdoc.cpp
@@ -36,7 +36,7 @@
 #include "xfa/fxfa/parser/cxfa_acrobat7.h"
 #include "xfa/fxfa/parser/cxfa_dataexporter.h"
 #include "xfa/fxfa/parser/cxfa_document.h"
-#include "xfa/fxfa/parser/cxfa_document_parser.h"
+#include "xfa/fxfa/parser/cxfa_document_builder.h"
 #include "xfa/fxfa/parser/cxfa_dynamicrender.h"
 #include "xfa/fxfa/parser/cxfa_node.h"
 
@@ -106,18 +106,18 @@
   if (!xml_doc)
     return false;
 
-  CXFA_DocumentParser doc_parser(m_pDocument.get());
-  bool parsed = doc_parser.Parse(std::move(xml_doc), XFA_PacketType::Xdp);
+  CXFA_DocumentBuilder builder(m_pDocument.get());
+  bool parsed = builder.BuildDocument(std::move(xml_doc), XFA_PacketType::Xdp);
 
   // We have to set the XML document before we return so that we can clean
   // up in the OpenDoc method. If we don't, the XMLDocument will get free'd
   // when this method returns and UnownedPtrs get unhappy.
-  m_pXMLDoc = doc_parser.GetXMLDoc();
+  m_pXMLDoc = builder.GetXMLDoc();
 
   if (!parsed)
     return false;
 
-  m_pDocument->SetRoot(doc_parser.GetRootNode());
+  m_pDocument->SetRoot(builder.GetRootNode());
   return true;
 }
 
diff --git a/xfa/fxfa/parser/BUILD.gn b/xfa/fxfa/parser/BUILD.gn
index 754bdcf..7878267 100644
--- a/xfa/fxfa/parser/BUILD.gn
+++ b/xfa/fxfa/parser/BUILD.gn
@@ -197,8 +197,8 @@
     "cxfa_digestmethods.h",
     "cxfa_document.cpp",
     "cxfa_document.h",
-    "cxfa_document_parser.cpp",
-    "cxfa_document_parser.h",
+    "cxfa_document_builder.cpp",
+    "cxfa_document_builder.h",
     "cxfa_documentassembly.cpp",
     "cxfa_documentassembly.h",
     "cxfa_draw.cpp",
@@ -697,7 +697,7 @@
 
 pdfium_unittest_source_set("unittests") {
   sources = [
-    "cxfa_document_parser_unittest.cpp",
+    "cxfa_document_builder_unittest.cpp",
     "cxfa_localevalue_unittest.cpp",
     "cxfa_measurement_unittest.cpp",
     "cxfa_node_unittest.cpp",
@@ -714,6 +714,6 @@
 }
 
 pdfium_embeddertest_source_set("embeddertests") {
-  sources = [ "cxfa_document_parser_embeddertest.cpp" ]
+  sources = [ "cxfa_document_builder_embeddertest.cpp" ]
   pdfium_root_dir = "../../../"
 }
diff --git a/xfa/fxfa/parser/cxfa_document_parser.cpp b/xfa/fxfa/parser/cxfa_document_builder.cpp
similarity index 93%
rename from xfa/fxfa/parser/cxfa_document_parser.cpp
rename to xfa/fxfa/parser/cxfa_document_builder.cpp
index de23fe5..b3cd01f 100644
--- a/xfa/fxfa/parser/cxfa_document_parser.cpp
+++ b/xfa/fxfa/parser/cxfa_document_builder.cpp
@@ -4,7 +4,7 @@
 
 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
 
-#include "xfa/fxfa/parser/cxfa_document_parser.h"
+#include "xfa/fxfa/parser/cxfa_document_builder.h"
 
 #include <utility>
 #include <vector>
@@ -224,14 +224,14 @@
                                  "http://www.w3.org/1999/xhtml");
 }
 
-CXFA_DocumentParser::CXFA_DocumentParser(CXFA_Document* pFactory)
+CXFA_DocumentBuilder::CXFA_DocumentBuilder(CXFA_Document* pFactory)
     : m_pFactory(pFactory) {}
 
-CXFA_DocumentParser::~CXFA_DocumentParser() = default;
+CXFA_DocumentBuilder::~CXFA_DocumentBuilder() = default;
 
-bool CXFA_DocumentParser::Parse(std::unique_ptr<CFX_XMLDocument> pXML,
-                                XFA_PacketType ePacketID) {
-  CFX_XMLNode* root = ParseData(std::move(pXML));
+bool CXFA_DocumentBuilder::BuildDocument(std::unique_ptr<CFX_XMLDocument> pXML,
+                                         XFA_PacketType ePacketID) {
+  CFX_XMLNode* root = Build(std::move(pXML));
   if (!root)
     return false;
 
@@ -239,7 +239,7 @@
   return !!m_pRootNode;
 }
 
-CFX_XMLNode* CXFA_DocumentParser::ParseData(
+CFX_XMLNode* CXFA_DocumentBuilder::Build(
     std::unique_ptr<CFX_XMLDocument> pXML) {
   if (!pXML)
     return nullptr;
@@ -251,8 +251,8 @@
   return GetDocumentNode(xml_doc_->GetRoot());
 }
 
-void CXFA_DocumentParser::ConstructXFANode(CXFA_Node* pXFANode,
-                                           CFX_XMLNode* pXMLNode) {
+void CXFA_DocumentBuilder::ConstructXFANode(CXFA_Node* pXFANode,
+                                            CFX_XMLNode* pXMLNode) {
   XFA_PacketType ePacketID = pXFANode->GetPacketType();
   if (ePacketID == XFA_PacketType::Datasets) {
     if (pXFANode->GetElementType() == XFA_Element::DataValue) {
@@ -295,12 +295,12 @@
   }
 }
 
-CXFA_Node* CXFA_DocumentParser::GetRootNode() const {
+CXFA_Node* CXFA_DocumentBuilder::GetRootNode() const {
   return m_pRootNode;
 }
 
-CXFA_Node* CXFA_DocumentParser::ParseAsXDPPacket(CFX_XMLNode* pXMLDocumentNode,
-                                                 XFA_PacketType ePacketID) {
+CXFA_Node* CXFA_DocumentBuilder::ParseAsXDPPacket(CFX_XMLNode* pXMLDocumentNode,
+                                                  XFA_PacketType ePacketID) {
   switch (ePacketID) {
     case XFA_PacketType::Xdp:
       return ParseAsXDPPacket_XDP(pXMLDocumentNode);
@@ -329,7 +329,7 @@
   }
 }
 
-CXFA_Node* CXFA_DocumentParser::ParseAsXDPPacket_XDP(
+CXFA_Node* CXFA_DocumentBuilder::ParseAsXDPPacket_XDP(
     CFX_XMLNode* pXMLDocumentNode) {
   XFA_PACKETINFO packet = XFA_GetPacketByIndex(XFA_PacketType::Xdp);
   if (!MatchNodeName(pXMLDocumentNode, packet.name, packet.uri, packet.flags))
@@ -450,7 +450,7 @@
   return pXFARootNode;
 }
 
-CXFA_Node* CXFA_DocumentParser::ParseAsXDPPacket_Config(
+CXFA_Node* CXFA_DocumentBuilder::ParseAsXDPPacket_Config(
     CFX_XMLNode* pXMLDocumentNode) {
   XFA_PACKETINFO packet = XFA_GetPacketByIndex(XFA_PacketType::Config);
   if (!MatchNodeName(pXMLDocumentNode, packet.name, packet.uri, packet.flags))
@@ -469,7 +469,7 @@
   return pNode;
 }
 
-CXFA_Node* CXFA_DocumentParser::ParseAsXDPPacket_Template(
+CXFA_Node* CXFA_DocumentBuilder::ParseAsXDPPacket_Template(
     CFX_XMLNode* pXMLDocumentNode) {
   XFA_PACKETINFO packet = XFA_GetPacketByIndex(XFA_PacketType::Template);
   if (!MatchNodeName(pXMLDocumentNode, packet.name, packet.uri, packet.flags))
@@ -496,7 +496,7 @@
   return pNode;
 }
 
-CXFA_Node* CXFA_DocumentParser::ParseAsXDPPacket_Form(
+CXFA_Node* CXFA_DocumentBuilder::ParseAsXDPPacket_Form(
     CFX_XMLNode* pXMLDocumentNode) {
   XFA_PACKETINFO packet = XFA_GetPacketByIndex(XFA_PacketType::Form);
   if (!MatchNodeName(pXMLDocumentNode, packet.name, packet.uri, packet.flags))
@@ -528,7 +528,7 @@
   return pNode;
 }
 
-CXFA_Node* CXFA_DocumentParser::ParseAsXDPPacket_Data(
+CXFA_Node* CXFA_DocumentBuilder::ParseAsXDPPacket_Data(
     CFX_XMLNode* pXMLDocumentNode) {
   XFA_PACKETINFO packet = XFA_GetPacketByIndex(XFA_PacketType::Datasets);
   CFX_XMLNode* pDatasetsXMLNode = GetDataSetsFromXDP(pXMLDocumentNode);
@@ -579,7 +579,7 @@
   return pNode;
 }
 
-CXFA_Node* CXFA_DocumentParser::ParseAsXDPPacket_LocaleConnectionSourceSet(
+CXFA_Node* CXFA_DocumentBuilder::ParseAsXDPPacket_LocaleConnectionSourceSet(
     CFX_XMLNode* pXMLDocumentNode,
     XFA_PacketType packet_type,
     XFA_Element element) {
@@ -599,7 +599,7 @@
   return pNode;
 }
 
-CXFA_Node* CXFA_DocumentParser::ParseAsXDPPacket_Xdc(
+CXFA_Node* CXFA_DocumentBuilder::ParseAsXDPPacket_Xdc(
     CFX_XMLNode* pXMLDocumentNode) {
   XFA_PACKETINFO packet = XFA_GetPacketByIndex(XFA_PacketType::Xdc);
   if (!MatchNodeName(pXMLDocumentNode, packet.name, packet.uri, packet.flags))
@@ -615,7 +615,7 @@
   return pNode;
 }
 
-CXFA_Node* CXFA_DocumentParser::ParseAsXDPPacket_User(
+CXFA_Node* CXFA_DocumentBuilder::ParseAsXDPPacket_User(
     CFX_XMLNode* pXMLDocumentNode) {
   CXFA_Node* pNode =
       m_pFactory->CreateNode(XFA_PacketType::Xdp, XFA_Element::Packet);
@@ -628,17 +628,17 @@
   return pNode;
 }
 
-CXFA_Node* CXFA_DocumentParser::DataLoader(CXFA_Node* pXFANode,
-                                           CFX_XMLNode* pXMLDoc,
-                                           bool bDoTransform) {
+CXFA_Node* CXFA_DocumentBuilder::DataLoader(CXFA_Node* pXFANode,
+                                            CFX_XMLNode* pXMLDoc,
+                                            bool bDoTransform) {
   ParseDataGroup(pXFANode, pXMLDoc, XFA_PacketType::Datasets);
   return pXFANode;
 }
 
-CXFA_Node* CXFA_DocumentParser::NormalLoader(CXFA_Node* pXFANode,
-                                             CFX_XMLNode* pXMLDoc,
-                                             XFA_PacketType ePacketID,
-                                             bool bUseAttribute) {
+CXFA_Node* CXFA_DocumentBuilder::NormalLoader(CXFA_Node* pXFANode,
+                                              CFX_XMLNode* pXMLDoc,
+                                              XFA_PacketType ePacketID,
+                                              bool bUseAttribute) {
   constexpr size_t kMaxExecuteRecursion = 1000;
   if (m_ExecuteRecursionDepth > kMaxExecuteRecursion)
     return nullptr;
@@ -723,9 +723,9 @@
   return pXFANode;
 }
 
-void CXFA_DocumentParser::ParseContentNode(CXFA_Node* pXFANode,
-                                           CFX_XMLNode* pXMLNode,
-                                           XFA_PacketType ePacketID) {
+void CXFA_DocumentBuilder::ParseContentNode(CXFA_Node* pXFANode,
+                                            CFX_XMLNode* pXMLNode,
+                                            XFA_PacketType ePacketID) {
   XFA_Element element = XFA_Element::Sharptext;
   if (pXFANode->GetElementType() == XFA_Element::ExData) {
     WideString wsContentType =
@@ -779,9 +779,9 @@
   }
 }
 
-void CXFA_DocumentParser::ParseDataGroup(CXFA_Node* pXFANode,
-                                         CFX_XMLNode* pXMLNode,
-                                         XFA_PacketType ePacketID) {
+void CXFA_DocumentBuilder::ParseDataGroup(CXFA_Node* pXFANode,
+                                          CFX_XMLNode* pXMLNode,
+                                          XFA_PacketType ePacketID) {
   for (CFX_XMLNode* pXMLChild = pXMLNode->GetFirstChild(); pXMLChild;
        pXMLChild = pXMLChild->GetNextSibling()) {
     switch (pXMLChild->GetType()) {
@@ -910,9 +910,9 @@
   }
 }
 
-void CXFA_DocumentParser::ParseDataValue(CXFA_Node* pXFANode,
-                                         CFX_XMLNode* pXMLNode,
-                                         XFA_PacketType ePacketID) {
+void CXFA_DocumentBuilder::ParseDataValue(CXFA_Node* pXFANode,
+                                          CFX_XMLNode* pXMLNode,
+                                          XFA_PacketType ePacketID) {
   CFX_WideTextBuf wsValueTextBuf;
   CFX_WideTextBuf wsCurValueTextBuf;
   bool bMarkAsCompound = false;
@@ -1003,9 +1003,9 @@
                                  false);
 }
 
-void CXFA_DocumentParser::ParseInstruction(CXFA_Node* pXFANode,
-                                           CFX_XMLInstruction* pXMLInstruction,
-                                           XFA_PacketType ePacketID) {
+void CXFA_DocumentBuilder::ParseInstruction(CXFA_Node* pXFANode,
+                                            CFX_XMLInstruction* pXMLInstruction,
+                                            XFA_PacketType ePacketID) {
   const std::vector<WideString>& target_data = pXMLInstruction->GetTargetData();
   if (pXMLInstruction->IsOriginalXFAVersion()) {
     if (target_data.size() > 1 &&
diff --git a/xfa/fxfa/parser/cxfa_document_parser.h b/xfa/fxfa/parser/cxfa_document_builder.h
similarity index 85%
rename from xfa/fxfa/parser/cxfa_document_parser.h
rename to xfa/fxfa/parser/cxfa_document_builder.h
index bef976e..9486dac 100644
--- a/xfa/fxfa/parser/cxfa_document_parser.h
+++ b/xfa/fxfa/parser/cxfa_document_builder.h
@@ -4,8 +4,8 @@
 
 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
 
-#ifndef XFA_FXFA_PARSER_CXFA_DOCUMENT_PARSER_H_
-#define XFA_FXFA_PARSER_CXFA_DOCUMENT_PARSER_H_
+#ifndef XFA_FXFA_PARSER_CXFA_DOCUMENT_BUILDER_H_
+#define XFA_FXFA_PARSER_CXFA_DOCUMENT_BUILDER_H_
 
 #include <memory>
 #include <utility>
@@ -20,13 +20,14 @@
 class CXFA_Node;
 class CFX_XMLInstruction;
 
-class CXFA_DocumentParser {
+class CXFA_DocumentBuilder {
  public:
-  explicit CXFA_DocumentParser(CXFA_Document* pFactory);
-  ~CXFA_DocumentParser();
+  explicit CXFA_DocumentBuilder(CXFA_Document* pFactory);
+  ~CXFA_DocumentBuilder();
 
-  bool Parse(std::unique_ptr<CFX_XMLDocument> pXML, XFA_PacketType ePacketID);
-  CFX_XMLNode* ParseData(std::unique_ptr<CFX_XMLDocument> pXML);
+  CFX_XMLNode* Build(std::unique_ptr<CFX_XMLDocument> pXML);
+  bool BuildDocument(std::unique_ptr<CFX_XMLDocument> pXML,
+                     XFA_PacketType ePacketID);
   std::unique_ptr<CFX_XMLDocument> GetXMLDoc() { return std::move(xml_doc_); }
 
   void ConstructXFANode(CXFA_Node* pXFANode, CFX_XMLNode* pXMLNode);
@@ -73,4 +74,4 @@
   size_t m_ExecuteRecursionDepth = 0;
 };
 
-#endif  // XFA_FXFA_PARSER_CXFA_DOCUMENT_PARSER_H_
+#endif  // XFA_FXFA_PARSER_CXFA_DOCUMENT_BUILDER_H_
diff --git a/xfa/fxfa/parser/cxfa_document_parser_embeddertest.cpp b/xfa/fxfa/parser/cxfa_document_builder_embeddertest.cpp
similarity index 100%
rename from xfa/fxfa/parser/cxfa_document_parser_embeddertest.cpp
rename to xfa/fxfa/parser/cxfa_document_builder_embeddertest.cpp
diff --git a/xfa/fxfa/parser/cxfa_document_parser_unittest.cpp b/xfa/fxfa/parser/cxfa_document_builder_unittest.cpp
similarity index 65%
rename from xfa/fxfa/parser/cxfa_document_parser_unittest.cpp
rename to xfa/fxfa/parser/cxfa_document_builder_unittest.cpp
index bb98de1..81f39ee 100644
--- a/xfa/fxfa/parser/cxfa_document_parser_unittest.cpp
+++ b/xfa/fxfa/parser/cxfa_document_builder_unittest.cpp
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "xfa/fxfa/parser/cxfa_document_parser.h"
+#include "xfa/fxfa/parser/cxfa_document_builder.h"
 
 #include "core/fxcrt/cfx_readonlymemorystream.h"
 #include "core/fxcrt/xml/cfx_xmldocument.h"
@@ -10,47 +10,49 @@
 #include "testing/gtest/include/gtest/gtest.h"
 #include "xfa/fxfa/parser/cxfa_document.h"
 
-class CXFA_DocumentParserTest : public testing::Test {
+class CXFA_DocumentBuilderTest : public testing::Test {
  public:
   void SetUp() override {
     doc_ = std::make_unique<CXFA_Document>(nullptr, nullptr);
-    parser_ = std::make_unique<CXFA_DocumentParser>(doc_.get());
+    builder_ = std::make_unique<CXFA_DocumentBuilder>(doc_.get());
   }
 
   void TearDown() override {
     // Hold the XML tree until we cleanup the document.
-    std::unique_ptr<CFX_XMLDocument> doc = parser_->GetXMLDoc();
-    parser_ = nullptr;
+    std::unique_ptr<CFX_XMLDocument> doc = builder_->GetXMLDoc();
+    builder_ = nullptr;
     doc_ = nullptr;
   }
 
   CXFA_Document* GetDoc() const { return doc_.get(); }
-  CXFA_DocumentParser* GetParser() const { return parser_.get(); }
+  CXFA_DocumentBuilder* GetBuilder() const { return builder_.get(); }
 
  private:
   std::unique_ptr<CXFA_Document> doc_;
-  std::unique_ptr<CXFA_DocumentParser> parser_;
+  std::unique_ptr<CXFA_DocumentBuilder> builder_;
 };
 
-TEST_F(CXFA_DocumentParserTest, EmptyInput) {
+TEST_F(CXFA_DocumentBuilderTest, EmptyInput) {
   static const char kInput[] = "";
   auto stream = pdfium::MakeRetain<CFX_ReadOnlyMemoryStream>(
       pdfium::as_bytes(pdfium::make_span(kInput)));
   CFX_XMLParser xml_parser(stream);
-  EXPECT_FALSE(GetParser()->Parse(xml_parser.Parse(), XFA_PacketType::Config));
-  EXPECT_FALSE(GetParser()->GetRootNode());
+  EXPECT_FALSE(
+      GetBuilder()->BuildDocument(xml_parser.Parse(), XFA_PacketType::Config));
+  EXPECT_FALSE(GetBuilder()->GetRootNode());
 }
 
-TEST_F(CXFA_DocumentParserTest, BadInput) {
+TEST_F(CXFA_DocumentBuilderTest, BadInput) {
   static const char kInput[] = "<<<>bar?>>>>>>>";
   auto stream = pdfium::MakeRetain<CFX_ReadOnlyMemoryStream>(
       pdfium::as_bytes(pdfium::make_span(kInput)));
   CFX_XMLParser xml_parser(stream);
-  EXPECT_FALSE(GetParser()->Parse(xml_parser.Parse(), XFA_PacketType::Config));
-  EXPECT_FALSE(GetParser()->GetRootNode());
+  EXPECT_FALSE(
+      GetBuilder()->BuildDocument(xml_parser.Parse(), XFA_PacketType::Config));
+  EXPECT_FALSE(GetBuilder()->GetRootNode());
 }
 
-TEST_F(CXFA_DocumentParserTest, XMLInstructionsScriptOff) {
+TEST_F(CXFA_DocumentBuilderTest, XMLInstructionsScriptOff) {
   static const char kInput[] =
       "<config>\n"
       "<?originalXFAVersion http://www.xfa.org/schema/xfa-template/2.7 "
@@ -61,14 +63,15 @@
   auto stream = pdfium::MakeRetain<CFX_ReadOnlyMemoryStream>(
       pdfium::as_bytes(pdfium::make_span(kInput)));
   CFX_XMLParser xml_parser(stream);
-  ASSERT_TRUE(GetParser()->Parse(xml_parser.Parse(), XFA_PacketType::Config));
+  ASSERT_TRUE(
+      GetBuilder()->BuildDocument(xml_parser.Parse(), XFA_PacketType::Config));
 
-  CXFA_Node* root = GetParser()->GetRootNode();
+  CXFA_Node* root = GetBuilder()->GetRootNode();
   ASSERT_TRUE(root);
   EXPECT_FALSE(GetDoc()->is_scripting());
 }
 
-TEST_F(CXFA_DocumentParserTest, XMLInstructionsScriptOn) {
+TEST_F(CXFA_DocumentBuilderTest, XMLInstructionsScriptOn) {
   static const char kInput[] =
       "<config>\n"
       "<?originalXFAVersion http://www.xfa.org/schema/xfa-template/2.7 "
@@ -80,14 +83,15 @@
   auto stream = pdfium::MakeRetain<CFX_ReadOnlyMemoryStream>(
       pdfium::as_bytes(pdfium::make_span(kInput)));
   CFX_XMLParser xml_parser(stream);
-  ASSERT_TRUE(GetParser()->Parse(xml_parser.Parse(), XFA_PacketType::Config));
+  ASSERT_TRUE(
+      GetBuilder()->BuildDocument(xml_parser.Parse(), XFA_PacketType::Config));
 
-  CXFA_Node* root = GetParser()->GetRootNode();
+  CXFA_Node* root = GetBuilder()->GetRootNode();
   ASSERT_TRUE(root);
   EXPECT_TRUE(GetDoc()->is_scripting());
 }
 
-TEST_F(CXFA_DocumentParserTest, XMLInstructionsStrictScope) {
+TEST_F(CXFA_DocumentBuilderTest, XMLInstructionsStrictScope) {
   static const char kInput[] =
       "<config>"
       "<?acrobat JavaScript strictScoping ?>\n"
@@ -98,14 +102,15 @@
   auto stream = pdfium::MakeRetain<CFX_ReadOnlyMemoryStream>(
       pdfium::as_bytes(pdfium::make_span(kInput)));
   CFX_XMLParser xml_parser(stream);
-  ASSERT_TRUE(GetParser()->Parse(xml_parser.Parse(), XFA_PacketType::Config));
+  ASSERT_TRUE(
+      GetBuilder()->BuildDocument(xml_parser.Parse(), XFA_PacketType::Config));
 
-  CXFA_Node* root = GetParser()->GetRootNode();
+  CXFA_Node* root = GetBuilder()->GetRootNode();
   ASSERT_TRUE(root);
   EXPECT_TRUE(GetDoc()->is_strict_scoping());
 }
 
-TEST_F(CXFA_DocumentParserTest, XMLInstructionsStrictScopeBad) {
+TEST_F(CXFA_DocumentBuilderTest, XMLInstructionsStrictScopeBad) {
   static const char kInput[] =
       "<config>"
       "<?acrobat JavaScript otherScoping ?>\n"
@@ -116,14 +121,15 @@
   auto stream = pdfium::MakeRetain<CFX_ReadOnlyMemoryStream>(
       pdfium::as_bytes(pdfium::make_span(kInput)));
   CFX_XMLParser xml_parser(stream);
-  ASSERT_TRUE(GetParser()->Parse(xml_parser.Parse(), XFA_PacketType::Config));
+  ASSERT_TRUE(
+      GetBuilder()->BuildDocument(xml_parser.Parse(), XFA_PacketType::Config));
 
-  CXFA_Node* root = GetParser()->GetRootNode();
+  CXFA_Node* root = GetBuilder()->GetRootNode();
   ASSERT_TRUE(root);
   EXPECT_FALSE(GetDoc()->is_strict_scoping());
 }
 
-TEST_F(CXFA_DocumentParserTest, MultipleXMLInstructions) {
+TEST_F(CXFA_DocumentBuilderTest, MultipleXMLInstructions) {
   static const char kInput[] =
       "<config>"
       "<?originalXFAVersion http://www.xfa.org/schema/xfa-template/2.7 "
@@ -137,9 +143,10 @@
   auto stream = pdfium::MakeRetain<CFX_ReadOnlyMemoryStream>(
       pdfium::as_bytes(pdfium::make_span(kInput)));
   CFX_XMLParser xml_parser(stream);
-  ASSERT_TRUE(GetParser()->Parse(xml_parser.Parse(), XFA_PacketType::Config));
+  ASSERT_TRUE(
+      GetBuilder()->BuildDocument(xml_parser.Parse(), XFA_PacketType::Config));
 
-  CXFA_Node* root = GetParser()->GetRootNode();
+  CXFA_Node* root = GetBuilder()->GetRootNode();
   ASSERT_TRUE(root);
 
   EXPECT_TRUE(GetDoc()->is_scripting());
diff --git a/xfa/fxfa/parser/cxfa_node.cpp b/xfa/fxfa/parser/cxfa_node.cpp
index 184f962..d954ca5 100644
--- a/xfa/fxfa/parser/cxfa_node.cpp
+++ b/xfa/fxfa/parser/cxfa_node.cpp
@@ -127,7 +127,7 @@
 #include "xfa/fxfa/parser/cxfa_digestmethod.h"
 #include "xfa/fxfa/parser/cxfa_digestmethods.h"
 #include "xfa/fxfa/parser/cxfa_document.h"
-#include "xfa/fxfa/parser/cxfa_document_parser.h"
+#include "xfa/fxfa/parser/cxfa_document_builder.h"
 #include "xfa/fxfa/parser/cxfa_documentassembly.h"
 #include "xfa/fxfa/parser/cxfa_draw.h"
 #include "xfa/fxfa/parser/cxfa_driver.h"