diff --git a/fxjs/cfxjse_formcalc_context.cpp b/fxjs/cfxjse_formcalc_context.cpp
index a06e65a..7f488ed 100644
--- a/fxjs/cfxjse_formcalc_context.cpp
+++ b/fxjs/cfxjse_formcalc_context.cpp
@@ -5729,7 +5729,7 @@
             wsName = *ret;
         }
         if (wsName.IsEmpty())
-          wsName = L"#" + pNode->GetClassName();
+          wsName = L"#" + WideString::FromASCII(pNode->GetClassName());
 
         wsSomExpression = wsName + wsSomExpression;
         dFlags = XFA_RESOLVENODE_Siblings;
diff --git a/fxjs/xfa/cjx_node.cpp b/fxjs/xfa/cjx_node.cpp
index 4d706f9f..d0ae0ea 100644
--- a/fxjs/xfa/cjx_node.cpp
+++ b/fxjs/xfa/cjx_node.cpp
@@ -292,7 +292,7 @@
       clone = pThisXMLRoot->Clone(top_xml_doc);
     } else {
       clone = top_xml_doc->CreateNode<CFX_XMLElement>(
-          WideString(GetXFANode()->GetClassName()));
+          WideString::FromASCII(GetXFANode()->GetClassName()));
     }
     pFakeXMLRoot = clone;
   }
diff --git a/fxjs/xfa/cjx_object.cpp b/fxjs/xfa/cjx_object.cpp
index a762027..7ecd25f 100644
--- a/fxjs/xfa/cjx_object.cpp
+++ b/fxjs/xfa/cjx_object.cpp
@@ -148,8 +148,7 @@
     ThrowInvalidPropertyException();
     return;
   }
-  pValue->SetString(
-      FX_UTF8Encode(GetXFAObject()->GetClassName()).AsStringView());
+  pValue->SetString(GetXFAObject()->GetClassName());
 }
 
 int32_t CJX_Object::Subform_and_SubformSet_InstanceIndex() {
diff --git a/fxjs/xfa/cjx_tree.cpp b/fxjs/xfa/cjx_tree.cpp
index c1dc937..3992127 100644
--- a/fxjs/xfa/cjx_tree.cpp
+++ b/fxjs/xfa/cjx_tree.cpp
@@ -123,7 +123,8 @@
     return;
   }
 
-  WideString wsExpression = L"#" + GetXFAObject()->GetClassName() + L"[*]";
+  WideString wsExpression =
+      L"#" + WideString::FromASCII(GetXFAObject()->GetClassName()) + L"[*]";
   ResolveNodeList(pValue, wsExpression,
                   XFA_RESOLVENODE_Siblings | XFA_RESOLVENODE_ALL, nullptr);
 }
diff --git a/xfa/fxfa/parser/cscript_datawindow.cpp b/xfa/fxfa/parser/cscript_datawindow.cpp
index 0bf17e5..1328dba 100644
--- a/xfa/fxfa/parser/cscript_datawindow.cpp
+++ b/xfa/fxfa/parser/cscript_datawindow.cpp
@@ -16,7 +16,6 @@
     : CXFA_Object(pDocument,
                   XFA_ObjectType::Object,
                   XFA_Element::DataWindow,
-                  WideStringView(L"dataWindow"),
                   pdfium::MakeUnique<CJX_DataWindow>(this)) {}
 
 CScript_DataWindow::~CScript_DataWindow() {}
diff --git a/xfa/fxfa/parser/cscript_eventpseudomodel.cpp b/xfa/fxfa/parser/cscript_eventpseudomodel.cpp
index ecab6cf..b4953af 100644
--- a/xfa/fxfa/parser/cscript_eventpseudomodel.cpp
+++ b/xfa/fxfa/parser/cscript_eventpseudomodel.cpp
@@ -13,7 +13,6 @@
     : CXFA_Object(pDocument,
                   XFA_ObjectType::Object,
                   XFA_Element::EventPseudoModel,
-                  WideStringView(L"eventPseudoModel"),
                   pdfium::MakeUnique<CJX_EventPseudoModel>(this)) {}
 
 CScript_EventPseudoModel::~CScript_EventPseudoModel() = default;
diff --git a/xfa/fxfa/parser/cscript_hostpseudomodel.cpp b/xfa/fxfa/parser/cscript_hostpseudomodel.cpp
index 75701bf..4501633 100644
--- a/xfa/fxfa/parser/cscript_hostpseudomodel.cpp
+++ b/xfa/fxfa/parser/cscript_hostpseudomodel.cpp
@@ -13,7 +13,6 @@
     : CXFA_Object(pDocument,
                   XFA_ObjectType::Object,
                   XFA_Element::HostPseudoModel,
-                  WideStringView(L"hostPseudoModel"),
                   pdfium::MakeUnique<CJX_HostPseudoModel>(this)) {}
 
 CScript_HostPseudoModel::~CScript_HostPseudoModel() = default;
diff --git a/xfa/fxfa/parser/cscript_layoutpseudomodel.cpp b/xfa/fxfa/parser/cscript_layoutpseudomodel.cpp
index 4e0a4a3..4dfad07 100644
--- a/xfa/fxfa/parser/cscript_layoutpseudomodel.cpp
+++ b/xfa/fxfa/parser/cscript_layoutpseudomodel.cpp
@@ -13,7 +13,6 @@
     : CXFA_Object(pDocument,
                   XFA_ObjectType::Object,
                   XFA_Element::LayoutPseudoModel,
-                  WideStringView(L"layoutPseudoModel"),
                   pdfium::MakeUnique<CJX_LayoutPseudoModel>(this)) {}
 
 CScript_LayoutPseudoModel::~CScript_LayoutPseudoModel() = default;
diff --git a/xfa/fxfa/parser/cscript_logpseudomodel.cpp b/xfa/fxfa/parser/cscript_logpseudomodel.cpp
index d99651c..185ac80 100644
--- a/xfa/fxfa/parser/cscript_logpseudomodel.cpp
+++ b/xfa/fxfa/parser/cscript_logpseudomodel.cpp
@@ -13,7 +13,6 @@
     : CXFA_Object(pDocument,
                   XFA_ObjectType::Object,
                   XFA_Element::LogPseudoModel,
-                  WideStringView(L"logPseudoModel"),
                   pdfium::MakeUnique<CJX_LogPseudoModel>(this)) {}
 
 CScript_LogPseudoModel::~CScript_LogPseudoModel() {}
diff --git a/xfa/fxfa/parser/cscript_signaturepseudomodel.cpp b/xfa/fxfa/parser/cscript_signaturepseudomodel.cpp
index 3a83c8e..1f92369 100644
--- a/xfa/fxfa/parser/cscript_signaturepseudomodel.cpp
+++ b/xfa/fxfa/parser/cscript_signaturepseudomodel.cpp
@@ -14,7 +14,6 @@
     : CXFA_Object(pDocument,
                   XFA_ObjectType::Object,
                   XFA_Element::SignaturePseudoModel,
-                  WideStringView(L"signaturePseudoModel"),
                   pdfium::MakeUnique<CJX_SignaturePseudoModel>(this)) {}
 
 CScript_SignaturePseudoModel::~CScript_SignaturePseudoModel() = default;
diff --git a/xfa/fxfa/parser/cxfa_accessiblecontent.cpp b/xfa/fxfa/parser/cxfa_accessiblecontent.cpp
index 4286b8e..72bd5f0 100644
--- a/xfa/fxfa/parser/cxfa_accessiblecontent.cpp
+++ b/xfa/fxfa/parser/cxfa_accessiblecontent.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kAccessibleContentName[] = L"accessibleContent";
-
 }  // namespace
 
 CXFA_AccessibleContent::CXFA_AccessibleContent(CXFA_Document* doc,
@@ -25,7 +23,6 @@
                 XFA_ObjectType::ContentNode,
                 XFA_Element::AccessibleContent,
                 nullptr,
-                kAccessibleContentAttributeData,
-                kAccessibleContentName) {}
+                kAccessibleContentAttributeData) {}
 
-CXFA_AccessibleContent::~CXFA_AccessibleContent() {}
+CXFA_AccessibleContent::~CXFA_AccessibleContent() = default;
diff --git a/xfa/fxfa/parser/cxfa_acrobat.cpp b/xfa/fxfa/parser/cxfa_acrobat.cpp
index 2f4be07..d12340c 100644
--- a/xfa/fxfa/parser/cxfa_acrobat.cpp
+++ b/xfa/fxfa/parser/cxfa_acrobat.cpp
@@ -15,13 +15,12 @@
     {XFA_Element::Acrobat7, 1, 0},
     {XFA_Element::Common, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kAcrobatAttributeData[] = {
     {XFA_Attribute::Desc, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kAcrobatName[] = L"acrobat";
-
 }  // namespace
 
 CXFA_Acrobat::CXFA_Acrobat(CXFA_Document* doc, XFA_PacketType packet)
@@ -31,7 +30,6 @@
                 XFA_ObjectType::Node,
                 XFA_Element::Acrobat,
                 kAcrobatPropertyData,
-                kAcrobatAttributeData,
-                kAcrobatName) {}
+                kAcrobatAttributeData) {}
 
-CXFA_Acrobat::~CXFA_Acrobat() {}
+CXFA_Acrobat::~CXFA_Acrobat() = default;
diff --git a/xfa/fxfa/parser/cxfa_acrobat7.cpp b/xfa/fxfa/parser/cxfa_acrobat7.cpp
index 92eafb6..a68f9c4 100644
--- a/xfa/fxfa/parser/cxfa_acrobat7.cpp
+++ b/xfa/fxfa/parser/cxfa_acrobat7.cpp
@@ -11,13 +11,12 @@
 const CXFA_Node::PropertyData kAcrobat7PropertyData[] = {
     {XFA_Element::DynamicRender, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kAcrobat7AttributeData[] = {
     {XFA_Attribute::Desc, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kAcrobat7Name[] = L"acrobat7";
-
 }  // namespace
 
 CXFA_Acrobat7::CXFA_Acrobat7(CXFA_Document* doc, XFA_PacketType packet)
@@ -27,7 +26,6 @@
                 XFA_ObjectType::Node,
                 XFA_Element::Acrobat7,
                 kAcrobat7PropertyData,
-                kAcrobat7AttributeData,
-                kAcrobat7Name) {}
+                kAcrobat7AttributeData) {}
 
-CXFA_Acrobat7::~CXFA_Acrobat7() {}
+CXFA_Acrobat7::~CXFA_Acrobat7() = default;
diff --git a/xfa/fxfa/parser/cxfa_adbe_jsconsole.cpp b/xfa/fxfa/parser/cxfa_adbe_jsconsole.cpp
index a650683..b2581b2 100644
--- a/xfa/fxfa/parser/cxfa_adbe_jsconsole.cpp
+++ b/xfa/fxfa/parser/cxfa_adbe_jsconsole.cpp
@@ -8,16 +8,14 @@
 
 namespace {
 
-const CXFA_Node::AttributeData kaDBE_JSConsoleAttributeData[] = {
+const CXFA_Node::AttributeData kADBE_JSConsoleAttributeData[] = {
     {XFA_Attribute::Desc, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kaDBE_JSConsoleName[] = L"ADBE_JSConsole";
-
 }  // namespace
 
-CXFA_aDBE_JSConsole::CXFA_aDBE_JSConsole(CXFA_Document* doc,
+CXFA_ADBE_JSConsole::CXFA_ADBE_JSConsole(CXFA_Document* doc,
                                          XFA_PacketType packet)
     : CXFA_Node(doc,
                 packet,
@@ -25,7 +23,6 @@
                 XFA_ObjectType::ContentNode,
                 XFA_Element::ADBE_JSConsole,
                 nullptr,
-                kaDBE_JSConsoleAttributeData,
-                kaDBE_JSConsoleName) {}
+                kADBE_JSConsoleAttributeData) {}
 
-CXFA_aDBE_JSConsole::~CXFA_aDBE_JSConsole() {}
+CXFA_ADBE_JSConsole::~CXFA_ADBE_JSConsole() = default;
diff --git a/xfa/fxfa/parser/cxfa_adbe_jsconsole.h b/xfa/fxfa/parser/cxfa_adbe_jsconsole.h
index e894479..2fef074 100644
--- a/xfa/fxfa/parser/cxfa_adbe_jsconsole.h
+++ b/xfa/fxfa/parser/cxfa_adbe_jsconsole.h
@@ -9,10 +9,10 @@
 
 #include "xfa/fxfa/parser/cxfa_node.h"
 
-class CXFA_aDBE_JSConsole final : public CXFA_Node {
+class CXFA_ADBE_JSConsole final : public CXFA_Node {
  public:
-  CXFA_aDBE_JSConsole(CXFA_Document* doc, XFA_PacketType packet);
-  ~CXFA_aDBE_JSConsole() override;
+  CXFA_ADBE_JSConsole(CXFA_Document* doc, XFA_PacketType packet);
+  ~CXFA_ADBE_JSConsole() override;
 };
 
 #endif  // XFA_FXFA_PARSER_CXFA_ADBE_JSCONSOLE_H_
diff --git a/xfa/fxfa/parser/cxfa_adbe_jsdebugger.cpp b/xfa/fxfa/parser/cxfa_adbe_jsdebugger.cpp
index b1737e3..db3b890 100644
--- a/xfa/fxfa/parser/cxfa_adbe_jsdebugger.cpp
+++ b/xfa/fxfa/parser/cxfa_adbe_jsdebugger.cpp
@@ -8,16 +8,14 @@
 
 namespace {
 
-const CXFA_Node::AttributeData kaDBE_JSDebuggerAttributeData[] = {
+const CXFA_Node::AttributeData kADBE_JSDebuggerAttributeData[] = {
     {XFA_Attribute::Desc, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kaDBE_JSDebuggerName[] = L"ADBE_JSDebugger";
-
 }  // namespace
 
-CXFA_aDBE_JSDebugger::CXFA_aDBE_JSDebugger(CXFA_Document* doc,
+CXFA_ADBE_JSDebugger::CXFA_ADBE_JSDebugger(CXFA_Document* doc,
                                            XFA_PacketType packet)
     : CXFA_Node(doc,
                 packet,
@@ -25,7 +23,6 @@
                 XFA_ObjectType::ContentNode,
                 XFA_Element::ADBE_JSDebugger,
                 nullptr,
-                kaDBE_JSDebuggerAttributeData,
-                kaDBE_JSDebuggerName) {}
+                kADBE_JSDebuggerAttributeData) {}
 
-CXFA_aDBE_JSDebugger::~CXFA_aDBE_JSDebugger() {}
+CXFA_ADBE_JSDebugger::~CXFA_ADBE_JSDebugger() = default;
diff --git a/xfa/fxfa/parser/cxfa_adbe_jsdebugger.h b/xfa/fxfa/parser/cxfa_adbe_jsdebugger.h
index f7da535..34fcb0c 100644
--- a/xfa/fxfa/parser/cxfa_adbe_jsdebugger.h
+++ b/xfa/fxfa/parser/cxfa_adbe_jsdebugger.h
@@ -9,10 +9,10 @@
 
 #include "xfa/fxfa/parser/cxfa_node.h"
 
-class CXFA_aDBE_JSDebugger final : public CXFA_Node {
+class CXFA_ADBE_JSDebugger final : public CXFA_Node {
  public:
-  CXFA_aDBE_JSDebugger(CXFA_Document* doc, XFA_PacketType packet);
-  ~CXFA_aDBE_JSDebugger() override;
+  CXFA_ADBE_JSDebugger(CXFA_Document* doc, XFA_PacketType packet);
+  ~CXFA_ADBE_JSDebugger() override;
 };
 
 #endif  // XFA_FXFA_PARSER_CXFA_ADBE_JSDEBUGGER_H_
diff --git a/xfa/fxfa/parser/cxfa_addsilentprint.cpp b/xfa/fxfa/parser/cxfa_addsilentprint.cpp
index 74c3633..28d1918 100644
--- a/xfa/fxfa/parser/cxfa_addsilentprint.cpp
+++ b/xfa/fxfa/parser/cxfa_addsilentprint.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kAddSilentPrintName[] = L"addSilentPrint";
-
 }  // namespace
 
 CXFA_AddSilentPrint::CXFA_AddSilentPrint(CXFA_Document* doc,
@@ -25,7 +23,6 @@
                 XFA_ObjectType::ContentNode,
                 XFA_Element::AddSilentPrint,
                 nullptr,
-                kAddSilentPrintAttributeData,
-                kAddSilentPrintName) {}
+                kAddSilentPrintAttributeData) {}
 
-CXFA_AddSilentPrint::~CXFA_AddSilentPrint() {}
+CXFA_AddSilentPrint::~CXFA_AddSilentPrint() = default;
diff --git a/xfa/fxfa/parser/cxfa_addviewerpreferences.cpp b/xfa/fxfa/parser/cxfa_addviewerpreferences.cpp
index 7624410..3d98c73 100644
--- a/xfa/fxfa/parser/cxfa_addviewerpreferences.cpp
+++ b/xfa/fxfa/parser/cxfa_addviewerpreferences.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kAddViewerPreferencesName[] = L"addViewerPreferences";
-
 }  // namespace
 
 CXFA_AddViewerPreferences::CXFA_AddViewerPreferences(CXFA_Document* doc,
@@ -25,7 +23,6 @@
                 XFA_ObjectType::ContentNode,
                 XFA_Element::AddViewerPreferences,
                 nullptr,
-                kAddViewerPreferencesAttributeData,
-                kAddViewerPreferencesName) {}
+                kAddViewerPreferencesAttributeData) {}
 
-CXFA_AddViewerPreferences::~CXFA_AddViewerPreferences() {}
+CXFA_AddViewerPreferences::~CXFA_AddViewerPreferences() = default;
diff --git a/xfa/fxfa/parser/cxfa_adjustdata.cpp b/xfa/fxfa/parser/cxfa_adjustdata.cpp
index 18c72d9..e207ce9 100644
--- a/xfa/fxfa/parser/cxfa_adjustdata.cpp
+++ b/xfa/fxfa/parser/cxfa_adjustdata.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kAdjustDataName[] = L"adjustData";
-
 }  // namespace
 
 CXFA_AdjustData::CXFA_AdjustData(CXFA_Document* doc, XFA_PacketType packet)
@@ -24,7 +22,6 @@
                 XFA_ObjectType::NodeV,
                 XFA_Element::AdjustData,
                 nullptr,
-                kAdjustDataAttributeData,
-                kAdjustDataName) {}
+                kAdjustDataAttributeData) {}
 
-CXFA_AdjustData::~CXFA_AdjustData() {}
+CXFA_AdjustData::~CXFA_AdjustData() = default;
diff --git a/xfa/fxfa/parser/cxfa_adobeextensionlevel.cpp b/xfa/fxfa/parser/cxfa_adobeextensionlevel.cpp
index 593dd910..f29dc97 100644
--- a/xfa/fxfa/parser/cxfa_adobeextensionlevel.cpp
+++ b/xfa/fxfa/parser/cxfa_adobeextensionlevel.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kAdobeExtensionLevelName[] = L"adobeExtensionLevel";
-
 }  // namespace
 
 CXFA_AdobeExtensionLevel::CXFA_AdobeExtensionLevel(CXFA_Document* doc,
@@ -25,7 +23,6 @@
                 XFA_ObjectType::ContentNode,
                 XFA_Element::AdobeExtensionLevel,
                 nullptr,
-                kAdobeExtensionLevelAttributeData,
-                kAdobeExtensionLevelName) {}
+                kAdobeExtensionLevelAttributeData) {}
 
-CXFA_AdobeExtensionLevel::~CXFA_AdobeExtensionLevel() {}
+CXFA_AdobeExtensionLevel::~CXFA_AdobeExtensionLevel() = default;
diff --git a/xfa/fxfa/parser/cxfa_agent.cpp b/xfa/fxfa/parser/cxfa_agent.cpp
index 4643aa1..a70f63f 100644
--- a/xfa/fxfa/parser/cxfa_agent.cpp
+++ b/xfa/fxfa/parser/cxfa_agent.cpp
@@ -14,8 +14,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kAgentName[] = L"agent";
-
 }  // namespace
 
 CXFA_Agent::CXFA_Agent(CXFA_Document* doc, XFA_PacketType packet)
@@ -25,7 +23,6 @@
                 XFA_ObjectType::Node,
                 XFA_Element::Agent,
                 nullptr,
-                kAgentAttributeData,
-                kAgentName) {}
+                kAgentAttributeData) {}
 
-CXFA_Agent::~CXFA_Agent() {}
+CXFA_Agent::~CXFA_Agent() = default;
diff --git a/xfa/fxfa/parser/cxfa_alwaysembed.cpp b/xfa/fxfa/parser/cxfa_alwaysembed.cpp
index d57dfb6..d8b50e3 100644
--- a/xfa/fxfa/parser/cxfa_alwaysembed.cpp
+++ b/xfa/fxfa/parser/cxfa_alwaysembed.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kAlwaysEmbedName[] = L"alwaysEmbed";
-
 }  // namespace
 
 CXFA_AlwaysEmbed::CXFA_AlwaysEmbed(CXFA_Document* doc, XFA_PacketType packet)
@@ -24,7 +22,6 @@
                 XFA_ObjectType::NodeV,
                 XFA_Element::AlwaysEmbed,
                 nullptr,
-                kAlwaysEmbedAttributeData,
-                kAlwaysEmbedName) {}
+                kAlwaysEmbedAttributeData) {}
 
-CXFA_AlwaysEmbed::~CXFA_AlwaysEmbed() {}
+CXFA_AlwaysEmbed::~CXFA_AlwaysEmbed() = default;
diff --git a/xfa/fxfa/parser/cxfa_amd.cpp b/xfa/fxfa/parser/cxfa_amd.cpp
index 539a41a..e26a261 100644
--- a/xfa/fxfa/parser/cxfa_amd.cpp
+++ b/xfa/fxfa/parser/cxfa_amd.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kAmdName[] = L"amd";
-
 }  // namespace
 
 CXFA_Amd::CXFA_Amd(CXFA_Document* doc, XFA_PacketType packet)
@@ -24,7 +22,6 @@
                 XFA_ObjectType::ContentNode,
                 XFA_Element::Amd,
                 nullptr,
-                kAmdAttributeData,
-                kAmdName) {}
+                kAmdAttributeData) {}
 
-CXFA_Amd::~CXFA_Amd() {}
+CXFA_Amd::~CXFA_Amd() = default;
diff --git a/xfa/fxfa/parser/cxfa_appearancefilter.cpp b/xfa/fxfa/parser/cxfa_appearancefilter.cpp
index 8561636..e78b633 100644
--- a/xfa/fxfa/parser/cxfa_appearancefilter.cpp
+++ b/xfa/fxfa/parser/cxfa_appearancefilter.cpp
@@ -16,8 +16,6 @@
     {XFA_Attribute::Usehref, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kAppearanceFilterName[] = L"appearanceFilter";
-
 }  // namespace
 
 CXFA_AppearanceFilter::CXFA_AppearanceFilter(CXFA_Document* doc,
@@ -28,7 +26,6 @@
                 XFA_ObjectType::NodeC,
                 XFA_Element::AppearanceFilter,
                 nullptr,
-                kAppearanceFilterAttributeData,
-                kAppearanceFilterName) {}
+                kAppearanceFilterAttributeData) {}
 
-CXFA_AppearanceFilter::~CXFA_AppearanceFilter() {}
+CXFA_AppearanceFilter::~CXFA_AppearanceFilter() = default;
diff --git a/xfa/fxfa/parser/cxfa_arc.cpp b/xfa/fxfa/parser/cxfa_arc.cpp
index 81d7107..03c427c 100644
--- a/xfa/fxfa/parser/cxfa_arc.cpp
+++ b/xfa/fxfa/parser/cxfa_arc.cpp
@@ -15,6 +15,7 @@
     {XFA_Element::Edge, 1, 0},
     {XFA_Element::Fill, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kArcAttributeData[] = {
     {XFA_Attribute::Id, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Use, XFA_AttributeType::CData, nullptr},
@@ -26,7 +27,6 @@
      (void*)XFA_AttributeValue::Even},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kArcName[] = L"arc";
 
 }  // namespace
 
@@ -38,7 +38,6 @@
                XFA_Element::Arc,
                kArcPropertyData,
                kArcAttributeData,
-               kArcName,
                pdfium::MakeUnique<CJX_Arc>(this)) {}
 
-CXFA_Arc::~CXFA_Arc() {}
+CXFA_Arc::~CXFA_Arc() = default;
diff --git a/xfa/fxfa/parser/cxfa_area.cpp b/xfa/fxfa/parser/cxfa_area.cpp
index be8e832..54ca365 100644
--- a/xfa/fxfa/parser/cxfa_area.cpp
+++ b/xfa/fxfa/parser/cxfa_area.cpp
@@ -15,6 +15,7 @@
     {XFA_Element::Desc, 1, 0},
     {XFA_Element::Extras, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kAreaAttributeData[] = {
     {XFA_Attribute::X, XFA_AttributeType::Measure, (void*)L"0in"},
     {XFA_Attribute::Y, XFA_AttributeType::Measure, (void*)L"0in"},
@@ -28,8 +29,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kAreaName[] = L"area";
-
 }  // namespace
 
 CXFA_Area::CXFA_Area(CXFA_Document* doc, XFA_PacketType packet)
@@ -41,7 +40,6 @@
           XFA_Element::Area,
           kAreaPropertyData,
           kAreaAttributeData,
-          kAreaName,
           pdfium::MakeUnique<CJX_Area>(this)) {}
 
-CXFA_Area::~CXFA_Area() {}
+CXFA_Area::~CXFA_Area() = default;
diff --git a/xfa/fxfa/parser/cxfa_assist.cpp b/xfa/fxfa/parser/cxfa_assist.cpp
index 9ba1408..4119ec7 100644
--- a/xfa/fxfa/parser/cxfa_assist.cpp
+++ b/xfa/fxfa/parser/cxfa_assist.cpp
@@ -15,6 +15,7 @@
     {XFA_Element::ToolTip, 1, 0},
     {XFA_Element::Speak, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kAssistAttributeData[] = {
     {XFA_Attribute::Id, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Use, XFA_AttributeType::CData, nullptr},
@@ -22,8 +23,6 @@
     {XFA_Attribute::Usehref, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kAssistName[] = L"assist";
-
 }  // namespace
 
 CXFA_Assist::CXFA_Assist(CXFA_Document* doc, XFA_PacketType packet)
@@ -34,7 +33,6 @@
                 XFA_Element::Assist,
                 kAssistPropertyData,
                 kAssistAttributeData,
-                kAssistName,
                 pdfium::MakeUnique<CJX_Assist>(this)) {}
 
-CXFA_Assist::~CXFA_Assist() {}
+CXFA_Assist::~CXFA_Assist() = default;
diff --git a/xfa/fxfa/parser/cxfa_attributes.cpp b/xfa/fxfa/parser/cxfa_attributes.cpp
index 7a9df6e..5bac73e 100644
--- a/xfa/fxfa/parser/cxfa_attributes.cpp
+++ b/xfa/fxfa/parser/cxfa_attributes.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kAttributesName[] = L"attributes";
-
 }  // namespace
 
 CXFA_Attributes::CXFA_Attributes(CXFA_Document* doc, XFA_PacketType packet)
@@ -24,7 +22,6 @@
                 XFA_ObjectType::NodeV,
                 XFA_Element::Attributes,
                 nullptr,
-                kAttributesAttributeData,
-                kAttributesName) {}
+                kAttributesAttributeData) {}
 
-CXFA_Attributes::~CXFA_Attributes() {}
+CXFA_Attributes::~CXFA_Attributes() = default;
diff --git a/xfa/fxfa/parser/cxfa_autosave.cpp b/xfa/fxfa/parser/cxfa_autosave.cpp
index d02fe20..01c5219 100644
--- a/xfa/fxfa/parser/cxfa_autosave.cpp
+++ b/xfa/fxfa/parser/cxfa_autosave.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kAutoSaveName[] = L"autoSave";
-
 }  // namespace
 
 CXFA_AutoSave::CXFA_AutoSave(CXFA_Document* doc, XFA_PacketType packet)
@@ -24,7 +22,6 @@
                 XFA_ObjectType::NodeV,
                 XFA_Element::AutoSave,
                 nullptr,
-                kAutoSaveAttributeData,
-                kAutoSaveName) {}
+                kAutoSaveAttributeData) {}
 
-CXFA_AutoSave::~CXFA_AutoSave() {}
+CXFA_AutoSave::~CXFA_AutoSave() = default;
diff --git a/xfa/fxfa/parser/cxfa_barcode.cpp b/xfa/fxfa/parser/cxfa_barcode.cpp
index cc8da5b..316b169 100644
--- a/xfa/fxfa/parser/cxfa_barcode.cpp
+++ b/xfa/fxfa/parser/cxfa_barcode.cpp
@@ -40,8 +40,6 @@
     {XFA_Attribute::EndChar, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kBarcodeName[] = L"barcode";
-
 }  // namespace
 
 CXFA_Barcode::CXFA_Barcode(CXFA_Document* doc, XFA_PacketType packet)
@@ -52,10 +50,9 @@
                 XFA_Element::Barcode,
                 nullptr,
                 kBarcodeAttributeData,
-                kBarcodeName,
                 pdfium::MakeUnique<CJX_Barcode>(this)) {}
 
-CXFA_Barcode::~CXFA_Barcode() {}
+CXFA_Barcode::~CXFA_Barcode() = default;
 
 XFA_FFWidgetType CXFA_Barcode::GetDefaultFFWidgetType() const {
   return XFA_FFWidgetType::kBarcode;
diff --git a/xfa/fxfa/parser/cxfa_base.cpp b/xfa/fxfa/parser/cxfa_base.cpp
index bc23a75..43fc66b 100644
--- a/xfa/fxfa/parser/cxfa_base.cpp
+++ b/xfa/fxfa/parser/cxfa_base.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kBaseName[] = L"base";
-
 }  // namespace
 
 CXFA_Base::CXFA_Base(CXFA_Document* doc, XFA_PacketType packet)
@@ -24,7 +22,6 @@
                 XFA_ObjectType::ContentNode,
                 XFA_Element::Base,
                 nullptr,
-                kBaseAttributeData,
-                kBaseName) {}
+                kBaseAttributeData) {}
 
-CXFA_Base::~CXFA_Base() {}
+CXFA_Base::~CXFA_Base() = default;
diff --git a/xfa/fxfa/parser/cxfa_batchoutput.cpp b/xfa/fxfa/parser/cxfa_batchoutput.cpp
index d274e87..c4b1c58 100644
--- a/xfa/fxfa/parser/cxfa_batchoutput.cpp
+++ b/xfa/fxfa/parser/cxfa_batchoutput.cpp
@@ -15,8 +15,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kBatchOutputName[] = L"batchOutput";
-
 }  // namespace
 
 CXFA_BatchOutput::CXFA_BatchOutput(CXFA_Document* doc, XFA_PacketType packet)
@@ -26,7 +24,6 @@
                 XFA_ObjectType::Node,
                 XFA_Element::BatchOutput,
                 nullptr,
-                kBatchOutputAttributeData,
-                kBatchOutputName) {}
+                kBatchOutputAttributeData) {}
 
-CXFA_BatchOutput::~CXFA_BatchOutput() {}
+CXFA_BatchOutput::~CXFA_BatchOutput() = default;
diff --git a/xfa/fxfa/parser/cxfa_behavioroverride.cpp b/xfa/fxfa/parser/cxfa_behavioroverride.cpp
index 14ee23b..adf709c 100644
--- a/xfa/fxfa/parser/cxfa_behavioroverride.cpp
+++ b/xfa/fxfa/parser/cxfa_behavioroverride.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kBehaviorOverrideName[] = L"behaviorOverride";
-
 }  // namespace
 
 CXFA_BehaviorOverride::CXFA_BehaviorOverride(CXFA_Document* doc,
@@ -25,7 +23,6 @@
                 XFA_ObjectType::ContentNode,
                 XFA_Element::BehaviorOverride,
                 nullptr,
-                kBehaviorOverrideAttributeData,
-                kBehaviorOverrideName) {}
+                kBehaviorOverrideAttributeData) {}
 
-CXFA_BehaviorOverride::~CXFA_BehaviorOverride() {}
+CXFA_BehaviorOverride::~CXFA_BehaviorOverride() = default;
diff --git a/xfa/fxfa/parser/cxfa_bind.cpp b/xfa/fxfa/parser/cxfa_bind.cpp
index 99a2a49..6315d88 100644
--- a/xfa/fxfa/parser/cxfa_bind.cpp
+++ b/xfa/fxfa/parser/cxfa_bind.cpp
@@ -16,6 +16,7 @@
 const CXFA_Node::PropertyData kBindPropertyData[] = {
     {XFA_Element::Picture, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kBindAttributeData[] = {
     {XFA_Attribute::Id, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Name, XFA_AttributeType::CData, nullptr},
@@ -29,8 +30,6 @@
      (void*)XFA_AttributeValue::Once},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kBindName[] = L"bind";
-
 }  // namespace
 
 CXFA_Bind::CXFA_Bind(CXFA_Document* doc, XFA_PacketType packet)
@@ -42,10 +41,9 @@
                 XFA_Element::Bind,
                 kBindPropertyData,
                 kBindAttributeData,
-                kBindName,
                 pdfium::MakeUnique<CJX_Bind>(this)) {}
 
-CXFA_Bind::~CXFA_Bind() {}
+CXFA_Bind::~CXFA_Bind() = default;
 
 WideString CXFA_Bind::GetPicture() {
   CXFA_Picture* pPicture =
diff --git a/xfa/fxfa/parser/cxfa_binditems.cpp b/xfa/fxfa/parser/cxfa_binditems.cpp
index 4116780..d29165b 100644
--- a/xfa/fxfa/parser/cxfa_binditems.cpp
+++ b/xfa/fxfa/parser/cxfa_binditems.cpp
@@ -18,8 +18,6 @@
     {XFA_Attribute::ValueRef, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kBindItemsName[] = L"bindItems";
-
 }  // namespace
 
 CXFA_BindItems::CXFA_BindItems(CXFA_Document* doc, XFA_PacketType packet)
@@ -30,10 +28,9 @@
                 XFA_Element::BindItems,
                 nullptr,
                 kBindItemsAttributeData,
-                kBindItemsName,
                 pdfium::MakeUnique<CJX_BindItems>(this)) {}
 
-CXFA_BindItems::~CXFA_BindItems() {}
+CXFA_BindItems::~CXFA_BindItems() = default;
 
 WideString CXFA_BindItems::GetLabelRef() {
   return JSObject()->GetCData(XFA_Attribute::LabelRef);
diff --git a/xfa/fxfa/parser/cxfa_bookend.cpp b/xfa/fxfa/parser/cxfa_bookend.cpp
index f6ea93b..6434478 100644
--- a/xfa/fxfa/parser/cxfa_bookend.cpp
+++ b/xfa/fxfa/parser/cxfa_bookend.cpp
@@ -19,7 +19,6 @@
     {XFA_Attribute::Leader, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kBookendName[] = L"bookend";
 
 }  // namespace
 
@@ -31,7 +30,6 @@
                 XFA_Element::Bookend,
                 nullptr,
                 kBookendAttributeData,
-                kBookendName,
                 pdfium::MakeUnique<CJX_Bookend>(this)) {}
 
-CXFA_Bookend::~CXFA_Bookend() {}
+CXFA_Bookend::~CXFA_Bookend() = default;
diff --git a/xfa/fxfa/parser/cxfa_boolean.cpp b/xfa/fxfa/parser/cxfa_boolean.cpp
index c3dbbaf..9012b02 100644
--- a/xfa/fxfa/parser/cxfa_boolean.cpp
+++ b/xfa/fxfa/parser/cxfa_boolean.cpp
@@ -18,8 +18,6 @@
     {XFA_Attribute::Usehref, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kBooleanName[] = L"boolean";
-
 }  // namespace
 
 CXFA_Boolean::CXFA_Boolean(CXFA_Document* doc, XFA_PacketType packet)
@@ -31,7 +29,6 @@
                 XFA_Element::Boolean,
                 nullptr,
                 kBooleanAttributeData,
-                kBooleanName,
                 pdfium::MakeUnique<CJX_Boolean>(this)) {}
 
 CXFA_Boolean::~CXFA_Boolean() {}
diff --git a/xfa/fxfa/parser/cxfa_border.cpp b/xfa/fxfa/parser/cxfa_border.cpp
index 0e99dfd..0e50a08 100644
--- a/xfa/fxfa/parser/cxfa_border.cpp
+++ b/xfa/fxfa/parser/cxfa_border.cpp
@@ -15,6 +15,7 @@
     {XFA_Element::Margin, 1, 0}, {XFA_Element::Edge, 4, 0},
     {XFA_Element::Corner, 4, 0}, {XFA_Element::Fill, 1, 0},
     {XFA_Element::Extras, 1, 0}, {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kBorderAttributeData[] = {
     {XFA_Attribute::Id, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Break, XFA_AttributeType::Enum,
@@ -28,8 +29,6 @@
      (void*)XFA_AttributeValue::Even},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kBorderName[] = L"border";
-
 }  // namespace
 
 CXFA_Border::CXFA_Border(CXFA_Document* doc, XFA_PacketType packet)
@@ -40,7 +39,6 @@
                      XFA_Element::Border,
                      kBorderPropertyData,
                      kBorderAttributeData,
-                     kBorderName,
                      pdfium::MakeUnique<CJX_Border>(this)) {}
 
-CXFA_Border::~CXFA_Border() {}
+CXFA_Border::~CXFA_Border() = default;
diff --git a/xfa/fxfa/parser/cxfa_box.cpp b/xfa/fxfa/parser/cxfa_box.cpp
index b65e5b3..2ef2e82 100644
--- a/xfa/fxfa/parser/cxfa_box.cpp
+++ b/xfa/fxfa/parser/cxfa_box.cpp
@@ -64,7 +64,6 @@
                    XFA_Element eType,
                    const PropertyData* properties,
                    const AttributeData* attributes,
-                   const WideStringView& elementName,
                    std::unique_ptr<CJX_Object> js_node)
     : CXFA_Node(pDoc,
                 ePacket,
@@ -73,7 +72,6 @@
                 eType,
                 properties,
                 attributes,
-                elementName,
                 std::move(js_node)) {}
 
 CXFA_Box::~CXFA_Box() = default;
diff --git a/xfa/fxfa/parser/cxfa_box.h b/xfa/fxfa/parser/cxfa_box.h
index 12ac7a4..b882f66 100644
--- a/xfa/fxfa/parser/cxfa_box.h
+++ b/xfa/fxfa/parser/cxfa_box.h
@@ -47,7 +47,6 @@
            XFA_Element eType,
            const PropertyData* properties,
            const AttributeData* attributes,
-           const WideStringView& elementName,
            std::unique_ptr<CJX_Object> js_node);
 
   XFA_AttributeValue GetHand();
diff --git a/xfa/fxfa/parser/cxfa_break.cpp b/xfa/fxfa/parser/cxfa_break.cpp
index b7d030b..398d62b 100644
--- a/xfa/fxfa/parser/cxfa_break.cpp
+++ b/xfa/fxfa/parser/cxfa_break.cpp
@@ -14,6 +14,7 @@
 const CXFA_Node::PropertyData kBreakPropertyData[] = {
     {XFA_Element::Extras, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kBreakAttributeData[] = {
     {XFA_Attribute::Id, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::BeforeTarget, XFA_AttributeType::CData, nullptr},
@@ -32,8 +33,6 @@
      (void*)XFA_AttributeValue::Auto},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kBreakName[] = L"break";
-
 }  // namespace
 
 CXFA_Break::CXFA_Break(CXFA_Document* doc, XFA_PacketType packet)
@@ -44,7 +43,6 @@
                 XFA_Element::Break,
                 kBreakPropertyData,
                 kBreakAttributeData,
-                kBreakName,
                 pdfium::MakeUnique<CJX_Break>(this)) {}
 
-CXFA_Break::~CXFA_Break() {}
+CXFA_Break::~CXFA_Break() = default;
diff --git a/xfa/fxfa/parser/cxfa_breakafter.cpp b/xfa/fxfa/parser/cxfa_breakafter.cpp
index 927f559..c55e5c0 100644
--- a/xfa/fxfa/parser/cxfa_breakafter.cpp
+++ b/xfa/fxfa/parser/cxfa_breakafter.cpp
@@ -14,6 +14,7 @@
 const CXFA_Node::PropertyData kBreakAfterPropertyData[] = {
     {XFA_Element::Script, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kBreakAfterAttributeData[] = {
     {XFA_Attribute::Id, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Use, XFA_AttributeType::CData, nullptr},
@@ -26,8 +27,6 @@
     {XFA_Attribute::Leader, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kBreakAfterName[] = L"breakAfter";
-
 }  // namespace
 
 CXFA_BreakAfter::CXFA_BreakAfter(CXFA_Document* doc, XFA_PacketType packet)
@@ -38,7 +37,6 @@
                 XFA_Element::BreakAfter,
                 kBreakAfterPropertyData,
                 kBreakAfterAttributeData,
-                kBreakAfterName,
                 pdfium::MakeUnique<CJX_BreakAfter>(this)) {}
 
-CXFA_BreakAfter::~CXFA_BreakAfter() {}
+CXFA_BreakAfter::~CXFA_BreakAfter() = default;
diff --git a/xfa/fxfa/parser/cxfa_breakbefore.cpp b/xfa/fxfa/parser/cxfa_breakbefore.cpp
index 36784c1..ff3e59e 100644
--- a/xfa/fxfa/parser/cxfa_breakbefore.cpp
+++ b/xfa/fxfa/parser/cxfa_breakbefore.cpp
@@ -14,6 +14,7 @@
 const CXFA_Node::PropertyData kBreakBeforePropertyData[] = {
     {XFA_Element::Script, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kBreakBeforeAttributeData[] = {
     {XFA_Attribute::Id, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Use, XFA_AttributeType::CData, nullptr},
@@ -26,8 +27,6 @@
     {XFA_Attribute::Leader, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kBreakBeforeName[] = L"breakBefore";
-
 }  // namespace
 
 CXFA_BreakBefore::CXFA_BreakBefore(CXFA_Document* doc, XFA_PacketType packet)
@@ -38,7 +37,6 @@
                 XFA_Element::BreakBefore,
                 kBreakBeforePropertyData,
                 kBreakBeforeAttributeData,
-                kBreakBeforeName,
                 pdfium::MakeUnique<CJX_BreakBefore>(this)) {}
 
-CXFA_BreakBefore::~CXFA_BreakBefore() {}
+CXFA_BreakBefore::~CXFA_BreakBefore() = default;
diff --git a/xfa/fxfa/parser/cxfa_button.cpp b/xfa/fxfa/parser/cxfa_button.cpp
index 15c2791..38a61bd 100644
--- a/xfa/fxfa/parser/cxfa_button.cpp
+++ b/xfa/fxfa/parser/cxfa_button.cpp
@@ -14,6 +14,7 @@
 const CXFA_Node::PropertyData kButtonPropertyData[] = {
     {XFA_Element::Extras, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kButtonAttributeData[] = {
     {XFA_Attribute::Id, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Use, XFA_AttributeType::CData, nullptr},
@@ -22,8 +23,6 @@
      (void*)XFA_AttributeValue::Inverted},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kButtonName[] = L"button";
-
 }  // namespace
 
 CXFA_Button::CXFA_Button(CXFA_Document* doc, XFA_PacketType packet)
@@ -34,10 +33,9 @@
                 XFA_Element::Button,
                 kButtonPropertyData,
                 kButtonAttributeData,
-                kButtonName,
                 pdfium::MakeUnique<CJX_Button>(this)) {}
 
-CXFA_Button::~CXFA_Button() {}
+CXFA_Button::~CXFA_Button() = default;
 
 XFA_FFWidgetType CXFA_Button::GetDefaultFFWidgetType() const {
   return XFA_FFWidgetType::kButton;
diff --git a/xfa/fxfa/parser/cxfa_cache.cpp b/xfa/fxfa/parser/cxfa_cache.cpp
index 1c6d0a2..8553efe 100644
--- a/xfa/fxfa/parser/cxfa_cache.cpp
+++ b/xfa/fxfa/parser/cxfa_cache.cpp
@@ -11,13 +11,12 @@
 const CXFA_Node::PropertyData kCachePropertyData[] = {
     {XFA_Element::TemplateCache, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kCacheAttributeData[] = {
     {XFA_Attribute::Desc, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kCacheName[] = L"cache";
-
 }  // namespace
 
 CXFA_Cache::CXFA_Cache(CXFA_Document* doc, XFA_PacketType packet)
@@ -27,7 +26,6 @@
                 XFA_ObjectType::Node,
                 XFA_Element::Cache,
                 kCachePropertyData,
-                kCacheAttributeData,
-                kCacheName) {}
+                kCacheAttributeData) {}
 
 CXFA_Cache::~CXFA_Cache() {}
diff --git a/xfa/fxfa/parser/cxfa_calculate.cpp b/xfa/fxfa/parser/cxfa_calculate.cpp
index 5b15bcc..0a34760 100644
--- a/xfa/fxfa/parser/cxfa_calculate.cpp
+++ b/xfa/fxfa/parser/cxfa_calculate.cpp
@@ -19,6 +19,7 @@
     {XFA_Element::Script, 1, 0},
     {XFA_Element::Extras, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kCalculateAttributeData[] = {
     {XFA_Attribute::Id, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Use, XFA_AttributeType::CData, nullptr},
@@ -27,8 +28,6 @@
      (void*)XFA_AttributeValue::Error},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kCalculateName[] = L"calculate";
-
 }  // namespace
 
 CXFA_Calculate::CXFA_Calculate(CXFA_Document* doc, XFA_PacketType packet)
@@ -39,10 +38,9 @@
                 XFA_Element::Calculate,
                 kCalculatePropertyData,
                 kCalculateAttributeData,
-                kCalculateName,
                 pdfium::MakeUnique<CJX_Calculate>(this)) {}
 
-CXFA_Calculate::~CXFA_Calculate() {}
+CXFA_Calculate::~CXFA_Calculate() = default;
 
 XFA_AttributeValue CXFA_Calculate::GetOverride() {
   return JSObject()
diff --git a/xfa/fxfa/parser/cxfa_calendarsymbols.cpp b/xfa/fxfa/parser/cxfa_calendarsymbols.cpp
index 507f1f8..a4fe532 100644
--- a/xfa/fxfa/parser/cxfa_calendarsymbols.cpp
+++ b/xfa/fxfa/parser/cxfa_calendarsymbols.cpp
@@ -14,13 +14,12 @@
     {XFA_Element::MeridiemNames, 1, 0},
     {XFA_Element::MonthNames, 2, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kCalendarSymbolsAttributeData[] = {
     {XFA_Attribute::Name, XFA_AttributeType::Enum,
      (void*)XFA_AttributeValue::Gregorian},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kCalendarSymbolsName[] = L"calendarSymbols";
-
 }  // namespace
 
 CXFA_CalendarSymbols::CXFA_CalendarSymbols(CXFA_Document* doc,
@@ -31,7 +30,6 @@
                 XFA_ObjectType::Node,
                 XFA_Element::CalendarSymbols,
                 kCalendarSymbolsPropertyData,
-                kCalendarSymbolsAttributeData,
-                kCalendarSymbolsName) {}
+                kCalendarSymbolsAttributeData) {}
 
-CXFA_CalendarSymbols::~CXFA_CalendarSymbols() {}
+CXFA_CalendarSymbols::~CXFA_CalendarSymbols() = default;
diff --git a/xfa/fxfa/parser/cxfa_caption.cpp b/xfa/fxfa/parser/cxfa_caption.cpp
index 22f1851..5b27b58 100644
--- a/xfa/fxfa/parser/cxfa_caption.cpp
+++ b/xfa/fxfa/parser/cxfa_caption.cpp
@@ -19,6 +19,7 @@
     {XFA_Element::Margin, 1, 0}, {XFA_Element::Para, 1, 0},
     {XFA_Element::Font, 1, 0},   {XFA_Element::Value, 1, 0},
     {XFA_Element::Extras, 1, 0}, {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kCaptionAttributeData[] = {
     {XFA_Attribute::Id, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Use, XFA_AttributeType::CData, nullptr},
@@ -30,8 +31,6 @@
      (void*)XFA_AttributeValue::Left},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kCaptionName[] = L"caption";
-
 }  // namespace
 
 CXFA_Caption::CXFA_Caption(CXFA_Document* doc, XFA_PacketType packet)
@@ -42,10 +41,9 @@
                 XFA_Element::Caption,
                 kCaptionPropertyData,
                 kCaptionAttributeData,
-                kCaptionName,
                 pdfium::MakeUnique<CJX_Caption>(this)) {}
 
-CXFA_Caption::~CXFA_Caption() {}
+CXFA_Caption::~CXFA_Caption() = default;
 
 bool CXFA_Caption::IsVisible() {
   return JSObject()
diff --git a/xfa/fxfa/parser/cxfa_certificate.cpp b/xfa/fxfa/parser/cxfa_certificate.cpp
index e7e203d..cf1200c 100644
--- a/xfa/fxfa/parser/cxfa_certificate.cpp
+++ b/xfa/fxfa/parser/cxfa_certificate.cpp
@@ -18,8 +18,6 @@
     {XFA_Attribute::Usehref, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kCertificateName[] = L"certificate";
-
 }  // namespace
 
 CXFA_Certificate::CXFA_Certificate(CXFA_Document* doc, XFA_PacketType packet)
@@ -30,7 +28,6 @@
                 XFA_Element::Certificate,
                 nullptr,
                 kCertificateAttributeData,
-                kCertificateName,
                 pdfium::MakeUnique<CJX_Certificate>(this)) {}
 
-CXFA_Certificate::~CXFA_Certificate() {}
+CXFA_Certificate::~CXFA_Certificate() = default;
diff --git a/xfa/fxfa/parser/cxfa_certificates.cpp b/xfa/fxfa/parser/cxfa_certificates.cpp
index 62aa428..b0d8add 100644
--- a/xfa/fxfa/parser/cxfa_certificates.cpp
+++ b/xfa/fxfa/parser/cxfa_certificates.cpp
@@ -15,6 +15,7 @@
     {XFA_Element::KeyUsage, 1, 0}, {XFA_Element::SubjectDNs, 1, 0},
     {XFA_Element::Issuers, 1, 0},  {XFA_Element::Signing, 1, 0},
     {XFA_Element::Oids, 1, 0},     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kCertificatesAttributeData[] = {
     {XFA_Attribute::Id, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Url, XFA_AttributeType::CData, nullptr},
@@ -25,8 +26,6 @@
     {XFA_Attribute::UrlPolicy, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kCertificatesName[] = L"certificates";
-
 }  // namespace
 
 CXFA_Certificates::CXFA_Certificates(CXFA_Document* doc, XFA_PacketType packet)
@@ -37,7 +36,6 @@
                 XFA_Element::Certificates,
                 kCertificatesPropertyData,
                 kCertificatesAttributeData,
-                kCertificatesName,
                 pdfium::MakeUnique<CJX_Certificates>(this)) {}
 
-CXFA_Certificates::~CXFA_Certificates() {}
+CXFA_Certificates::~CXFA_Certificates() = default;
diff --git a/xfa/fxfa/parser/cxfa_change.cpp b/xfa/fxfa/parser/cxfa_change.cpp
index 2b968d4..1a02bf2 100644
--- a/xfa/fxfa/parser/cxfa_change.cpp
+++ b/xfa/fxfa/parser/cxfa_change.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kChangeName[] = L"change";
-
 }  // namespace
 
 CXFA_Change::CXFA_Change(CXFA_Document* doc, XFA_PacketType packet)
@@ -24,7 +22,6 @@
                 XFA_ObjectType::ContentNode,
                 XFA_Element::Change,
                 nullptr,
-                kChangeAttributeData,
-                kChangeName) {}
+                kChangeAttributeData) {}
 
-CXFA_Change::~CXFA_Change() {}
+CXFA_Change::~CXFA_Change() = default;
diff --git a/xfa/fxfa/parser/cxfa_checkbutton.cpp b/xfa/fxfa/parser/cxfa_checkbutton.cpp
index 1ef8c14..301a23c 100644
--- a/xfa/fxfa/parser/cxfa_checkbutton.cpp
+++ b/xfa/fxfa/parser/cxfa_checkbutton.cpp
@@ -16,6 +16,7 @@
     {XFA_Element::Border, 1, 0},
     {XFA_Element::Extras, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kCheckButtonAttributeData[] = {
     {XFA_Attribute::Id, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Use, XFA_AttributeType::CData, nullptr},
@@ -28,8 +29,6 @@
     {XFA_Attribute::Usehref, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kCheckButtonName[] = L"checkButton";
-
 }  // namespace
 
 CXFA_CheckButton::CXFA_CheckButton(CXFA_Document* doc, XFA_PacketType packet)
@@ -40,10 +39,9 @@
                 XFA_Element::CheckButton,
                 kCheckButtonPropertyData,
                 kCheckButtonAttributeData,
-                kCheckButtonName,
                 pdfium::MakeUnique<CJX_CheckButton>(this)) {}
 
-CXFA_CheckButton::~CXFA_CheckButton() {}
+CXFA_CheckButton::~CXFA_CheckButton() = default;
 
 XFA_FFWidgetType CXFA_CheckButton::GetDefaultFFWidgetType() const {
   return XFA_FFWidgetType::kCheckButton;
diff --git a/xfa/fxfa/parser/cxfa_choicelist.cpp b/xfa/fxfa/parser/cxfa_choicelist.cpp
index 7815686..3d7b98c 100644
--- a/xfa/fxfa/parser/cxfa_choicelist.cpp
+++ b/xfa/fxfa/parser/cxfa_choicelist.cpp
@@ -16,6 +16,7 @@
     {XFA_Element::Border, 1, 0},
     {XFA_Element::Extras, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kChoiceListAttributeData[] = {
     {XFA_Attribute::Id, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Use, XFA_AttributeType::CData, nullptr},
@@ -27,8 +28,6 @@
     {XFA_Attribute::Usehref, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kChoiceListName[] = L"choiceList";
-
 }  // namespace
 
 CXFA_ChoiceList::CXFA_ChoiceList(CXFA_Document* doc, XFA_PacketType packet)
@@ -39,10 +38,9 @@
                 XFA_Element::ChoiceList,
                 kChoiceListPropertyData,
                 kChoiceListAttributeData,
-                kChoiceListName,
                 pdfium::MakeUnique<CJX_ChoiceList>(this)) {}
 
-CXFA_ChoiceList::~CXFA_ChoiceList() {}
+CXFA_ChoiceList::~CXFA_ChoiceList() = default;
 
 XFA_Element CXFA_ChoiceList::GetValueNodeType() const {
   return JSObject()->GetEnum(XFA_Attribute::Open) ==
diff --git a/xfa/fxfa/parser/cxfa_color.cpp b/xfa/fxfa/parser/cxfa_color.cpp
index 6fc6397..3e52419 100644
--- a/xfa/fxfa/parser/cxfa_color.cpp
+++ b/xfa/fxfa/parser/cxfa_color.cpp
@@ -14,6 +14,7 @@
 const CXFA_Node::PropertyData kColorPropertyData[] = {
     {XFA_Element::Extras, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kColorAttributeData[] = {
     {XFA_Attribute::Id, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Use, XFA_AttributeType::CData, nullptr},
@@ -22,8 +23,6 @@
     {XFA_Attribute::Value, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kColorName[] = L"color";
-
 }  // namespace
 
 CXFA_Color::CXFA_Color(CXFA_Document* doc, XFA_PacketType packet)
@@ -34,10 +33,9 @@
                 XFA_Element::Color,
                 kColorPropertyData,
                 kColorAttributeData,
-                kColorName,
                 pdfium::MakeUnique<CJX_Color>(this)) {}
 
-CXFA_Color::~CXFA_Color() {}
+CXFA_Color::~CXFA_Color() = default;
 
 FX_ARGB CXFA_Color::GetValue() {
   Optional<WideString> val = JSObject()->TryCData(XFA_Attribute::Value, false);
diff --git a/xfa/fxfa/parser/cxfa_comb.cpp b/xfa/fxfa/parser/cxfa_comb.cpp
index 1be4f56..5c85832 100644
--- a/xfa/fxfa/parser/cxfa_comb.cpp
+++ b/xfa/fxfa/parser/cxfa_comb.cpp
@@ -18,8 +18,6 @@
     {XFA_Attribute::Usehref, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kCombName[] = L"comb";
-
 }  // namespace
 
 CXFA_Comb::CXFA_Comb(CXFA_Document* doc, XFA_PacketType packet)
@@ -30,7 +28,6 @@
                 XFA_Element::Comb,
                 nullptr,
                 kCombAttributeData,
-                kCombName,
                 pdfium::MakeUnique<CJX_Comb>(this)) {}
 
 CXFA_Comb::~CXFA_Comb() {}
diff --git a/xfa/fxfa/parser/cxfa_command.cpp b/xfa/fxfa/parser/cxfa_command.cpp
index bf786e1..08929a7 100644
--- a/xfa/fxfa/parser/cxfa_command.cpp
+++ b/xfa/fxfa/parser/cxfa_command.cpp
@@ -17,6 +17,7 @@
     {XFA_Element::Update, 1, 0},
     {XFA_Element::Delete, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kCommandAttributeData[] = {
     {XFA_Attribute::Id, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Name, XFA_AttributeType::CData, nullptr},
@@ -25,8 +26,6 @@
     {XFA_Attribute::Usehref, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kCommandName[] = L"command";
-
 }  // namespace
 
 CXFA_Command::CXFA_Command(CXFA_Document* doc, XFA_PacketType packet)
@@ -37,7 +36,6 @@
                 XFA_Element::Command,
                 kCommandPropertyData,
                 kCommandAttributeData,
-                kCommandName,
                 pdfium::MakeUnique<CJX_Command>(this)) {}
 
-CXFA_Command::~CXFA_Command() {}
+CXFA_Command::~CXFA_Command() = default;
diff --git a/xfa/fxfa/parser/cxfa_common.cpp b/xfa/fxfa/parser/cxfa_common.cpp
index 76c8f50..aea95cc 100644
--- a/xfa/fxfa/parser/cxfa_common.cpp
+++ b/xfa/fxfa/parser/cxfa_common.cpp
@@ -18,13 +18,12 @@
     {XFA_Element::Data, 1, 0},
     {XFA_Element::Messaging, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kCommonAttributeData[] = {
     {XFA_Attribute::Desc, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kCommonName[] = L"common";
-
 }  // namespace
 
 CXFA_Common::CXFA_Common(CXFA_Document* doc, XFA_PacketType packet)
@@ -34,7 +33,6 @@
                 XFA_ObjectType::Node,
                 XFA_Element::Common,
                 kCommonPropertyData,
-                kCommonAttributeData,
-                kCommonName) {}
+                kCommonAttributeData) {}
 
-CXFA_Common::~CXFA_Common() {}
+CXFA_Common::~CXFA_Common() = default;
diff --git a/xfa/fxfa/parser/cxfa_compress.cpp b/xfa/fxfa/parser/cxfa_compress.cpp
index 672bced..991a40a 100644
--- a/xfa/fxfa/parser/cxfa_compress.cpp
+++ b/xfa/fxfa/parser/cxfa_compress.cpp
@@ -15,8 +15,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kCompressName[] = L"compress";
-
 }  // namespace
 
 CXFA_Compress::CXFA_Compress(CXFA_Document* doc, XFA_PacketType packet)
@@ -26,7 +24,6 @@
                 XFA_ObjectType::Node,
                 XFA_Element::Compress,
                 nullptr,
-                kCompressAttributeData,
-                kCompressName) {}
+                kCompressAttributeData) {}
 
-CXFA_Compress::~CXFA_Compress() {}
+CXFA_Compress::~CXFA_Compress() = default;
diff --git a/xfa/fxfa/parser/cxfa_compression.cpp b/xfa/fxfa/parser/cxfa_compression.cpp
index 615b5e6..54caf77 100644
--- a/xfa/fxfa/parser/cxfa_compression.cpp
+++ b/xfa/fxfa/parser/cxfa_compression.cpp
@@ -14,13 +14,12 @@
     {XFA_Element::CompressObjectStream, 1, 0},
     {XFA_Element::CompressLogicalStructure, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kCompressionAttributeData[] = {
     {XFA_Attribute::Desc, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kCompressionName[] = L"compression";
-
 }  // namespace
 
 CXFA_Compression::CXFA_Compression(CXFA_Document* doc, XFA_PacketType packet)
@@ -30,7 +29,6 @@
                 XFA_ObjectType::Node,
                 XFA_Element::Compression,
                 kCompressionPropertyData,
-                kCompressionAttributeData,
-                kCompressionName) {}
+                kCompressionAttributeData) {}
 
-CXFA_Compression::~CXFA_Compression() {}
+CXFA_Compression::~CXFA_Compression() = default;
diff --git a/xfa/fxfa/parser/cxfa_compresslogicalstructure.cpp b/xfa/fxfa/parser/cxfa_compresslogicalstructure.cpp
index 77ac93e..0cba778 100644
--- a/xfa/fxfa/parser/cxfa_compresslogicalstructure.cpp
+++ b/xfa/fxfa/parser/cxfa_compresslogicalstructure.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kCompressLogicalStructureName[] = L"compressLogicalStructure";
-
 }  // namespace
 
 CXFA_CompressLogicalStructure::CXFA_CompressLogicalStructure(
@@ -26,7 +24,6 @@
                 XFA_ObjectType::ContentNode,
                 XFA_Element::CompressLogicalStructure,
                 nullptr,
-                kCompressLogicalStructureAttributeData,
-                kCompressLogicalStructureName) {}
+                kCompressLogicalStructureAttributeData) {}
 
-CXFA_CompressLogicalStructure::~CXFA_CompressLogicalStructure() {}
+CXFA_CompressLogicalStructure::~CXFA_CompressLogicalStructure() = default;
diff --git a/xfa/fxfa/parser/cxfa_compressobjectstream.cpp b/xfa/fxfa/parser/cxfa_compressobjectstream.cpp
index 9d3a0cf..1c9650d 100644
--- a/xfa/fxfa/parser/cxfa_compressobjectstream.cpp
+++ b/xfa/fxfa/parser/cxfa_compressobjectstream.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kCompressObjectStreamName[] = L"compressObjectStream";
-
 }  // namespace
 
 CXFA_CompressObjectStream::CXFA_CompressObjectStream(CXFA_Document* doc,
@@ -25,7 +23,6 @@
                 XFA_ObjectType::ContentNode,
                 XFA_Element::CompressObjectStream,
                 nullptr,
-                kCompressObjectStreamAttributeData,
-                kCompressObjectStreamName) {}
+                kCompressObjectStreamAttributeData) {}
 
-CXFA_CompressObjectStream::~CXFA_CompressObjectStream() {}
+CXFA_CompressObjectStream::~CXFA_CompressObjectStream() = default;
diff --git a/xfa/fxfa/parser/cxfa_config.cpp b/xfa/fxfa/parser/cxfa_config.cpp
index 8d23bc0..c864d71 100644
--- a/xfa/fxfa/parser/cxfa_config.cpp
+++ b/xfa/fxfa/parser/cxfa_config.cpp
@@ -13,13 +13,12 @@
     {XFA_Element::Acrobat, 1, 0},
     {XFA_Element::Trace, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kConfigAttributeData[] = {
     {XFA_Attribute::Desc, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kConfigName[] = L"config";
-
 }  // namespace
 
 CXFA_Config::CXFA_Config(CXFA_Document* doc, XFA_PacketType packet)
@@ -29,7 +28,6 @@
                 XFA_ObjectType::ModelNode,
                 XFA_Element::Config,
                 kConfigPropertyData,
-                kConfigAttributeData,
-                kConfigName) {}
+                kConfigAttributeData) {}
 
-CXFA_Config::~CXFA_Config() {}
+CXFA_Config::~CXFA_Config() = default;
diff --git a/xfa/fxfa/parser/cxfa_conformance.cpp b/xfa/fxfa/parser/cxfa_conformance.cpp
index 9b15fd9..a2343ac 100644
--- a/xfa/fxfa/parser/cxfa_conformance.cpp
+++ b/xfa/fxfa/parser/cxfa_conformance.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kConformanceName[] = L"conformance";
-
 }  // namespace
 
 CXFA_Conformance::CXFA_Conformance(CXFA_Document* doc, XFA_PacketType packet)
@@ -24,7 +22,6 @@
                 XFA_ObjectType::ContentNode,
                 XFA_Element::Conformance,
                 nullptr,
-                kConformanceAttributeData,
-                kConformanceName) {}
+                kConformanceAttributeData) {}
 
-CXFA_Conformance::~CXFA_Conformance() {}
+CXFA_Conformance::~CXFA_Conformance() = default;
diff --git a/xfa/fxfa/parser/cxfa_connect.cpp b/xfa/fxfa/parser/cxfa_connect.cpp
index 61971ed..088659e 100644
--- a/xfa/fxfa/parser/cxfa_connect.cpp
+++ b/xfa/fxfa/parser/cxfa_connect.cpp
@@ -17,6 +17,7 @@
     {XFA_Element::User, 1, 0},
     {XFA_Element::Password, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kConnectAttributeData[] = {
     {XFA_Attribute::Id, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Name, XFA_AttributeType::CData, nullptr},
@@ -30,8 +31,6 @@
     {XFA_Attribute::DelayedOpen, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kConnectName[] = L"connect";
-
 }  // namespace
 
 CXFA_Connect::CXFA_Connect(CXFA_Document* doc, XFA_PacketType packet)
@@ -43,7 +42,6 @@
                 XFA_Element::Connect,
                 kConnectPropertyData,
                 kConnectAttributeData,
-                kConnectName,
                 pdfium::MakeUnique<CJX_Connect>(this)) {}
 
-CXFA_Connect::~CXFA_Connect() {}
+CXFA_Connect::~CXFA_Connect() = default;
diff --git a/xfa/fxfa/parser/cxfa_connectionset.cpp b/xfa/fxfa/parser/cxfa_connectionset.cpp
index 65ca758..e46e91e 100644
--- a/xfa/fxfa/parser/cxfa_connectionset.cpp
+++ b/xfa/fxfa/parser/cxfa_connectionset.cpp
@@ -9,12 +9,6 @@
 #include "fxjs/xfa/cjx_model.h"
 #include "third_party/base/ptr_util.h"
 
-namespace {
-
-constexpr wchar_t kConnectionSetName[] = L"connectionSet";
-
-}  // namespace
-
 CXFA_ConnectionSet::CXFA_ConnectionSet(CXFA_Document* doc,
                                        XFA_PacketType packet)
     : CXFA_Node(doc,
@@ -24,7 +18,6 @@
                 XFA_Element::ConnectionSet,
                 nullptr,
                 nullptr,
-                kConnectionSetName,
                 pdfium::MakeUnique<CJX_Model>(this)) {}
 
-CXFA_ConnectionSet::~CXFA_ConnectionSet() {}
+CXFA_ConnectionSet::~CXFA_ConnectionSet() = default;
diff --git a/xfa/fxfa/parser/cxfa_connectstring.cpp b/xfa/fxfa/parser/cxfa_connectstring.cpp
index bf0c9e2..8658f0b 100644
--- a/xfa/fxfa/parser/cxfa_connectstring.cpp
+++ b/xfa/fxfa/parser/cxfa_connectstring.cpp
@@ -18,8 +18,6 @@
     {XFA_Attribute::Usehref, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kConnectStringName[] = L"connectString";
-
 }  // namespace
 
 CXFA_ConnectString::CXFA_ConnectString(CXFA_Document* doc,
@@ -31,7 +29,6 @@
                 XFA_Element::ConnectString,
                 nullptr,
                 kConnectStringAttributeData,
-                kConnectStringName,
                 pdfium::MakeUnique<CJX_ConnectString>(this)) {}
 
-CXFA_ConnectString::~CXFA_ConnectString() {}
+CXFA_ConnectString::~CXFA_ConnectString() = default;
diff --git a/xfa/fxfa/parser/cxfa_contentarea.cpp b/xfa/fxfa/parser/cxfa_contentarea.cpp
index 0883f46..4c002a4 100644
--- a/xfa/fxfa/parser/cxfa_contentarea.cpp
+++ b/xfa/fxfa/parser/cxfa_contentarea.cpp
@@ -15,6 +15,7 @@
     {XFA_Element::Desc, 1, 0},
     {XFA_Element::Extras, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kContentAreaAttributeData[] = {
     {XFA_Attribute::H, XFA_AttributeType::Measure, (void*)L"0in"},
     {XFA_Attribute::W, XFA_AttributeType::Measure, (void*)L"0in"},
@@ -27,8 +28,6 @@
     {XFA_Attribute::Usehref, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kContentAreaName[] = L"contentArea";
-
 }  // namespace
 
 CXFA_ContentArea::CXFA_ContentArea(CXFA_Document* doc, XFA_PacketType packet)
@@ -39,7 +38,6 @@
                 XFA_Element::ContentArea,
                 kContentAreaPropertyData,
                 kContentAreaAttributeData,
-                kContentAreaName,
                 pdfium::MakeUnique<CJX_ContentArea>(this)) {}
 
-CXFA_ContentArea::~CXFA_ContentArea() {}
+CXFA_ContentArea::~CXFA_ContentArea() = default;
diff --git a/xfa/fxfa/parser/cxfa_contentcopy.cpp b/xfa/fxfa/parser/cxfa_contentcopy.cpp
index 5ae862a..a095350 100644
--- a/xfa/fxfa/parser/cxfa_contentcopy.cpp
+++ b/xfa/fxfa/parser/cxfa_contentcopy.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kContentCopyName[] = L"contentCopy";
-
 }  // namespace
 
 CXFA_ContentCopy::CXFA_ContentCopy(CXFA_Document* doc, XFA_PacketType packet)
@@ -24,7 +22,6 @@
                 XFA_ObjectType::ContentNode,
                 XFA_Element::ContentCopy,
                 nullptr,
-                kContentCopyAttributeData,
-                kContentCopyName) {}
+                kContentCopyAttributeData) {}
 
-CXFA_ContentCopy::~CXFA_ContentCopy() {}
+CXFA_ContentCopy::~CXFA_ContentCopy() = default;
diff --git a/xfa/fxfa/parser/cxfa_copies.cpp b/xfa/fxfa/parser/cxfa_copies.cpp
index 5c0ddc9..dd96388 100644
--- a/xfa/fxfa/parser/cxfa_copies.cpp
+++ b/xfa/fxfa/parser/cxfa_copies.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kCopiesName[] = L"copies";
-
 }  // namespace
 
 CXFA_Copies::CXFA_Copies(CXFA_Document* doc, XFA_PacketType packet)
@@ -24,7 +22,6 @@
                 XFA_ObjectType::ContentNode,
                 XFA_Element::Copies,
                 nullptr,
-                kCopiesAttributeData,
-                kCopiesName) {}
+                kCopiesAttributeData) {}
 
-CXFA_Copies::~CXFA_Copies() {}
+CXFA_Copies::~CXFA_Copies() = default;
diff --git a/xfa/fxfa/parser/cxfa_corner.cpp b/xfa/fxfa/parser/cxfa_corner.cpp
index 16d4bff..1c29a10 100644
--- a/xfa/fxfa/parser/cxfa_corner.cpp
+++ b/xfa/fxfa/parser/cxfa_corner.cpp
@@ -15,6 +15,7 @@
     {XFA_Element::Color, 1, 0},
     {XFA_Element::Extras, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kCornerAttributeData[] = {
     {XFA_Attribute::Id, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Use, XFA_AttributeType::CData, nullptr},
@@ -30,8 +31,6 @@
     {XFA_Attribute::Radius, XFA_AttributeType::Measure, (void*)L"0in"},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kCornerName[] = L"corner";
-
 }  // namespace
 
 CXFA_Corner::CXFA_Corner(CXFA_Document* doc, XFA_PacketType packet)
@@ -42,7 +41,6 @@
                   XFA_Element::Corner,
                   kCornerPropertyData,
                   kCornerAttributeData,
-                  kCornerName,
                   pdfium::MakeUnique<CJX_Corner>(this)) {}
 
-CXFA_Corner::~CXFA_Corner() {}
+CXFA_Corner::~CXFA_Corner() = default;
diff --git a/xfa/fxfa/parser/cxfa_creator.cpp b/xfa/fxfa/parser/cxfa_creator.cpp
index bd09fd1..f30269b 100644
--- a/xfa/fxfa/parser/cxfa_creator.cpp
+++ b/xfa/fxfa/parser/cxfa_creator.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kCreatorName[] = L"creator";
-
 }  // namespace
 
 CXFA_Creator::CXFA_Creator(CXFA_Document* doc, XFA_PacketType packet)
@@ -24,7 +22,6 @@
                 XFA_ObjectType::ContentNode,
                 XFA_Element::Creator,
                 nullptr,
-                kCreatorAttributeData,
-                kCreatorName) {}
+                kCreatorAttributeData) {}
 
-CXFA_Creator::~CXFA_Creator() {}
+CXFA_Creator::~CXFA_Creator() = default;
diff --git a/xfa/fxfa/parser/cxfa_currencysymbol.cpp b/xfa/fxfa/parser/cxfa_currencysymbol.cpp
index d95df3f..e0bc064 100644
--- a/xfa/fxfa/parser/cxfa_currencysymbol.cpp
+++ b/xfa/fxfa/parser/cxfa_currencysymbol.cpp
@@ -13,8 +13,6 @@
      (void*)XFA_AttributeValue::Symbol},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kCurrencySymbolName[] = L"currencySymbol";
-
 }  // namespace
 
 CXFA_CurrencySymbol::CXFA_CurrencySymbol(CXFA_Document* doc,
@@ -25,7 +23,6 @@
                 XFA_ObjectType::ContentNode,
                 XFA_Element::CurrencySymbol,
                 nullptr,
-                kCurrencySymbolAttributeData,
-                kCurrencySymbolName) {}
+                kCurrencySymbolAttributeData) {}
 
-CXFA_CurrencySymbol::~CXFA_CurrencySymbol() {}
+CXFA_CurrencySymbol::~CXFA_CurrencySymbol() = default;
diff --git a/xfa/fxfa/parser/cxfa_currencysymbols.cpp b/xfa/fxfa/parser/cxfa_currencysymbols.cpp
index e82da2f..2198405 100644
--- a/xfa/fxfa/parser/cxfa_currencysymbols.cpp
+++ b/xfa/fxfa/parser/cxfa_currencysymbols.cpp
@@ -12,8 +12,6 @@
     {XFA_Element::CurrencySymbol, 3, 0},
     {XFA_Element::Unknown, 0, 0}};
 
-constexpr wchar_t kCurrencySymbolsName[] = L"currencySymbols";
-
 }  // namespace
 
 CXFA_CurrencySymbols::CXFA_CurrencySymbols(CXFA_Document* doc,
@@ -24,7 +22,6 @@
                 XFA_ObjectType::Node,
                 XFA_Element::CurrencySymbols,
                 kCurrencySymbolsPropertyData,
-                nullptr,
-                kCurrencySymbolsName) {}
+                nullptr) {}
 
-CXFA_CurrencySymbols::~CXFA_CurrencySymbols() {}
+CXFA_CurrencySymbols::~CXFA_CurrencySymbols() = default;
diff --git a/xfa/fxfa/parser/cxfa_currentpage.cpp b/xfa/fxfa/parser/cxfa_currentpage.cpp
index cab81de..131d2e5 100644
--- a/xfa/fxfa/parser/cxfa_currentpage.cpp
+++ b/xfa/fxfa/parser/cxfa_currentpage.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kCurrentPageName[] = L"currentPage";
-
 }  // namespace
 
 CXFA_CurrentPage::CXFA_CurrentPage(CXFA_Document* doc, XFA_PacketType packet)
@@ -24,7 +22,6 @@
                 XFA_ObjectType::ContentNode,
                 XFA_Element::CurrentPage,
                 nullptr,
-                kCurrentPageAttributeData,
-                kCurrentPageName) {}
+                kCurrentPageAttributeData) {}
 
-CXFA_CurrentPage::~CXFA_CurrentPage() {}
+CXFA_CurrentPage::~CXFA_CurrentPage() = default;
diff --git a/xfa/fxfa/parser/cxfa_data.cpp b/xfa/fxfa/parser/cxfa_data.cpp
index 39df531..02843ad 100644
--- a/xfa/fxfa/parser/cxfa_data.cpp
+++ b/xfa/fxfa/parser/cxfa_data.cpp
@@ -15,13 +15,12 @@
     {XFA_Element::Window, 1, 0},     {XFA_Element::Record, 1, 0},
     {XFA_Element::Range, 1, 0},      {XFA_Element::IncrementalLoad, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kDataAttributeData[] = {
     {XFA_Attribute::Desc, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kDataName[] = L"data";
-
 }  // namespace
 
 CXFA_Data::CXFA_Data(CXFA_Document* doc, XFA_PacketType packet)
@@ -31,7 +30,6 @@
                 XFA_ObjectType::Node,
                 XFA_Element::Data,
                 kDataPropertyData,
-                kDataAttributeData,
-                kDataName) {}
+                kDataAttributeData) {}
 
-CXFA_Data::~CXFA_Data() {}
+CXFA_Data::~CXFA_Data() = default;
diff --git a/xfa/fxfa/parser/cxfa_datagroup.cpp b/xfa/fxfa/parser/cxfa_datagroup.cpp
index 6b59e55..baae42b 100644
--- a/xfa/fxfa/parser/cxfa_datagroup.cpp
+++ b/xfa/fxfa/parser/cxfa_datagroup.cpp
@@ -12,8 +12,6 @@
     {XFA_Attribute::Name, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kDataGroupName[] = L"dataGroup";
-
 }  // namespace
 
 CXFA_DataGroup::CXFA_DataGroup(CXFA_Document* doc, XFA_PacketType packet)
@@ -23,7 +21,6 @@
                 XFA_ObjectType::Node,
                 XFA_Element::DataGroup,
                 nullptr,
-                kDataGroupAttributeData,
-                kDataGroupName) {}
+                kDataGroupAttributeData) {}
 
-CXFA_DataGroup::~CXFA_DataGroup() {}
+CXFA_DataGroup::~CXFA_DataGroup() = default;
diff --git a/xfa/fxfa/parser/cxfa_datamodel.cpp b/xfa/fxfa/parser/cxfa_datamodel.cpp
index dc040c7..d334903 100644
--- a/xfa/fxfa/parser/cxfa_datamodel.cpp
+++ b/xfa/fxfa/parser/cxfa_datamodel.cpp
@@ -9,12 +9,6 @@
 #include "fxjs/xfa/cjx_model.h"
 #include "third_party/base/ptr_util.h"
 
-namespace {
-
-constexpr wchar_t kDataModelName[] = L"dataModel";
-
-}  // namespace
-
 CXFA_DataModel::CXFA_DataModel(CXFA_Document* doc, XFA_PacketType packet)
     : CXFA_Node(doc,
                 packet,
@@ -23,7 +17,6 @@
                 XFA_Element::DataModel,
                 nullptr,
                 nullptr,
-                kDataModelName,
                 pdfium::MakeUnique<CJX_Model>(this)) {}
 
-CXFA_DataModel::~CXFA_DataModel() {}
+CXFA_DataModel::~CXFA_DataModel() = default;
diff --git a/xfa/fxfa/parser/cxfa_datavalue.cpp b/xfa/fxfa/parser/cxfa_datavalue.cpp
index 5e18b44..53cb5db 100644
--- a/xfa/fxfa/parser/cxfa_datavalue.cpp
+++ b/xfa/fxfa/parser/cxfa_datavalue.cpp
@@ -20,8 +20,6 @@
     {XFA_Attribute::IsNull, XFA_AttributeType::Boolean, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kDataValueName[] = L"dataValue";
-
 }  // namespace
 
 CXFA_DataValue::CXFA_DataValue(CXFA_Document* doc, XFA_PacketType packet)
@@ -32,7 +30,6 @@
                 XFA_Element::DataValue,
                 nullptr,
                 kDataValueAttributeData,
-                kDataValueName,
                 pdfium::MakeUnique<CJX_DataValue>(this)) {}
 
-CXFA_DataValue::~CXFA_DataValue() {}
+CXFA_DataValue::~CXFA_DataValue() = default;
diff --git a/xfa/fxfa/parser/cxfa_date.cpp b/xfa/fxfa/parser/cxfa_date.cpp
index 90f20b5..6abff28 100644
--- a/xfa/fxfa/parser/cxfa_date.cpp
+++ b/xfa/fxfa/parser/cxfa_date.cpp
@@ -18,8 +18,6 @@
     {XFA_Attribute::Usehref, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kDateName[] = L"date";
-
 }  // namespace
 
 CXFA_Date::CXFA_Date(CXFA_Document* doc, XFA_PacketType packet)
@@ -30,7 +28,6 @@
                 XFA_Element::Date,
                 nullptr,
                 kDateAttributeData,
-                kDateName,
                 pdfium::MakeUnique<CJX_Date>(this)) {}
 
-CXFA_Date::~CXFA_Date() {}
+CXFA_Date::~CXFA_Date() = default;
diff --git a/xfa/fxfa/parser/cxfa_datepattern.cpp b/xfa/fxfa/parser/cxfa_datepattern.cpp
index 1fcfaf5..b4b8888 100644
--- a/xfa/fxfa/parser/cxfa_datepattern.cpp
+++ b/xfa/fxfa/parser/cxfa_datepattern.cpp
@@ -13,8 +13,6 @@
      (void*)XFA_AttributeValue::Med},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kDatePatternName[] = L"datePattern";
-
 }  // namespace
 
 CXFA_DatePattern::CXFA_DatePattern(CXFA_Document* doc, XFA_PacketType packet)
@@ -24,7 +22,6 @@
                 XFA_ObjectType::ContentNode,
                 XFA_Element::DatePattern,
                 nullptr,
-                kDatePatternAttributeData,
-                kDatePatternName) {}
+                kDatePatternAttributeData) {}
 
-CXFA_DatePattern::~CXFA_DatePattern() {}
+CXFA_DatePattern::~CXFA_DatePattern() = default;
diff --git a/xfa/fxfa/parser/cxfa_datepatterns.cpp b/xfa/fxfa/parser/cxfa_datepatterns.cpp
index 9678d1f..59c6b30 100644
--- a/xfa/fxfa/parser/cxfa_datepatterns.cpp
+++ b/xfa/fxfa/parser/cxfa_datepatterns.cpp
@@ -12,8 +12,6 @@
     {XFA_Element::DatePattern, 4, 0},
     {XFA_Element::Unknown, 0, 0}};
 
-constexpr wchar_t kDatePatternsName[] = L"datePatterns";
-
 }  // namespace
 
 CXFA_DatePatterns::CXFA_DatePatterns(CXFA_Document* doc, XFA_PacketType packet)
@@ -23,7 +21,6 @@
                 XFA_ObjectType::Node,
                 XFA_Element::DatePatterns,
                 kDatePatternsPropertyData,
-                nullptr,
-                kDatePatternsName) {}
+                nullptr) {}
 
-CXFA_DatePatterns::~CXFA_DatePatterns() {}
+CXFA_DatePatterns::~CXFA_DatePatterns() = default;
diff --git a/xfa/fxfa/parser/cxfa_datetime.cpp b/xfa/fxfa/parser/cxfa_datetime.cpp
index 564a57a..aa7dbf8 100644
--- a/xfa/fxfa/parser/cxfa_datetime.cpp
+++ b/xfa/fxfa/parser/cxfa_datetime.cpp
@@ -18,8 +18,6 @@
     {XFA_Attribute::Usehref, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kDateTimeName[] = L"dateTime";
-
 }  // namespace
 
 CXFA_DateTime::CXFA_DateTime(CXFA_Document* doc, XFA_PacketType packet)
@@ -30,7 +28,6 @@
                 XFA_Element::DateTime,
                 nullptr,
                 kDateTimeAttributeData,
-                kDateTimeName,
                 pdfium::MakeUnique<CJX_DateTime>(this)) {}
 
-CXFA_DateTime::~CXFA_DateTime() {}
+CXFA_DateTime::~CXFA_DateTime() = default;
diff --git a/xfa/fxfa/parser/cxfa_datetimeedit.cpp b/xfa/fxfa/parser/cxfa_datetimeedit.cpp
index 56aedc5..e257b9d 100644
--- a/xfa/fxfa/parser/cxfa_datetimeedit.cpp
+++ b/xfa/fxfa/parser/cxfa_datetimeedit.cpp
@@ -17,6 +17,7 @@
     {XFA_Element::Comb, 1, 0},
     {XFA_Element::Extras, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kDateTimeEditAttributeData[] = {
     {XFA_Attribute::Id, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Use, XFA_AttributeType::CData, nullptr},
@@ -27,8 +28,6 @@
      (void*)XFA_AttributeValue::Auto},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kDateTimeEditName[] = L"dateTimeEdit";
-
 }  // namespace
 
 CXFA_DateTimeEdit::CXFA_DateTimeEdit(CXFA_Document* doc, XFA_PacketType packet)
@@ -39,10 +38,9 @@
                 XFA_Element::DateTimeEdit,
                 kDateTimeEditPropertyData,
                 kDateTimeEditAttributeData,
-                kDateTimeEditName,
                 pdfium::MakeUnique<CJX_DateTimeEdit>(this)) {}
 
-CXFA_DateTimeEdit::~CXFA_DateTimeEdit() {}
+CXFA_DateTimeEdit::~CXFA_DateTimeEdit() = default;
 
 XFA_Element CXFA_DateTimeEdit::GetValueNodeType() const {
   return XFA_Element::DateTime;
diff --git a/xfa/fxfa/parser/cxfa_datetimesymbols.cpp b/xfa/fxfa/parser/cxfa_datetimesymbols.cpp
index 85d3f91..5946bbe 100644
--- a/xfa/fxfa/parser/cxfa_datetimesymbols.cpp
+++ b/xfa/fxfa/parser/cxfa_datetimesymbols.cpp
@@ -6,12 +6,6 @@
 
 #include "xfa/fxfa/parser/cxfa_datetimesymbols.h"
 
-namespace {
-
-constexpr wchar_t kDateTimeSymbolsName[] = L"dateTimeSymbols";
-
-}  // namespace
-
 CXFA_DateTimeSymbols::CXFA_DateTimeSymbols(CXFA_Document* doc,
                                            XFA_PacketType packet)
     : CXFA_Node(doc,
@@ -20,7 +14,6 @@
                 XFA_ObjectType::ContentNode,
                 XFA_Element::DateTimeSymbols,
                 nullptr,
-                nullptr,
-                kDateTimeSymbolsName) {}
+                nullptr) {}
 
-CXFA_DateTimeSymbols::~CXFA_DateTimeSymbols() {}
+CXFA_DateTimeSymbols::~CXFA_DateTimeSymbols() = default;
diff --git a/xfa/fxfa/parser/cxfa_day.cpp b/xfa/fxfa/parser/cxfa_day.cpp
index 0b5b3a1..e3cd3a1 100644
--- a/xfa/fxfa/parser/cxfa_day.cpp
+++ b/xfa/fxfa/parser/cxfa_day.cpp
@@ -6,12 +6,6 @@
 
 #include "xfa/fxfa/parser/cxfa_day.h"
 
-namespace {
-
-constexpr wchar_t kDayName[] = L"day";
-
-}  // namespace
-
 CXFA_Day::CXFA_Day(CXFA_Document* doc, XFA_PacketType packet)
     : CXFA_Node(doc,
                 packet,
@@ -19,7 +13,6 @@
                 XFA_ObjectType::ContentNode,
                 XFA_Element::Day,
                 nullptr,
-                nullptr,
-                kDayName) {}
+                nullptr) {}
 
-CXFA_Day::~CXFA_Day() {}
+CXFA_Day::~CXFA_Day() = default;
diff --git a/xfa/fxfa/parser/cxfa_daynames.cpp b/xfa/fxfa/parser/cxfa_daynames.cpp
index 0947fce..50daba9 100644
--- a/xfa/fxfa/parser/cxfa_daynames.cpp
+++ b/xfa/fxfa/parser/cxfa_daynames.cpp
@@ -11,12 +11,11 @@
 const CXFA_Node::PropertyData kDayNamesPropertyData[] = {
     {XFA_Element::Day, 7, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kDayNamesAttributeData[] = {
     {XFA_Attribute::Abbr, XFA_AttributeType::Boolean, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kDayNamesName[] = L"dayNames";
-
 }  // namespace
 
 CXFA_DayNames::CXFA_DayNames(CXFA_Document* doc, XFA_PacketType packet)
@@ -26,7 +25,6 @@
                 XFA_ObjectType::Node,
                 XFA_Element::DayNames,
                 kDayNamesPropertyData,
-                kDayNamesAttributeData,
-                kDayNamesName) {}
+                kDayNamesAttributeData) {}
 
-CXFA_DayNames::~CXFA_DayNames() {}
+CXFA_DayNames::~CXFA_DayNames() = default;
diff --git a/xfa/fxfa/parser/cxfa_debug.cpp b/xfa/fxfa/parser/cxfa_debug.cpp
index 346cd11..1b2fe14 100644
--- a/xfa/fxfa/parser/cxfa_debug.cpp
+++ b/xfa/fxfa/parser/cxfa_debug.cpp
@@ -11,13 +11,12 @@
 const CXFA_Node::PropertyData kDebugPropertyData[] = {
     {XFA_Element::Uri, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kDebugAttributeData[] = {
     {XFA_Attribute::Desc, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kDebugName[] = L"debug";
-
 }  // namespace
 
 CXFA_Debug::CXFA_Debug(CXFA_Document* doc, XFA_PacketType packet)
@@ -27,7 +26,6 @@
                 XFA_ObjectType::Node,
                 XFA_Element::Debug,
                 kDebugPropertyData,
-                kDebugAttributeData,
-                kDebugName) {}
+                kDebugAttributeData) {}
 
-CXFA_Debug::~CXFA_Debug() {}
+CXFA_Debug::~CXFA_Debug() = default;
diff --git a/xfa/fxfa/parser/cxfa_decimal.cpp b/xfa/fxfa/parser/cxfa_decimal.cpp
index 6941d1c..6f96bad 100644
--- a/xfa/fxfa/parser/cxfa_decimal.cpp
+++ b/xfa/fxfa/parser/cxfa_decimal.cpp
@@ -20,8 +20,6 @@
     {XFA_Attribute::LeadDigits, XFA_AttributeType::Integer, (void*)-1},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kDecimalName[] = L"decimal";
-
 }  // namespace
 
 CXFA_Decimal::CXFA_Decimal(CXFA_Document* doc, XFA_PacketType packet)
@@ -32,7 +30,6 @@
                 XFA_Element::Decimal,
                 nullptr,
                 kDecimalAttributeData,
-                kDecimalName,
                 pdfium::MakeUnique<CJX_Decimal>(this)) {}
 
-CXFA_Decimal::~CXFA_Decimal() {}
+CXFA_Decimal::~CXFA_Decimal() = default;
diff --git a/xfa/fxfa/parser/cxfa_defaulttypeface.cpp b/xfa/fxfa/parser/cxfa_defaulttypeface.cpp
index c0a8358..64e3651 100644
--- a/xfa/fxfa/parser/cxfa_defaulttypeface.cpp
+++ b/xfa/fxfa/parser/cxfa_defaulttypeface.cpp
@@ -15,8 +15,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kDefaultTypefaceName[] = L"defaultTypeface";
-
 }  // namespace
 
 CXFA_DefaultTypeface::CXFA_DefaultTypeface(CXFA_Document* doc,
@@ -27,7 +25,6 @@
                 XFA_ObjectType::NodeV,
                 XFA_Element::DefaultTypeface,
                 nullptr,
-                kDefaultTypefaceAttributeData,
-                kDefaultTypefaceName) {}
+                kDefaultTypefaceAttributeData) {}
 
-CXFA_DefaultTypeface::~CXFA_DefaultTypeface() {}
+CXFA_DefaultTypeface::~CXFA_DefaultTypeface() = default;
diff --git a/xfa/fxfa/parser/cxfa_defaultui.cpp b/xfa/fxfa/parser/cxfa_defaultui.cpp
index c619d05..e132bee 100644
--- a/xfa/fxfa/parser/cxfa_defaultui.cpp
+++ b/xfa/fxfa/parser/cxfa_defaultui.cpp
@@ -13,14 +13,13 @@
 const CXFA_Node::PropertyData kDefaultUiPropertyData[] = {
     {XFA_Element::Extras, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kDefaultUiAttributeData[] = {
     {XFA_Attribute::Id, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Use, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Usehref, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kDefaultUiName[] = L"defaultUi";
-
 }  // namespace
 
 CXFA_DefaultUi::CXFA_DefaultUi(CXFA_Document* doc, XFA_PacketType packet)
@@ -30,10 +29,9 @@
                 XFA_ObjectType::Node,
                 XFA_Element::DefaultUi,
                 kDefaultUiPropertyData,
-                kDefaultUiAttributeData,
-                kDefaultUiName) {}
+                kDefaultUiAttributeData) {}
 
-CXFA_DefaultUi::~CXFA_DefaultUi() {}
+CXFA_DefaultUi::~CXFA_DefaultUi() = default;
 
 XFA_FFWidgetType CXFA_DefaultUi::GetDefaultFFWidgetType() const {
   return XFA_FFWidgetType::kTextEdit;
diff --git a/xfa/fxfa/parser/cxfa_delete.cpp b/xfa/fxfa/parser/cxfa_delete.cpp
index cd377e8..36c227d 100644
--- a/xfa/fxfa/parser/cxfa_delete.cpp
+++ b/xfa/fxfa/parser/cxfa_delete.cpp
@@ -18,8 +18,6 @@
     {XFA_Attribute::Usehref, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kDeleteName[] = L"delete";
-
 }  // namespace
 
 CXFA_Delete::CXFA_Delete(CXFA_Document* doc, XFA_PacketType packet)
@@ -30,7 +28,6 @@
                 XFA_Element::Delete,
                 nullptr,
                 kDeleteAttributeData,
-                kDeleteName,
                 pdfium::MakeUnique<CJX_Delete>(this)) {}
 
-CXFA_Delete::~CXFA_Delete() {}
+CXFA_Delete::~CXFA_Delete() = default;
diff --git a/xfa/fxfa/parser/cxfa_delta.cpp b/xfa/fxfa/parser/cxfa_delta.cpp
index e50fd7f..24e4f42 100644
--- a/xfa/fxfa/parser/cxfa_delta.cpp
+++ b/xfa/fxfa/parser/cxfa_delta.cpp
@@ -9,12 +9,6 @@
 #include "fxjs/xfa/cjx_delta.h"
 #include "third_party/base/ptr_util.h"
 
-namespace {
-
-constexpr wchar_t kDeltaName[] = L"delta";
-
-}  // namespace
-
 CXFA_Delta::CXFA_Delta(CXFA_Document* doc, XFA_PacketType packet)
     : CXFA_Node(doc,
                 packet,
@@ -23,7 +17,6 @@
                 XFA_Element::Delta,
                 nullptr,
                 nullptr,
-                kDeltaName,
                 pdfium::MakeUnique<CJX_Delta>(this)) {}
 
-CXFA_Delta::~CXFA_Delta() {}
+CXFA_Delta::~CXFA_Delta() = default;
diff --git a/xfa/fxfa/parser/cxfa_desc.cpp b/xfa/fxfa/parser/cxfa_desc.cpp
index 954da53..d509bfa 100644
--- a/xfa/fxfa/parser/cxfa_desc.cpp
+++ b/xfa/fxfa/parser/cxfa_desc.cpp
@@ -18,14 +18,13 @@
     {XFA_Element::Integer, 1, 0},  {XFA_Element::ExData, 1, 0},
     {XFA_Element::Date, 1, 0},     {XFA_Element::Float, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kDescAttributeData[] = {
     {XFA_Attribute::Id, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Use, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Usehref, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kDescName[] = L"desc";
-
 }  // namespace
 
 CXFA_Desc::CXFA_Desc(CXFA_Document* doc, XFA_PacketType packet)
@@ -36,7 +35,6 @@
                 XFA_Element::Desc,
                 kDescPropertyData,
                 kDescAttributeData,
-                kDescName,
                 pdfium::MakeUnique<CJX_Desc>(this)) {}
 
-CXFA_Desc::~CXFA_Desc() {}
+CXFA_Desc::~CXFA_Desc() = default;
diff --git a/xfa/fxfa/parser/cxfa_destination.cpp b/xfa/fxfa/parser/cxfa_destination.cpp
index 291ac5e..aeffa02 100644
--- a/xfa/fxfa/parser/cxfa_destination.cpp
+++ b/xfa/fxfa/parser/cxfa_destination.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kDestinationName[] = L"destination";
-
 }  // namespace
 
 CXFA_Destination::CXFA_Destination(CXFA_Document* doc, XFA_PacketType packet)
@@ -24,7 +22,6 @@
                 XFA_ObjectType::ContentNode,
                 XFA_Element::Destination,
                 nullptr,
-                kDestinationAttributeData,
-                kDestinationName) {}
+                kDestinationAttributeData) {}
 
-CXFA_Destination::~CXFA_Destination() {}
+CXFA_Destination::~CXFA_Destination() = default;
diff --git a/xfa/fxfa/parser/cxfa_digestmethod.cpp b/xfa/fxfa/parser/cxfa_digestmethod.cpp
index 9c78635..ac4ed84 100644
--- a/xfa/fxfa/parser/cxfa_digestmethod.cpp
+++ b/xfa/fxfa/parser/cxfa_digestmethod.cpp
@@ -17,8 +17,6 @@
     {XFA_Attribute::Usehref, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kDigestMethodName[] = L"digestMethod";
-
 }  // namespace
 
 CXFA_DigestMethod::CXFA_DigestMethod(CXFA_Document* doc, XFA_PacketType packet)
@@ -29,7 +27,6 @@
                 XFA_Element::DigestMethod,
                 nullptr,
                 kDigestMethodAttributeData,
-                kDigestMethodName,
                 pdfium::MakeUnique<CJX_DigestMethod>(this)) {}
 
-CXFA_DigestMethod::~CXFA_DigestMethod() {}
+CXFA_DigestMethod::~CXFA_DigestMethod() = default;
diff --git a/xfa/fxfa/parser/cxfa_digestmethods.cpp b/xfa/fxfa/parser/cxfa_digestmethods.cpp
index 62c3422..0ee6fce 100644
--- a/xfa/fxfa/parser/cxfa_digestmethods.cpp
+++ b/xfa/fxfa/parser/cxfa_digestmethods.cpp
@@ -19,8 +19,6 @@
     {XFA_Attribute::Usehref, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kDigestMethodsName[] = L"digestMethods";
-
 }  // namespace
 
 CXFA_DigestMethods::CXFA_DigestMethods(CXFA_Document* doc,
@@ -32,7 +30,6 @@
                 XFA_Element::DigestMethods,
                 nullptr,
                 kDigestMethodsAttributeData,
-                kDigestMethodsName,
                 pdfium::MakeUnique<CJX_DigestMethods>(this)) {}
 
-CXFA_DigestMethods::~CXFA_DigestMethods() {}
+CXFA_DigestMethods::~CXFA_DigestMethods() = default;
diff --git a/xfa/fxfa/parser/cxfa_documentassembly.cpp b/xfa/fxfa/parser/cxfa_documentassembly.cpp
index f3cbc34..ee83ef4 100644
--- a/xfa/fxfa/parser/cxfa_documentassembly.cpp
+++ b/xfa/fxfa/parser/cxfa_documentassembly.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kDocumentAssemblyName[] = L"documentAssembly";
-
 }  // namespace
 
 CXFA_DocumentAssembly::CXFA_DocumentAssembly(CXFA_Document* doc,
@@ -25,7 +23,6 @@
                 XFA_ObjectType::ContentNode,
                 XFA_Element::DocumentAssembly,
                 nullptr,
-                kDocumentAssemblyAttributeData,
-                kDocumentAssemblyName) {}
+                kDocumentAssemblyAttributeData) {}
 
-CXFA_DocumentAssembly::~CXFA_DocumentAssembly() {}
+CXFA_DocumentAssembly::~CXFA_DocumentAssembly() = default;
diff --git a/xfa/fxfa/parser/cxfa_draw.cpp b/xfa/fxfa/parser/cxfa_draw.cpp
index ce15428..d853651 100644
--- a/xfa/fxfa/parser/cxfa_draw.cpp
+++ b/xfa/fxfa/parser/cxfa_draw.cpp
@@ -19,6 +19,7 @@
     {XFA_Element::Desc, 1, 0},   {XFA_Element::Font, 1, 0},
     {XFA_Element::Value, 1, 0},  {XFA_Element::Extras, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kDrawAttributeData[] = {
     {XFA_Attribute::H, XFA_AttributeType::Measure, (void*)L"0in"},
     {XFA_Attribute::W, XFA_AttributeType::Measure, (void*)L"0in"},
@@ -46,8 +47,6 @@
      (void*)XFA_AttributeValue::TopLeft},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kDrawName[] = L"draw";
-
 }  // namespace
 
 CXFA_Draw::CXFA_Draw(CXFA_Document* doc, XFA_PacketType packet)
@@ -58,7 +57,6 @@
                 XFA_Element::Draw,
                 kDrawPropertyData,
                 kDrawAttributeData,
-                kDrawName,
                 pdfium::MakeUnique<CJX_Draw>(this)) {}
 
-CXFA_Draw::~CXFA_Draw() {}
+CXFA_Draw::~CXFA_Draw() = default;
diff --git a/xfa/fxfa/parser/cxfa_driver.cpp b/xfa/fxfa/parser/cxfa_driver.cpp
index 3a704f3..f49fa14 100644
--- a/xfa/fxfa/parser/cxfa_driver.cpp
+++ b/xfa/fxfa/parser/cxfa_driver.cpp
@@ -12,14 +12,13 @@
     {XFA_Element::FontInfo, 1, 0},
     {XFA_Element::Xdc, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kDriverAttributeData[] = {
     {XFA_Attribute::Name, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Desc, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kDriverName[] = L"driver";
-
 }  // namespace
 
 CXFA_Driver::CXFA_Driver(CXFA_Document* doc, XFA_PacketType packet)
@@ -29,7 +28,6 @@
                 XFA_ObjectType::Node,
                 XFA_Element::Driver,
                 kDriverPropertyData,
-                kDriverAttributeData,
-                kDriverName) {}
+                kDriverAttributeData) {}
 
-CXFA_Driver::~CXFA_Driver() {}
+CXFA_Driver::~CXFA_Driver() = default;
diff --git a/xfa/fxfa/parser/cxfa_dsigdata.cpp b/xfa/fxfa/parser/cxfa_dsigdata.cpp
index b9a6ee9..3411d32 100644
--- a/xfa/fxfa/parser/cxfa_dsigdata.cpp
+++ b/xfa/fxfa/parser/cxfa_dsigdata.cpp
@@ -12,8 +12,6 @@
     {XFA_Attribute::Value, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kDSigDataName[] = L"dSigData";
-
 }  // namespace
 
 CXFA_DSigData::CXFA_DSigData(CXFA_Document* doc, XFA_PacketType packet)
@@ -23,7 +21,6 @@
                 XFA_ObjectType::Node,
                 XFA_Element::DSigData,
                 nullptr,
-                kDSigDataAttributeData,
-                kDSigDataName) {}
+                kDSigDataAttributeData) {}
 
-CXFA_DSigData::~CXFA_DSigData() {}
+CXFA_DSigData::~CXFA_DSigData() = default;
diff --git a/xfa/fxfa/parser/cxfa_duplexoption.cpp b/xfa/fxfa/parser/cxfa_duplexoption.cpp
index baf07b9..2a3102b 100644
--- a/xfa/fxfa/parser/cxfa_duplexoption.cpp
+++ b/xfa/fxfa/parser/cxfa_duplexoption.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kDuplexOptionName[] = L"duplexOption";
-
 }  // namespace
 
 CXFA_DuplexOption::CXFA_DuplexOption(CXFA_Document* doc, XFA_PacketType packet)
@@ -24,7 +22,6 @@
                 XFA_ObjectType::ContentNode,
                 XFA_Element::DuplexOption,
                 nullptr,
-                kDuplexOptionAttributeData,
-                kDuplexOptionName) {}
+                kDuplexOptionAttributeData) {}
 
-CXFA_DuplexOption::~CXFA_DuplexOption() {}
+CXFA_DuplexOption::~CXFA_DuplexOption() = default;
diff --git a/xfa/fxfa/parser/cxfa_dynamicrender.cpp b/xfa/fxfa/parser/cxfa_dynamicrender.cpp
index 7120300..6de711a 100644
--- a/xfa/fxfa/parser/cxfa_dynamicrender.cpp
+++ b/xfa/fxfa/parser/cxfa_dynamicrender.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kDynamicRenderName[] = L"dynamicRender";
-
 }  // namespace
 
 CXFA_DynamicRender::CXFA_DynamicRender(CXFA_Document* doc,
@@ -25,7 +23,6 @@
                 XFA_ObjectType::ContentNode,
                 XFA_Element::DynamicRender,
                 nullptr,
-                kDynamicRenderAttributeData,
-                kDynamicRenderName) {}
+                kDynamicRenderAttributeData) {}
 
-CXFA_DynamicRender::~CXFA_DynamicRender() {}
+CXFA_DynamicRender::~CXFA_DynamicRender() = default;
diff --git a/xfa/fxfa/parser/cxfa_edge.cpp b/xfa/fxfa/parser/cxfa_edge.cpp
index 9671dc0..6afb6c1 100644
--- a/xfa/fxfa/parser/cxfa_edge.cpp
+++ b/xfa/fxfa/parser/cxfa_edge.cpp
@@ -15,6 +15,7 @@
     {XFA_Element::Color, 1, 0},
     {XFA_Element::Extras, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kEdgeAttributeData[] = {
     {XFA_Attribute::Id, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Cap, XFA_AttributeType::Enum,
@@ -28,8 +29,6 @@
     {XFA_Attribute::Usehref, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kEdgeName[] = L"edge";
-
 }  // namespace
 
 CXFA_Edge::CXFA_Edge(CXFA_Document* doc, XFA_PacketType packet)
@@ -40,7 +39,6 @@
                   XFA_Element::Edge,
                   kEdgePropertyData,
                   kEdgeAttributeData,
-                  kEdgeName,
                   pdfium::MakeUnique<CJX_Edge>(this)) {}
 
-CXFA_Edge::~CXFA_Edge() {}
+CXFA_Edge::~CXFA_Edge() = default;
diff --git a/xfa/fxfa/parser/cxfa_effectiveinputpolicy.cpp b/xfa/fxfa/parser/cxfa_effectiveinputpolicy.cpp
index 485fbdf..db48e89 100644
--- a/xfa/fxfa/parser/cxfa_effectiveinputpolicy.cpp
+++ b/xfa/fxfa/parser/cxfa_effectiveinputpolicy.cpp
@@ -15,8 +15,6 @@
     {XFA_Attribute::Usehref, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kEffectiveInputPolicyName[] = L"effectiveInputPolicy";
-
 }  // namespace
 
 CXFA_EffectiveInputPolicy::CXFA_EffectiveInputPolicy(CXFA_Document* doc,
@@ -27,7 +25,6 @@
                 XFA_ObjectType::Node,
                 XFA_Element::EffectiveInputPolicy,
                 nullptr,
-                kEffectiveInputPolicyAttributeData,
-                kEffectiveInputPolicyName) {}
+                kEffectiveInputPolicyAttributeData) {}
 
-CXFA_EffectiveInputPolicy::~CXFA_EffectiveInputPolicy() {}
+CXFA_EffectiveInputPolicy::~CXFA_EffectiveInputPolicy() = default;
diff --git a/xfa/fxfa/parser/cxfa_effectiveoutputpolicy.cpp b/xfa/fxfa/parser/cxfa_effectiveoutputpolicy.cpp
index 5a657e3..ae16091 100644
--- a/xfa/fxfa/parser/cxfa_effectiveoutputpolicy.cpp
+++ b/xfa/fxfa/parser/cxfa_effectiveoutputpolicy.cpp
@@ -15,8 +15,6 @@
     {XFA_Attribute::Usehref, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kEffectiveOutputPolicyName[] = L"effectiveOutputPolicy";
-
 }  // namespace
 
 CXFA_EffectiveOutputPolicy::CXFA_EffectiveOutputPolicy(CXFA_Document* doc,
@@ -27,7 +25,6 @@
                 XFA_ObjectType::Node,
                 XFA_Element::EffectiveOutputPolicy,
                 nullptr,
-                kEffectiveOutputPolicyAttributeData,
-                kEffectiveOutputPolicyName) {}
+                kEffectiveOutputPolicyAttributeData) {}
 
-CXFA_EffectiveOutputPolicy::~CXFA_EffectiveOutputPolicy() {}
+CXFA_EffectiveOutputPolicy::~CXFA_EffectiveOutputPolicy() = default;
diff --git a/xfa/fxfa/parser/cxfa_embed.cpp b/xfa/fxfa/parser/cxfa_embed.cpp
index 2039dad..f456c72 100644
--- a/xfa/fxfa/parser/cxfa_embed.cpp
+++ b/xfa/fxfa/parser/cxfa_embed.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kEmbedName[] = L"embed";
-
 }  // namespace
 
 CXFA_Embed::CXFA_Embed(CXFA_Document* doc, XFA_PacketType packet)
@@ -24,7 +22,6 @@
                 XFA_ObjectType::ContentNode,
                 XFA_Element::Embed,
                 nullptr,
-                kEmbedAttributeData,
-                kEmbedName) {}
+                kEmbedAttributeData) {}
 
-CXFA_Embed::~CXFA_Embed() {}
+CXFA_Embed::~CXFA_Embed() = default;
diff --git a/xfa/fxfa/parser/cxfa_encoding.cpp b/xfa/fxfa/parser/cxfa_encoding.cpp
index 90c6a30..818e654 100644
--- a/xfa/fxfa/parser/cxfa_encoding.cpp
+++ b/xfa/fxfa/parser/cxfa_encoding.cpp
@@ -17,8 +17,6 @@
     {XFA_Attribute::Usehref, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kEncodingName[] = L"encoding";
-
 }  // namespace
 
 CXFA_Encoding::CXFA_Encoding(CXFA_Document* doc, XFA_PacketType packet)
@@ -29,7 +27,6 @@
                 XFA_Element::Encoding,
                 nullptr,
                 kEncodingAttributeData,
-                kEncodingName,
                 pdfium::MakeUnique<CJX_Encoding>(this)) {}
 
-CXFA_Encoding::~CXFA_Encoding() {}
+CXFA_Encoding::~CXFA_Encoding() = default;
diff --git a/xfa/fxfa/parser/cxfa_encodings.cpp b/xfa/fxfa/parser/cxfa_encodings.cpp
index 6b57803..b40c9b4 100644
--- a/xfa/fxfa/parser/cxfa_encodings.cpp
+++ b/xfa/fxfa/parser/cxfa_encodings.cpp
@@ -19,8 +19,6 @@
     {XFA_Attribute::Usehref, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kEncodingsName[] = L"encodings";
-
 }  // namespace
 
 CXFA_Encodings::CXFA_Encodings(CXFA_Document* doc, XFA_PacketType packet)
@@ -31,7 +29,6 @@
                 XFA_Element::Encodings,
                 nullptr,
                 kEncodingsAttributeData,
-                kEncodingsName,
                 pdfium::MakeUnique<CJX_Encodings>(this)) {}
 
-CXFA_Encodings::~CXFA_Encodings() {}
+CXFA_Encodings::~CXFA_Encodings() = default;
diff --git a/xfa/fxfa/parser/cxfa_encrypt.cpp b/xfa/fxfa/parser/cxfa_encrypt.cpp
index 3c89341..9d0739c 100644
--- a/xfa/fxfa/parser/cxfa_encrypt.cpp
+++ b/xfa/fxfa/parser/cxfa_encrypt.cpp
@@ -14,6 +14,7 @@
 const CXFA_Node::PropertyData kEncryptPropertyData[] = {
     {XFA_Element::Certificate, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kEncryptAttributeData[] = {
     {XFA_Attribute::Id, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Use, XFA_AttributeType::CData, nullptr},
@@ -22,8 +23,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kEncryptName[] = L"encrypt";
-
 }  // namespace
 
 CXFA_Encrypt::CXFA_Encrypt(CXFA_Document* doc, XFA_PacketType packet)
@@ -35,7 +34,6 @@
           XFA_Element::Encrypt,
           kEncryptPropertyData,
           kEncryptAttributeData,
-          kEncryptName,
           pdfium::MakeUnique<CJX_Encrypt>(this)) {}
 
-CXFA_Encrypt::~CXFA_Encrypt() {}
+CXFA_Encrypt::~CXFA_Encrypt() = default;
diff --git a/xfa/fxfa/parser/cxfa_encryption.cpp b/xfa/fxfa/parser/cxfa_encryption.cpp
index 863f720..9b9c6d8 100644
--- a/xfa/fxfa/parser/cxfa_encryption.cpp
+++ b/xfa/fxfa/parser/cxfa_encryption.cpp
@@ -13,13 +13,12 @@
     {XFA_Element::Encrypt, 1, 0},
     {XFA_Element::Permissions, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kEncryptionAttributeData[] = {
     {XFA_Attribute::Desc, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kEncryptionName[] = L"encryption";
-
 }  // namespace
 
 CXFA_Encryption::CXFA_Encryption(CXFA_Document* doc, XFA_PacketType packet)
@@ -29,7 +28,6 @@
                 XFA_ObjectType::Node,
                 XFA_Element::Encryption,
                 kEncryptionPropertyData,
-                kEncryptionAttributeData,
-                kEncryptionName) {}
+                kEncryptionAttributeData) {}
 
-CXFA_Encryption::~CXFA_Encryption() {}
+CXFA_Encryption::~CXFA_Encryption() = default;
diff --git a/xfa/fxfa/parser/cxfa_encryptionlevel.cpp b/xfa/fxfa/parser/cxfa_encryptionlevel.cpp
index 3c03372..b0d765b 100644
--- a/xfa/fxfa/parser/cxfa_encryptionlevel.cpp
+++ b/xfa/fxfa/parser/cxfa_encryptionlevel.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kEncryptionLevelName[] = L"encryptionLevel";
-
 }  // namespace
 
 CXFA_EncryptionLevel::CXFA_EncryptionLevel(CXFA_Document* doc,
@@ -25,7 +23,6 @@
                 XFA_ObjectType::ContentNode,
                 XFA_Element::EncryptionLevel,
                 nullptr,
-                kEncryptionLevelAttributeData,
-                kEncryptionLevelName) {}
+                kEncryptionLevelAttributeData) {}
 
-CXFA_EncryptionLevel::~CXFA_EncryptionLevel() {}
+CXFA_EncryptionLevel::~CXFA_EncryptionLevel() = default;
diff --git a/xfa/fxfa/parser/cxfa_encryptionmethod.cpp b/xfa/fxfa/parser/cxfa_encryptionmethod.cpp
index 748f0a3..19a723d 100644
--- a/xfa/fxfa/parser/cxfa_encryptionmethod.cpp
+++ b/xfa/fxfa/parser/cxfa_encryptionmethod.cpp
@@ -14,8 +14,6 @@
     {XFA_Attribute::Usehref, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kEncryptionMethodName[] = L"encryptionMethod";
-
 }  // namespace
 
 CXFA_EncryptionMethod::CXFA_EncryptionMethod(CXFA_Document* doc,
@@ -26,7 +24,6 @@
                 XFA_ObjectType::NodeC,
                 XFA_Element::EncryptionMethod,
                 nullptr,
-                kEncryptionMethodAttributeData,
-                kEncryptionMethodName) {}
+                kEncryptionMethodAttributeData) {}
 
-CXFA_EncryptionMethod::~CXFA_EncryptionMethod() {}
+CXFA_EncryptionMethod::~CXFA_EncryptionMethod() = default;
diff --git a/xfa/fxfa/parser/cxfa_encryptionmethods.cpp b/xfa/fxfa/parser/cxfa_encryptionmethods.cpp
index ff87597..4c53c6c 100644
--- a/xfa/fxfa/parser/cxfa_encryptionmethods.cpp
+++ b/xfa/fxfa/parser/cxfa_encryptionmethods.cpp
@@ -16,8 +16,6 @@
     {XFA_Attribute::Usehref, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kEncryptionMethodsName[] = L"encryptionMethods";
-
 }  // namespace
 
 CXFA_EncryptionMethods::CXFA_EncryptionMethods(CXFA_Document* doc,
@@ -28,7 +26,6 @@
                 XFA_ObjectType::Node,
                 XFA_Element::EncryptionMethods,
                 nullptr,
-                kEncryptionMethodsAttributeData,
-                kEncryptionMethodsName) {}
+                kEncryptionMethodsAttributeData) {}
 
-CXFA_EncryptionMethods::~CXFA_EncryptionMethods() {}
+CXFA_EncryptionMethods::~CXFA_EncryptionMethods() = default;
diff --git a/xfa/fxfa/parser/cxfa_enforce.cpp b/xfa/fxfa/parser/cxfa_enforce.cpp
index 5d67999..c7dc9fb 100644
--- a/xfa/fxfa/parser/cxfa_enforce.cpp
+++ b/xfa/fxfa/parser/cxfa_enforce.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kEnforceName[] = L"enforce";
-
 }  // namespace
 
 CXFA_Enforce::CXFA_Enforce(CXFA_Document* doc, XFA_PacketType packet)
@@ -24,7 +22,6 @@
                 XFA_ObjectType::ContentNode,
                 XFA_Element::Enforce,
                 nullptr,
-                kEnforceAttributeData,
-                kEnforceName) {}
+                kEnforceAttributeData) {}
 
-CXFA_Enforce::~CXFA_Enforce() {}
+CXFA_Enforce::~CXFA_Enforce() = default;
diff --git a/xfa/fxfa/parser/cxfa_equate.cpp b/xfa/fxfa/parser/cxfa_equate.cpp
index 12070f7..9b27349 100644
--- a/xfa/fxfa/parser/cxfa_equate.cpp
+++ b/xfa/fxfa/parser/cxfa_equate.cpp
@@ -16,8 +16,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kEquateName[] = L"equate";
-
 }  // namespace
 
 CXFA_Equate::CXFA_Equate(CXFA_Document* doc, XFA_PacketType packet)
@@ -27,7 +25,6 @@
                 XFA_ObjectType::NodeV,
                 XFA_Element::Equate,
                 nullptr,
-                kEquateAttributeData,
-                kEquateName) {}
+                kEquateAttributeData) {}
 
-CXFA_Equate::~CXFA_Equate() {}
+CXFA_Equate::~CXFA_Equate() = default;
diff --git a/xfa/fxfa/parser/cxfa_equaterange.cpp b/xfa/fxfa/parser/cxfa_equaterange.cpp
index 7871ea8..f1e6703 100644
--- a/xfa/fxfa/parser/cxfa_equaterange.cpp
+++ b/xfa/fxfa/parser/cxfa_equaterange.cpp
@@ -16,8 +16,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kEquateRangeName[] = L"equateRange";
-
 }  // namespace
 
 CXFA_EquateRange::CXFA_EquateRange(CXFA_Document* doc, XFA_PacketType packet)
@@ -27,7 +25,6 @@
                 XFA_ObjectType::NodeV,
                 XFA_Element::EquateRange,
                 nullptr,
-                kEquateRangeAttributeData,
-                kEquateRangeName) {}
+                kEquateRangeAttributeData) {}
 
-CXFA_EquateRange::~CXFA_EquateRange() {}
+CXFA_EquateRange::~CXFA_EquateRange() = default;
diff --git a/xfa/fxfa/parser/cxfa_era.cpp b/xfa/fxfa/parser/cxfa_era.cpp
index 3fe3aa4..b419644 100644
--- a/xfa/fxfa/parser/cxfa_era.cpp
+++ b/xfa/fxfa/parser/cxfa_era.cpp
@@ -6,12 +6,6 @@
 
 #include "xfa/fxfa/parser/cxfa_era.h"
 
-namespace {
-
-constexpr wchar_t kEraName[] = L"era";
-
-}  // namespace
-
 CXFA_Era::CXFA_Era(CXFA_Document* doc, XFA_PacketType packet)
     : CXFA_Node(doc,
                 packet,
@@ -19,7 +13,6 @@
                 XFA_ObjectType::ContentNode,
                 XFA_Element::Era,
                 nullptr,
-                nullptr,
-                kEraName) {}
+                nullptr) {}
 
-CXFA_Era::~CXFA_Era() {}
+CXFA_Era::~CXFA_Era() = default;
diff --git a/xfa/fxfa/parser/cxfa_eranames.cpp b/xfa/fxfa/parser/cxfa_eranames.cpp
index 75ea37b..083dc2f 100644
--- a/xfa/fxfa/parser/cxfa_eranames.cpp
+++ b/xfa/fxfa/parser/cxfa_eranames.cpp
@@ -12,8 +12,6 @@
     {XFA_Element::Era, 2, 0},
     {XFA_Element::Unknown, 0, 0}};
 
-constexpr wchar_t kEraNamesName[] = L"eraNames";
-
 }  // namespace
 
 CXFA_EraNames::CXFA_EraNames(CXFA_Document* doc, XFA_PacketType packet)
@@ -23,7 +21,6 @@
                 XFA_ObjectType::Node,
                 XFA_Element::EraNames,
                 kEraNamesPropertyData,
-                nullptr,
-                kEraNamesName) {}
+                nullptr) {}
 
-CXFA_EraNames::~CXFA_EraNames() {}
+CXFA_EraNames::~CXFA_EraNames() = default;
diff --git a/xfa/fxfa/parser/cxfa_event.cpp b/xfa/fxfa/parser/cxfa_event.cpp
index bb963e5..5abf611 100644
--- a/xfa/fxfa/parser/cxfa_event.cpp
+++ b/xfa/fxfa/parser/cxfa_event.cpp
@@ -20,6 +20,7 @@
     {XFA_Element::Extras, 1, 0},
     {XFA_Element::Submit, 1, XFA_PROPERTYFLAG_OneOf},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kEventAttributeData[] = {
     {XFA_Attribute::Id, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Name, XFA_AttributeType::CData, nullptr},
@@ -32,8 +33,6 @@
      (void*)XFA_AttributeValue::Click},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kEventName[] = L"event";
-
 }  // namespace
 
 CXFA_Event::CXFA_Event(CXFA_Document* doc, XFA_PacketType packet)
@@ -44,10 +43,9 @@
                 XFA_Element::Event,
                 kEventPropertyData,
                 kEventAttributeData,
-                kEventName,
                 pdfium::MakeUnique<CJX_Event>(this)) {}
 
-CXFA_Event::~CXFA_Event() {}
+CXFA_Event::~CXFA_Event() = default;
 
 XFA_AttributeValue CXFA_Event::GetActivity() {
   return JSObject()->GetEnum(XFA_Attribute::Activity);
diff --git a/xfa/fxfa/parser/cxfa_exclgroup.cpp b/xfa/fxfa/parser/cxfa_exclgroup.cpp
index 71c0ce5..be2e21d 100644
--- a/xfa/fxfa/parser/cxfa_exclgroup.cpp
+++ b/xfa/fxfa/parser/cxfa_exclgroup.cpp
@@ -18,6 +18,7 @@
     {XFA_Element::Caption, 1, 0},   {XFA_Element::Bind, 1, 0},
     {XFA_Element::Desc, 1, 0},      {XFA_Element::Calculate, 1, 0},
     {XFA_Element::Extras, 1, 0},    {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kExclGroupAttributeData[] = {
     {XFA_Attribute::H, XFA_AttributeType::Measure, (void*)L"0in"},
     {XFA_Attribute::W, XFA_AttributeType::Measure, (void*)L"0in"},
@@ -48,8 +49,6 @@
     {XFA_Attribute::AccessKey, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kExclGroupName[] = L"exclGroup";
-
 }  // namespace
 
 CXFA_ExclGroup::CXFA_ExclGroup(CXFA_Document* doc, XFA_PacketType packet)
@@ -60,7 +59,6 @@
                 XFA_Element::ExclGroup,
                 kExclGroupPropertyData,
                 kExclGroupAttributeData,
-                kExclGroupName,
                 pdfium::MakeUnique<CJX_ExclGroup>(this)) {}
 
-CXFA_ExclGroup::~CXFA_ExclGroup() {}
+CXFA_ExclGroup::~CXFA_ExclGroup() = default;
diff --git a/xfa/fxfa/parser/cxfa_exclude.cpp b/xfa/fxfa/parser/cxfa_exclude.cpp
index 23b30b4..3a8b2e1 100644
--- a/xfa/fxfa/parser/cxfa_exclude.cpp
+++ b/xfa/fxfa/parser/cxfa_exclude.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kExcludeName[] = L"exclude";
-
 }  // namespace
 
 CXFA_Exclude::CXFA_Exclude(CXFA_Document* doc, XFA_PacketType packet)
@@ -24,7 +22,6 @@
                 XFA_ObjectType::ContentNode,
                 XFA_Element::Exclude,
                 nullptr,
-                kExcludeAttributeData,
-                kExcludeName) {}
+                kExcludeAttributeData) {}
 
-CXFA_Exclude::~CXFA_Exclude() {}
+CXFA_Exclude::~CXFA_Exclude() = default;
diff --git a/xfa/fxfa/parser/cxfa_excludens.cpp b/xfa/fxfa/parser/cxfa_excludens.cpp
index 2eacc76..b5a9031 100644
--- a/xfa/fxfa/parser/cxfa_excludens.cpp
+++ b/xfa/fxfa/parser/cxfa_excludens.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kExcludeNSName[] = L"excludeNS";
-
 }  // namespace
 
 CXFA_ExcludeNS::CXFA_ExcludeNS(CXFA_Document* doc, XFA_PacketType packet)
@@ -24,7 +22,6 @@
                 XFA_ObjectType::NodeV,
                 XFA_Element::ExcludeNS,
                 nullptr,
-                kExcludeNSAttributeData,
-                kExcludeNSName) {}
+                kExcludeNSAttributeData) {}
 
-CXFA_ExcludeNS::~CXFA_ExcludeNS() {}
+CXFA_ExcludeNS::~CXFA_ExcludeNS() = default;
diff --git a/xfa/fxfa/parser/cxfa_exdata.cpp b/xfa/fxfa/parser/cxfa_exdata.cpp
index 8cb89ab..000afd7 100644
--- a/xfa/fxfa/parser/cxfa_exdata.cpp
+++ b/xfa/fxfa/parser/cxfa_exdata.cpp
@@ -24,7 +24,6 @@
     {XFA_Attribute::Href, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kExDataName[] = L"exData";
 
 }  // namespace
 
@@ -36,10 +35,9 @@
                 XFA_Element::ExData,
                 nullptr,
                 kExDataAttributeData,
-                kExDataName,
                 pdfium::MakeUnique<CJX_ExData>(this)) {}
 
-CXFA_ExData::~CXFA_ExData() {}
+CXFA_ExData::~CXFA_ExData() = default;
 
 void CXFA_ExData::SetContentType(const WideString& wsContentType) {
   JSObject()->SetCData(XFA_Attribute::ContentType, wsContentType, false, false);
diff --git a/xfa/fxfa/parser/cxfa_execute.cpp b/xfa/fxfa/parser/cxfa_execute.cpp
index 70d3589..2f40f7d 100644
--- a/xfa/fxfa/parser/cxfa_execute.cpp
+++ b/xfa/fxfa/parser/cxfa_execute.cpp
@@ -22,8 +22,6 @@
     {XFA_Attribute::Usehref, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kExecuteName[] = L"execute";
-
 }  // namespace
 
 CXFA_Execute::CXFA_Execute(CXFA_Document* doc, XFA_PacketType packet)
@@ -34,7 +32,6 @@
                 XFA_Element::Execute,
                 nullptr,
                 kExecuteAttributeData,
-                kExecuteName,
                 pdfium::MakeUnique<CJX_Execute>(this)) {}
 
-CXFA_Execute::~CXFA_Execute() {}
+CXFA_Execute::~CXFA_Execute() = default;
diff --git a/xfa/fxfa/parser/cxfa_exobject.cpp b/xfa/fxfa/parser/cxfa_exobject.cpp
index 719399b..a43ed48 100644
--- a/xfa/fxfa/parser/cxfa_exobject.cpp
+++ b/xfa/fxfa/parser/cxfa_exobject.cpp
@@ -14,6 +14,7 @@
 const CXFA_Node::PropertyData kExObjectPropertyData[] = {
     {XFA_Element::Extras, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kExObjectAttributeData[] = {
     {XFA_Attribute::Id, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Name, XFA_AttributeType::CData, nullptr},
@@ -25,8 +26,6 @@
     {XFA_Attribute::ClassId, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kExObjectName[] = L"exObject";
-
 }  // namespace
 
 CXFA_ExObject::CXFA_ExObject(CXFA_Document* doc, XFA_PacketType packet)
@@ -37,7 +36,6 @@
                 XFA_Element::ExObject,
                 kExObjectPropertyData,
                 kExObjectAttributeData,
-                kExObjectName,
                 pdfium::MakeUnique<CJX_ExObject>(this)) {}
 
-CXFA_ExObject::~CXFA_ExObject() {}
+CXFA_ExObject::~CXFA_ExObject() = default;
diff --git a/xfa/fxfa/parser/cxfa_extras.cpp b/xfa/fxfa/parser/cxfa_extras.cpp
index ff9ac9b..6f8360b 100644
--- a/xfa/fxfa/parser/cxfa_extras.cpp
+++ b/xfa/fxfa/parser/cxfa_extras.cpp
@@ -18,8 +18,6 @@
     {XFA_Attribute::Usehref, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kExtrasName[] = L"extras";
-
 }  // namespace
 
 CXFA_Extras::CXFA_Extras(CXFA_Document* doc, XFA_PacketType packet)
@@ -31,7 +29,6 @@
                 XFA_Element::Extras,
                 nullptr,
                 kExtrasAttributeData,
-                kExtrasName,
                 pdfium::MakeUnique<CJX_Extras>(this)) {}
 
-CXFA_Extras::~CXFA_Extras() {}
+CXFA_Extras::~CXFA_Extras() = default;
diff --git a/xfa/fxfa/parser/cxfa_field.cpp b/xfa/fxfa/parser/cxfa_field.cpp
index d9278c7..0be32e8 100644
--- a/xfa/fxfa/parser/cxfa_field.cpp
+++ b/xfa/fxfa/parser/cxfa_field.cpp
@@ -21,6 +21,7 @@
     {XFA_Element::Font, 1, 0},      {XFA_Element::Value, 1, 0},
     {XFA_Element::Calculate, 1, 0}, {XFA_Element::Extras, 1, 0},
     {XFA_Element::Items, 2, 0},     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kFieldAttributeData[] = {
     {XFA_Attribute::H, XFA_AttributeType::Measure, (void*)L"0in"},
     {XFA_Attribute::W, XFA_AttributeType::Measure, (void*)L"0in"},
@@ -51,8 +52,6 @@
     {XFA_Attribute::AccessKey, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kFieldName[] = L"field";
-
 }  // namespace
 
 CXFA_Field::CXFA_Field(CXFA_Document* doc, XFA_PacketType packet)
@@ -63,7 +62,6 @@
                 XFA_Element::Field,
                 kFieldPropertyData,
                 kFieldAttributeData,
-                kFieldName,
                 pdfium::MakeUnique<CJX_Field>(this)) {}
 
-CXFA_Field::~CXFA_Field() {}
+CXFA_Field::~CXFA_Field() = default;
diff --git a/xfa/fxfa/parser/cxfa_fill.cpp b/xfa/fxfa/parser/cxfa_fill.cpp
index cd84ef9..04972af 100644
--- a/xfa/fxfa/parser/cxfa_fill.cpp
+++ b/xfa/fxfa/parser/cxfa_fill.cpp
@@ -27,6 +27,7 @@
     {XFA_Element::Extras, 1, 0},
     {XFA_Element::Radial, 1, XFA_PROPERTYFLAG_OneOf},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kFillAttributeData[] = {
     {XFA_Attribute::Id, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Use, XFA_AttributeType::CData, nullptr},
@@ -35,8 +36,6 @@
     {XFA_Attribute::Usehref, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kFillName[] = L"fill";
-
 }  // namespace
 
 CXFA_Fill::CXFA_Fill(CXFA_Document* doc, XFA_PacketType packet)
@@ -47,10 +46,9 @@
                 XFA_Element::Fill,
                 kFillPropertyData,
                 kFillAttributeData,
-                kFillName,
                 pdfium::MakeUnique<CJX_Fill>(this)) {}
 
-CXFA_Fill::~CXFA_Fill() {}
+CXFA_Fill::~CXFA_Fill() = default;
 
 bool CXFA_Fill::IsVisible() {
   return JSObject()
diff --git a/xfa/fxfa/parser/cxfa_filter.cpp b/xfa/fxfa/parser/cxfa_filter.cpp
index 28e9368..09483c6 100644
--- a/xfa/fxfa/parser/cxfa_filter.cpp
+++ b/xfa/fxfa/parser/cxfa_filter.cpp
@@ -17,6 +17,7 @@
     {XFA_Element::DigestMethods, 1, 0}, {XFA_Element::Encodings, 1, 0},
     {XFA_Element::Reasons, 1, 0},       {XFA_Element::AppearanceFilter, 1, 0},
     {XFA_Element::LockDocument, 1, 0},  {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kFilterAttributeData[] = {
     {XFA_Attribute::Id, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Name, XFA_AttributeType::CData, nullptr},
@@ -26,8 +27,6 @@
     {XFA_Attribute::AddRevocationInfo, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kFilterName[] = L"filter";
-
 }  // namespace
 
 CXFA_Filter::CXFA_Filter(CXFA_Document* doc, XFA_PacketType packet)
@@ -38,7 +37,6 @@
                 XFA_Element::Filter,
                 kFilterPropertyData,
                 kFilterAttributeData,
-                kFilterName,
                 pdfium::MakeUnique<CJX_Filter>(this)) {}
 
-CXFA_Filter::~CXFA_Filter() {}
+CXFA_Filter::~CXFA_Filter() = default;
diff --git a/xfa/fxfa/parser/cxfa_fliplabel.cpp b/xfa/fxfa/parser/cxfa_fliplabel.cpp
index bc5cb52..2834c40 100644
--- a/xfa/fxfa/parser/cxfa_fliplabel.cpp
+++ b/xfa/fxfa/parser/cxfa_fliplabel.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kFlipLabelName[] = L"flipLabel";
-
 }  // namespace
 
 CXFA_FlipLabel::CXFA_FlipLabel(CXFA_Document* doc, XFA_PacketType packet)
@@ -24,7 +22,6 @@
                 XFA_ObjectType::NodeV,
                 XFA_Element::FlipLabel,
                 nullptr,
-                kFlipLabelAttributeData,
-                kFlipLabelName) {}
+                kFlipLabelAttributeData) {}
 
-CXFA_FlipLabel::~CXFA_FlipLabel() {}
+CXFA_FlipLabel::~CXFA_FlipLabel() = default;
diff --git a/xfa/fxfa/parser/cxfa_float.cpp b/xfa/fxfa/parser/cxfa_float.cpp
index fdf0163..8b28d21 100644
--- a/xfa/fxfa/parser/cxfa_float.cpp
+++ b/xfa/fxfa/parser/cxfa_float.cpp
@@ -18,8 +18,6 @@
     {XFA_Attribute::Usehref, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kFloatName[] = L"float";
-
 }  // namespace
 
 CXFA_Float::CXFA_Float(CXFA_Document* doc, XFA_PacketType packet)
@@ -30,7 +28,6 @@
                 XFA_Element::Float,
                 nullptr,
                 kFloatAttributeData,
-                kFloatName,
                 pdfium::MakeUnique<CJX_Float>(this)) {}
 
-CXFA_Float::~CXFA_Float() {}
+CXFA_Float::~CXFA_Float() = default;
diff --git a/xfa/fxfa/parser/cxfa_font.cpp b/xfa/fxfa/parser/cxfa_font.cpp
index 42e7e17..fd10d76 100644
--- a/xfa/fxfa/parser/cxfa_font.cpp
+++ b/xfa/fxfa/parser/cxfa_font.cpp
@@ -17,6 +17,7 @@
     {XFA_Element::Fill, 1, 0},
     {XFA_Element::Extras, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kFontAttributeData[] = {
     {XFA_Attribute::Id, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::LineThrough, XFA_AttributeType::Integer, (void*)0},
@@ -49,8 +50,6 @@
      (void*)XFA_AttributeValue::Serif},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kFontName[] = L"font";
-
 }  // namespace
 
 CXFA_Font::CXFA_Font(CXFA_Document* doc, XFA_PacketType packet)
@@ -62,10 +61,9 @@
           XFA_Element::Font,
           kFontPropertyData,
           kFontAttributeData,
-          kFontName,
           pdfium::MakeUnique<CJX_Font>(this)) {}
 
-CXFA_Font::~CXFA_Font() {}
+CXFA_Font::~CXFA_Font() = default;
 
 float CXFA_Font::GetBaselineShift() const {
   return JSObject()
diff --git a/xfa/fxfa/parser/cxfa_fontinfo.cpp b/xfa/fxfa/parser/cxfa_fontinfo.cpp
index c649798..4cca2c6 100644
--- a/xfa/fxfa/parser/cxfa_fontinfo.cpp
+++ b/xfa/fxfa/parser/cxfa_fontinfo.cpp
@@ -13,13 +13,12 @@
     {XFA_Element::Map, 1, 0},
     {XFA_Element::Embed, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kFontInfoAttributeData[] = {
     {XFA_Attribute::Desc, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kFontInfoName[] = L"fontInfo";
-
 }  // namespace
 
 CXFA_FontInfo::CXFA_FontInfo(CXFA_Document* doc, XFA_PacketType packet)
@@ -29,7 +28,6 @@
                 XFA_ObjectType::Node,
                 XFA_Element::FontInfo,
                 kFontInfoPropertyData,
-                kFontInfoAttributeData,
-                kFontInfoName) {}
+                kFontInfoAttributeData) {}
 
-CXFA_FontInfo::~CXFA_FontInfo() {}
+CXFA_FontInfo::~CXFA_FontInfo() = default;
diff --git a/xfa/fxfa/parser/cxfa_form.cpp b/xfa/fxfa/parser/cxfa_form.cpp
index 7dfdc83..30ebb02 100644
--- a/xfa/fxfa/parser/cxfa_form.cpp
+++ b/xfa/fxfa/parser/cxfa_form.cpp
@@ -15,8 +15,6 @@
     {XFA_Attribute::Checksum, XFA_AttributeType::CData, (void*)nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kFormName[] = L"form";
-
 }  // namespace
 
 CXFA_Form::CXFA_Form(CXFA_Document* doc, XFA_PacketType packet)
@@ -27,7 +25,6 @@
                 XFA_Element::Form,
                 nullptr,
                 kFormAttributeData,
-                kFormName,
                 pdfium::MakeUnique<CJX_Form>(this)) {}
 
-CXFA_Form::~CXFA_Form() {}
+CXFA_Form::~CXFA_Form() = default;
diff --git a/xfa/fxfa/parser/cxfa_format.cpp b/xfa/fxfa/parser/cxfa_format.cpp
index de06f10..c972c83 100644
--- a/xfa/fxfa/parser/cxfa_format.cpp
+++ b/xfa/fxfa/parser/cxfa_format.cpp
@@ -15,14 +15,13 @@
     {XFA_Element::Picture, 1, 0},
     {XFA_Element::Extras, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kFormatAttributeData[] = {
     {XFA_Attribute::Id, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Use, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Usehref, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kFormatName[] = L"format";
-
 }  // namespace
 
 CXFA_Format::CXFA_Format(CXFA_Document* doc, XFA_PacketType packet)
@@ -33,7 +32,6 @@
                 XFA_Element::Format,
                 kFormatPropertyData,
                 kFormatAttributeData,
-                kFormatName,
                 pdfium::MakeUnique<CJX_Format>(this)) {}
 
-CXFA_Format::~CXFA_Format() {}
+CXFA_Format::~CXFA_Format() = default;
diff --git a/xfa/fxfa/parser/cxfa_formfieldfilling.cpp b/xfa/fxfa/parser/cxfa_formfieldfilling.cpp
index e1ccd3a..397280c 100644
--- a/xfa/fxfa/parser/cxfa_formfieldfilling.cpp
+++ b/xfa/fxfa/parser/cxfa_formfieldfilling.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kFormFieldFillingName[] = L"formFieldFilling";
-
 }  // namespace
 
 CXFA_FormFieldFilling::CXFA_FormFieldFilling(CXFA_Document* doc,
@@ -25,7 +23,6 @@
                 XFA_ObjectType::ContentNode,
                 XFA_Element::FormFieldFilling,
                 nullptr,
-                kFormFieldFillingAttributeData,
-                kFormFieldFillingName) {}
+                kFormFieldFillingAttributeData) {}
 
-CXFA_FormFieldFilling::~CXFA_FormFieldFilling() {}
+CXFA_FormFieldFilling::~CXFA_FormFieldFilling() = default;
diff --git a/xfa/fxfa/parser/cxfa_groupparent.cpp b/xfa/fxfa/parser/cxfa_groupparent.cpp
index 108877a..8c4ebb9 100644
--- a/xfa/fxfa/parser/cxfa_groupparent.cpp
+++ b/xfa/fxfa/parser/cxfa_groupparent.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kGroupParentName[] = L"groupParent";
-
 }  // namespace
 
 CXFA_GroupParent::CXFA_GroupParent(CXFA_Document* doc, XFA_PacketType packet)
@@ -24,7 +22,6 @@
                 XFA_ObjectType::NodeV,
                 XFA_Element::GroupParent,
                 nullptr,
-                kGroupParentAttributeData,
-                kGroupParentName) {}
+                kGroupParentAttributeData) {}
 
-CXFA_GroupParent::~CXFA_GroupParent() {}
+CXFA_GroupParent::~CXFA_GroupParent() = default;
diff --git a/xfa/fxfa/parser/cxfa_handler.cpp b/xfa/fxfa/parser/cxfa_handler.cpp
index 7877941..71e3b7d 100644
--- a/xfa/fxfa/parser/cxfa_handler.cpp
+++ b/xfa/fxfa/parser/cxfa_handler.cpp
@@ -19,8 +19,6 @@
     {XFA_Attribute::Usehref, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kHandlerName[] = L"handler";
-
 }  // namespace
 
 CXFA_Handler::CXFA_Handler(CXFA_Document* doc, XFA_PacketType packet)
@@ -31,7 +29,6 @@
                 XFA_Element::Handler,
                 nullptr,
                 kHandlerAttributeData,
-                kHandlerName,
                 pdfium::MakeUnique<CJX_Handler>(this)) {}
 
-CXFA_Handler::~CXFA_Handler() {}
+CXFA_Handler::~CXFA_Handler() = default;
diff --git a/xfa/fxfa/parser/cxfa_hyphenation.cpp b/xfa/fxfa/parser/cxfa_hyphenation.cpp
index c885ae5..5c92e61 100644
--- a/xfa/fxfa/parser/cxfa_hyphenation.cpp
+++ b/xfa/fxfa/parser/cxfa_hyphenation.cpp
@@ -20,8 +20,6 @@
     {XFA_Attribute::ExcludeAllCaps, XFA_AttributeType::Boolean, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kHyphenationName[] = L"hyphenation";
-
 }  // namespace
 
 CXFA_Hyphenation::CXFA_Hyphenation(CXFA_Document* doc, XFA_PacketType packet)
@@ -31,7 +29,6 @@
                 XFA_ObjectType::Node,
                 XFA_Element::Hyphenation,
                 nullptr,
-                kHyphenationAttributeData,
-                kHyphenationName) {}
+                kHyphenationAttributeData) {}
 
-CXFA_Hyphenation::~CXFA_Hyphenation() {}
+CXFA_Hyphenation::~CXFA_Hyphenation() = default;
diff --git a/xfa/fxfa/parser/cxfa_ifempty.cpp b/xfa/fxfa/parser/cxfa_ifempty.cpp
index bc7d4ba..74d9e28 100644
--- a/xfa/fxfa/parser/cxfa_ifempty.cpp
+++ b/xfa/fxfa/parser/cxfa_ifempty.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kIfEmptyName[] = L"ifEmpty";
-
 }  // namespace
 
 CXFA_IfEmpty::CXFA_IfEmpty(CXFA_Document* doc, XFA_PacketType packet)
@@ -24,7 +22,6 @@
                 XFA_ObjectType::NodeV,
                 XFA_Element::IfEmpty,
                 nullptr,
-                kIfEmptyAttributeData,
-                kIfEmptyName) {}
+                kIfEmptyAttributeData) {}
 
-CXFA_IfEmpty::~CXFA_IfEmpty() {}
+CXFA_IfEmpty::~CXFA_IfEmpty() = default;
diff --git a/xfa/fxfa/parser/cxfa_image.cpp b/xfa/fxfa/parser/cxfa_image.cpp
index c67bf3e..dc447ba 100644
--- a/xfa/fxfa/parser/cxfa_image.cpp
+++ b/xfa/fxfa/parser/cxfa_image.cpp
@@ -23,8 +23,6 @@
     {XFA_Attribute::Href, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kImageName[] = L"image";
-
 }  // namespace
 
 CXFA_Image::CXFA_Image(CXFA_Document* doc, XFA_PacketType packet)
@@ -34,10 +32,9 @@
                 XFA_ObjectType::ContentNode,
                 XFA_Element::Image,
                 nullptr,
-                kImageAttributeData,
-                kImageName) {}
+                kImageAttributeData) {}
 
-CXFA_Image::~CXFA_Image() {}
+CXFA_Image::~CXFA_Image() = default;
 
 XFA_AttributeValue CXFA_Image::GetAspect() {
   return JSObject()->GetEnum(XFA_Attribute::Aspect);
diff --git a/xfa/fxfa/parser/cxfa_imageedit.cpp b/xfa/fxfa/parser/cxfa_imageedit.cpp
index cd660f1..b90aee0 100644
--- a/xfa/fxfa/parser/cxfa_imageedit.cpp
+++ b/xfa/fxfa/parser/cxfa_imageedit.cpp
@@ -16,6 +16,7 @@
     {XFA_Element::Border, 1, 0},
     {XFA_Element::Extras, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kImageEditAttributeData[] = {
     {XFA_Attribute::Id, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Use, XFA_AttributeType::CData, nullptr},
@@ -24,8 +25,6 @@
      (void*)XFA_AttributeValue::Link},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kImageEditName[] = L"imageEdit";
-
 }  // namespace
 
 CXFA_ImageEdit::CXFA_ImageEdit(CXFA_Document* doc, XFA_PacketType packet)
@@ -36,10 +35,9 @@
                 XFA_Element::ImageEdit,
                 kImageEditPropertyData,
                 kImageEditAttributeData,
-                kImageEditName,
                 pdfium::MakeUnique<CJX_ImageEdit>(this)) {}
 
-CXFA_ImageEdit::~CXFA_ImageEdit() {}
+CXFA_ImageEdit::~CXFA_ImageEdit() = default;
 
 XFA_Element CXFA_ImageEdit::GetValueNodeType() const {
   return XFA_Element::Image;
diff --git a/xfa/fxfa/parser/cxfa_includexdpcontent.cpp b/xfa/fxfa/parser/cxfa_includexdpcontent.cpp
index b71bb00..b476d26 100644
--- a/xfa/fxfa/parser/cxfa_includexdpcontent.cpp
+++ b/xfa/fxfa/parser/cxfa_includexdpcontent.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kIncludeXDPContentName[] = L"includeXDPContent";
-
 }  // namespace
 
 CXFA_IncludeXDPContent::CXFA_IncludeXDPContent(CXFA_Document* doc,
@@ -25,7 +23,6 @@
                 XFA_ObjectType::ContentNode,
                 XFA_Element::IncludeXDPContent,
                 nullptr,
-                kIncludeXDPContentAttributeData,
-                kIncludeXDPContentName) {}
+                kIncludeXDPContentAttributeData) {}
 
-CXFA_IncludeXDPContent::~CXFA_IncludeXDPContent() {}
+CXFA_IncludeXDPContent::~CXFA_IncludeXDPContent() = default;
diff --git a/xfa/fxfa/parser/cxfa_incrementalload.cpp b/xfa/fxfa/parser/cxfa_incrementalload.cpp
index 5a1f345..8700231 100644
--- a/xfa/fxfa/parser/cxfa_incrementalload.cpp
+++ b/xfa/fxfa/parser/cxfa_incrementalload.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kIncrementalLoadName[] = L"incrementalLoad";
-
 }  // namespace
 
 CXFA_IncrementalLoad::CXFA_IncrementalLoad(CXFA_Document* doc,
@@ -25,7 +23,6 @@
                 XFA_ObjectType::NodeV,
                 XFA_Element::IncrementalLoad,
                 nullptr,
-                kIncrementalLoadAttributeData,
-                kIncrementalLoadName) {}
+                kIncrementalLoadAttributeData) {}
 
-CXFA_IncrementalLoad::~CXFA_IncrementalLoad() {}
+CXFA_IncrementalLoad::~CXFA_IncrementalLoad() = default;
diff --git a/xfa/fxfa/parser/cxfa_incrementalmerge.cpp b/xfa/fxfa/parser/cxfa_incrementalmerge.cpp
index 000d86e..6fc247b 100644
--- a/xfa/fxfa/parser/cxfa_incrementalmerge.cpp
+++ b/xfa/fxfa/parser/cxfa_incrementalmerge.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kIncrementalMergeName[] = L"incrementalMerge";
-
 }  // namespace
 
 CXFA_IncrementalMerge::CXFA_IncrementalMerge(CXFA_Document* doc,
@@ -25,7 +23,6 @@
                 XFA_ObjectType::ContentNode,
                 XFA_Element::IncrementalMerge,
                 nullptr,
-                kIncrementalMergeAttributeData,
-                kIncrementalMergeName) {}
+                kIncrementalMergeAttributeData) {}
 
-CXFA_IncrementalMerge::~CXFA_IncrementalMerge() {}
+CXFA_IncrementalMerge::~CXFA_IncrementalMerge() = default;
diff --git a/xfa/fxfa/parser/cxfa_insert.cpp b/xfa/fxfa/parser/cxfa_insert.cpp
index efc80ee..759b301 100644
--- a/xfa/fxfa/parser/cxfa_insert.cpp
+++ b/xfa/fxfa/parser/cxfa_insert.cpp
@@ -18,8 +18,6 @@
     {XFA_Attribute::Usehref, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kInsertName[] = L"insert";
-
 }  // namespace
 
 CXFA_Insert::CXFA_Insert(CXFA_Document* doc, XFA_PacketType packet)
@@ -30,7 +28,6 @@
                 XFA_Element::Insert,
                 nullptr,
                 kInsertAttributeData,
-                kInsertName,
                 pdfium::MakeUnique<CJX_Insert>(this)) {}
 
-CXFA_Insert::~CXFA_Insert() {}
+CXFA_Insert::~CXFA_Insert() = default;
diff --git a/xfa/fxfa/parser/cxfa_instancemanager.cpp b/xfa/fxfa/parser/cxfa_instancemanager.cpp
index ac74a32..6e2129a 100644
--- a/xfa/fxfa/parser/cxfa_instancemanager.cpp
+++ b/xfa/fxfa/parser/cxfa_instancemanager.cpp
@@ -14,12 +14,11 @@
 const CXFA_Node::PropertyData kInstanceManagerPropertyData[] = {
     {XFA_Element::Occur, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kInstanceManagerAttributeData[] = {
     {XFA_Attribute::Name, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kInstanceManagerName[] = L"instanceManager";
-
 }  // namespace
 
 CXFA_InstanceManager::CXFA_InstanceManager(CXFA_Document* doc,
@@ -31,7 +30,6 @@
                 XFA_Element::InstanceManager,
                 kInstanceManagerPropertyData,
                 kInstanceManagerAttributeData,
-                kInstanceManagerName,
                 pdfium::MakeUnique<CJX_InstanceManager>(this)) {}
 
-CXFA_InstanceManager::~CXFA_InstanceManager() {}
+CXFA_InstanceManager::~CXFA_InstanceManager() = default;
diff --git a/xfa/fxfa/parser/cxfa_integer.cpp b/xfa/fxfa/parser/cxfa_integer.cpp
index 0e87fd3..b2938a1 100644
--- a/xfa/fxfa/parser/cxfa_integer.cpp
+++ b/xfa/fxfa/parser/cxfa_integer.cpp
@@ -18,8 +18,6 @@
     {XFA_Attribute::Usehref, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kIntegerName[] = L"integer";
-
 }  // namespace
 
 CXFA_Integer::CXFA_Integer(CXFA_Document* doc, XFA_PacketType packet)
@@ -31,7 +29,6 @@
                 XFA_Element::Integer,
                 nullptr,
                 kIntegerAttributeData,
-                kIntegerName,
                 pdfium::MakeUnique<CJX_Integer>(this)) {}
 
-CXFA_Integer::~CXFA_Integer() {}
+CXFA_Integer::~CXFA_Integer() = default;
diff --git a/xfa/fxfa/parser/cxfa_interactive.cpp b/xfa/fxfa/parser/cxfa_interactive.cpp
index 135ca01..bfc6ba9 100644
--- a/xfa/fxfa/parser/cxfa_interactive.cpp
+++ b/xfa/fxfa/parser/cxfa_interactive.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kInteractiveName[] = L"interactive";
-
 }  // namespace
 
 CXFA_Interactive::CXFA_Interactive(CXFA_Document* doc, XFA_PacketType packet)
@@ -24,7 +22,6 @@
                 XFA_ObjectType::ContentNode,
                 XFA_Element::Interactive,
                 nullptr,
-                kInteractiveAttributeData,
-                kInteractiveName) {}
+                kInteractiveAttributeData) {}
 
 CXFA_Interactive::~CXFA_Interactive() {}
diff --git a/xfa/fxfa/parser/cxfa_issuers.cpp b/xfa/fxfa/parser/cxfa_issuers.cpp
index dda1aa5..fb28215 100644
--- a/xfa/fxfa/parser/cxfa_issuers.cpp
+++ b/xfa/fxfa/parser/cxfa_issuers.cpp
@@ -19,8 +19,6 @@
     {XFA_Attribute::Usehref, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kIssuersName[] = L"issuers";
-
 }  // namespace
 
 CXFA_Issuers::CXFA_Issuers(CXFA_Document* doc, XFA_PacketType packet)
@@ -31,7 +29,6 @@
                 XFA_Element::Issuers,
                 nullptr,
                 kIssuersAttributeData,
-                kIssuersName,
                 pdfium::MakeUnique<CJX_Issuers>(this)) {}
 
-CXFA_Issuers::~CXFA_Issuers() {}
+CXFA_Issuers::~CXFA_Issuers() = default;
diff --git a/xfa/fxfa/parser/cxfa_items.cpp b/xfa/fxfa/parser/cxfa_items.cpp
index ad2fe1d..6a7aa84 100644
--- a/xfa/fxfa/parser/cxfa_items.cpp
+++ b/xfa/fxfa/parser/cxfa_items.cpp
@@ -22,8 +22,6 @@
     {XFA_Attribute::Usehref, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kItemsName[] = L"items";
-
 }  // namespace
 
 CXFA_Items::CXFA_Items(CXFA_Document* doc, XFA_PacketType packet)
@@ -34,7 +32,6 @@
                 XFA_Element::Items,
                 nullptr,
                 kItemsAttributeData,
-                kItemsName,
                 pdfium::MakeUnique<CJX_Items>(this)) {}
 
-CXFA_Items::~CXFA_Items() {}
+CXFA_Items::~CXFA_Items() = default;
diff --git a/xfa/fxfa/parser/cxfa_jog.cpp b/xfa/fxfa/parser/cxfa_jog.cpp
index 31673ad..be73760 100644
--- a/xfa/fxfa/parser/cxfa_jog.cpp
+++ b/xfa/fxfa/parser/cxfa_jog.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kJogName[] = L"jog";
-
 }  // namespace
 
 CXFA_Jog::CXFA_Jog(CXFA_Document* doc, XFA_PacketType packet)
@@ -24,7 +22,6 @@
                 XFA_ObjectType::ContentNode,
                 XFA_Element::Jog,
                 nullptr,
-                kJogAttributeData,
-                kJogName) {}
+                kJogAttributeData) {}
 
-CXFA_Jog::~CXFA_Jog() {}
+CXFA_Jog::~CXFA_Jog() = default;
diff --git a/xfa/fxfa/parser/cxfa_keep.cpp b/xfa/fxfa/parser/cxfa_keep.cpp
index e58fa2c..8135d97 100644
--- a/xfa/fxfa/parser/cxfa_keep.cpp
+++ b/xfa/fxfa/parser/cxfa_keep.cpp
@@ -14,6 +14,7 @@
 const CXFA_Node::PropertyData kKeepPropertyData[] = {
     {XFA_Element::Extras, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kKeepAttributeData[] = {
     {XFA_Attribute::Id, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Next, XFA_AttributeType::Enum,
@@ -26,8 +27,6 @@
      (void*)XFA_AttributeValue::None},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kKeepName[] = L"keep";
-
 }  // namespace
 
 CXFA_Keep::CXFA_Keep(CXFA_Document* doc, XFA_PacketType packet)
@@ -38,7 +37,6 @@
                 XFA_Element::Keep,
                 kKeepPropertyData,
                 kKeepAttributeData,
-                kKeepName,
                 pdfium::MakeUnique<CJX_Keep>(this)) {}
 
-CXFA_Keep::~CXFA_Keep() {}
+CXFA_Keep::~CXFA_Keep() = default;
diff --git a/xfa/fxfa/parser/cxfa_keyusage.cpp b/xfa/fxfa/parser/cxfa_keyusage.cpp
index 6f8ee25..62d11d2 100644
--- a/xfa/fxfa/parser/cxfa_keyusage.cpp
+++ b/xfa/fxfa/parser/cxfa_keyusage.cpp
@@ -28,8 +28,6 @@
     {XFA_Attribute::DecipherOnly, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kKeyUsageName[] = L"keyUsage";
-
 }  // namespace
 
 CXFA_KeyUsage::CXFA_KeyUsage(CXFA_Document* doc, XFA_PacketType packet)
@@ -40,7 +38,6 @@
                 XFA_Element::KeyUsage,
                 nullptr,
                 kKeyUsageAttributeData,
-                kKeyUsageName,
                 pdfium::MakeUnique<CJX_KeyUsage>(this)) {}
 
-CXFA_KeyUsage::~CXFA_KeyUsage() {}
+CXFA_KeyUsage::~CXFA_KeyUsage() = default;
diff --git a/xfa/fxfa/parser/cxfa_labelprinter.cpp b/xfa/fxfa/parser/cxfa_labelprinter.cpp
index fa2256d..4d80384 100644
--- a/xfa/fxfa/parser/cxfa_labelprinter.cpp
+++ b/xfa/fxfa/parser/cxfa_labelprinter.cpp
@@ -14,6 +14,7 @@
     {XFA_Element::BatchOutput, 1, 0},
     {XFA_Element::FlipLabel, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kLabelPrinterAttributeData[] = {
     {XFA_Attribute::Name, XFA_AttributeType::Enum,
      (void*)XFA_AttributeValue::Zpl},
@@ -21,8 +22,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kLabelPrinterName[] = L"labelPrinter";
-
 }  // namespace
 
 CXFA_LabelPrinter::CXFA_LabelPrinter(CXFA_Document* doc, XFA_PacketType packet)
@@ -32,7 +31,6 @@
                 XFA_ObjectType::Node,
                 XFA_Element::LabelPrinter,
                 kLabelPrinterPropertyData,
-                kLabelPrinterAttributeData,
-                kLabelPrinterName) {}
+                kLabelPrinterAttributeData) {}
 
-CXFA_LabelPrinter::~CXFA_LabelPrinter() {}
+CXFA_LabelPrinter::~CXFA_LabelPrinter() = default;
diff --git a/xfa/fxfa/parser/cxfa_layout.cpp b/xfa/fxfa/parser/cxfa_layout.cpp
index ef742da..b200c6d 100644
--- a/xfa/fxfa/parser/cxfa_layout.cpp
+++ b/xfa/fxfa/parser/cxfa_layout.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kLayoutName[] = L"layout";
-
 }  // namespace
 
 CXFA_Layout::CXFA_Layout(CXFA_Document* doc, XFA_PacketType packet)
@@ -24,7 +22,6 @@
                 XFA_ObjectType::ContentNode,
                 XFA_Element::Layout,
                 nullptr,
-                kLayoutAttributeData,
-                kLayoutName) {}
+                kLayoutAttributeData) {}
 
-CXFA_Layout::~CXFA_Layout() {}
+CXFA_Layout::~CXFA_Layout() = default;
diff --git a/xfa/fxfa/parser/cxfa_level.cpp b/xfa/fxfa/parser/cxfa_level.cpp
index fca705a..ee1747f 100644
--- a/xfa/fxfa/parser/cxfa_level.cpp
+++ b/xfa/fxfa/parser/cxfa_level.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kLevelName[] = L"level";
-
 }  // namespace
 
 CXFA_Level::CXFA_Level(CXFA_Document* doc, XFA_PacketType packet)
@@ -24,7 +22,6 @@
                 XFA_ObjectType::ContentNode,
                 XFA_Element::Level,
                 nullptr,
-                kLevelAttributeData,
-                kLevelName) {}
+                kLevelAttributeData) {}
 
-CXFA_Level::~CXFA_Level() {}
+CXFA_Level::~CXFA_Level() = default;
diff --git a/xfa/fxfa/parser/cxfa_line.cpp b/xfa/fxfa/parser/cxfa_line.cpp
index 2378557..65e4b08 100644
--- a/xfa/fxfa/parser/cxfa_line.cpp
+++ b/xfa/fxfa/parser/cxfa_line.cpp
@@ -16,6 +16,7 @@
 const CXFA_Node::PropertyData kLinePropertyData[] = {
     {XFA_Element::Edge, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kLineAttributeData[] = {
     {XFA_Attribute::Id, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Use, XFA_AttributeType::CData, nullptr},
@@ -26,8 +27,6 @@
      (void*)XFA_AttributeValue::Even},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kLineName[] = L"line";
-
 }  // namespace
 
 CXFA_Line::CXFA_Line(CXFA_Document* doc, XFA_PacketType packet)
@@ -38,10 +37,9 @@
                 XFA_Element::Line,
                 kLinePropertyData,
                 kLineAttributeData,
-                kLineName,
                 pdfium::MakeUnique<CJX_Line>(this)) {}
 
-CXFA_Line::~CXFA_Line() {}
+CXFA_Line::~CXFA_Line() = default;
 
 XFA_AttributeValue CXFA_Line::GetHand() {
   return JSObject()->GetEnum(XFA_Attribute::Hand);
diff --git a/xfa/fxfa/parser/cxfa_linear.cpp b/xfa/fxfa/parser/cxfa_linear.cpp
index 920aa47..0f79b49 100644
--- a/xfa/fxfa/parser/cxfa_linear.cpp
+++ b/xfa/fxfa/parser/cxfa_linear.cpp
@@ -17,6 +17,7 @@
     {XFA_Element::Color, 1, 0},
     {XFA_Element::Extras, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kLinearAttributeData[] = {
     {XFA_Attribute::Id, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Use, XFA_AttributeType::CData, nullptr},
@@ -25,8 +26,6 @@
     {XFA_Attribute::Usehref, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kLinearName[] = L"linear";
-
 }  // namespace
 
 CXFA_Linear::CXFA_Linear(CXFA_Document* doc, XFA_PacketType packet)
@@ -37,10 +36,9 @@
                 XFA_Element::Linear,
                 kLinearPropertyData,
                 kLinearAttributeData,
-                kLinearName,
                 pdfium::MakeUnique<CJX_Linear>(this)) {}
 
-CXFA_Linear::~CXFA_Linear() {}
+CXFA_Linear::~CXFA_Linear() = default;
 
 XFA_AttributeValue CXFA_Linear::GetType() {
   return JSObject()
diff --git a/xfa/fxfa/parser/cxfa_linearized.cpp b/xfa/fxfa/parser/cxfa_linearized.cpp
index a16d8a3..fe2bd2c 100644
--- a/xfa/fxfa/parser/cxfa_linearized.cpp
+++ b/xfa/fxfa/parser/cxfa_linearized.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kLinearizedName[] = L"linearized";
-
 }  // namespace
 
 CXFA_Linearized::CXFA_Linearized(CXFA_Document* doc, XFA_PacketType packet)
@@ -24,7 +22,6 @@
                 XFA_ObjectType::ContentNode,
                 XFA_Element::Linearized,
                 nullptr,
-                kLinearizedAttributeData,
-                kLinearizedName) {}
+                kLinearizedAttributeData) {}
 
-CXFA_Linearized::~CXFA_Linearized() {}
+CXFA_Linearized::~CXFA_Linearized() = default;
diff --git a/xfa/fxfa/parser/cxfa_list.cpp b/xfa/fxfa/parser/cxfa_list.cpp
index 6f5fc29..e2e755c 100644
--- a/xfa/fxfa/parser/cxfa_list.cpp
+++ b/xfa/fxfa/parser/cxfa_list.cpp
@@ -18,15 +18,13 @@
     : CXFA_List(pDocument,
                 XFA_ObjectType::List,
                 XFA_Element::List,
-                WideStringView(L"list"),
                 std::move(obj)) {}
 
 CXFA_List::CXFA_List(CXFA_Document* pDocument,
                      XFA_ObjectType objectType,
                      XFA_Element eType,
-                     const WideStringView& elementName,
                      std::unique_ptr<CJX_Object> obj)
-    : CXFA_Object(pDocument, objectType, eType, elementName, std::move(obj)) {
+    : CXFA_Object(pDocument, objectType, eType, std::move(obj)) {
   m_pDocument->GetScriptContext()->AddToCacheList(
       std::unique_ptr<CXFA_List>(this));
 }
diff --git a/xfa/fxfa/parser/cxfa_list.h b/xfa/fxfa/parser/cxfa_list.h
index 66182863..bfe6508 100644
--- a/xfa/fxfa/parser/cxfa_list.h
+++ b/xfa/fxfa/parser/cxfa_list.h
@@ -28,7 +28,6 @@
   CXFA_List(CXFA_Document* pDocument,
             XFA_ObjectType objectType,
             XFA_Element eType,
-            const WideStringView& elementName,
             std::unique_ptr<CJX_Object> obj);
 };
 
diff --git a/xfa/fxfa/parser/cxfa_locale.cpp b/xfa/fxfa/parser/cxfa_locale.cpp
index d4af887..ec62397 100644
--- a/xfa/fxfa/parser/cxfa_locale.cpp
+++ b/xfa/fxfa/parser/cxfa_locale.cpp
@@ -14,14 +14,13 @@
     {XFA_Element::DateTimeSymbols, 1, 0}, {XFA_Element::NumberPatterns, 1, 0},
     {XFA_Element::NumberSymbols, 1, 0},   {XFA_Element::TimePatterns, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kLocaleAttributeData[] = {
     {XFA_Attribute::Name, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Desc, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kLocaleName[] = L"locale";
-
 }  // namespace
 
 CXFA_Locale::CXFA_Locale(CXFA_Document* doc, XFA_PacketType packet)
@@ -31,7 +30,6 @@
                 XFA_ObjectType::Node,
                 XFA_Element::Locale,
                 kLocalePropertyData,
-                kLocaleAttributeData,
-                kLocaleName) {}
+                kLocaleAttributeData) {}
 
-CXFA_Locale::~CXFA_Locale() {}
+CXFA_Locale::~CXFA_Locale() = default;
diff --git a/xfa/fxfa/parser/cxfa_localeset.cpp b/xfa/fxfa/parser/cxfa_localeset.cpp
index 6829284..95c7e18 100644
--- a/xfa/fxfa/parser/cxfa_localeset.cpp
+++ b/xfa/fxfa/parser/cxfa_localeset.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kLocaleSetName[] = L"localeSet";
-
 }  // namespace
 
 CXFA_LocaleSet::CXFA_LocaleSet(CXFA_Document* doc, XFA_PacketType packet)
@@ -24,7 +22,6 @@
                 XFA_ObjectType::ModelNode,
                 XFA_Element::LocaleSet,
                 nullptr,
-                kLocaleSetAttributeData,
-                kLocaleSetName) {}
+                kLocaleSetAttributeData) {}
 
-CXFA_LocaleSet::~CXFA_LocaleSet() {}
+CXFA_LocaleSet::~CXFA_LocaleSet() = default;
diff --git a/xfa/fxfa/parser/cxfa_lockdocument.cpp b/xfa/fxfa/parser/cxfa_lockdocument.cpp
index 3364f69..02ca6a0 100644
--- a/xfa/fxfa/parser/cxfa_lockdocument.cpp
+++ b/xfa/fxfa/parser/cxfa_lockdocument.cpp
@@ -16,8 +16,6 @@
     {XFA_Attribute::Usehref, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kLockDocumentName[] = L"lockDocument";
-
 }  // namespace
 
 CXFA_LockDocument::CXFA_LockDocument(CXFA_Document* doc, XFA_PacketType packet)
@@ -27,7 +25,6 @@
                 XFA_ObjectType::ContentNode,
                 XFA_Element::LockDocument,
                 nullptr,
-                kLockDocumentAttributeData,
-                kLockDocumentName) {}
+                kLockDocumentAttributeData) {}
 
-CXFA_LockDocument::~CXFA_LockDocument() {}
+CXFA_LockDocument::~CXFA_LockDocument() = default;
diff --git a/xfa/fxfa/parser/cxfa_log.cpp b/xfa/fxfa/parser/cxfa_log.cpp
index be68d70..0a71ad2 100644
--- a/xfa/fxfa/parser/cxfa_log.cpp
+++ b/xfa/fxfa/parser/cxfa_log.cpp
@@ -14,13 +14,12 @@
     {XFA_Element::Mode, 1, 0},
     {XFA_Element::Threshold, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kLogAttributeData[] = {
     {XFA_Attribute::Desc, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kLogName[] = L"log";
-
 }  // namespace
 
 CXFA_Log::CXFA_Log(CXFA_Document* doc, XFA_PacketType packet)
@@ -30,7 +29,6 @@
                 XFA_ObjectType::Node,
                 XFA_Element::Log,
                 kLogPropertyData,
-                kLogAttributeData,
-                kLogName) {}
+                kLogAttributeData) {}
 
-CXFA_Log::~CXFA_Log() {}
+CXFA_Log::~CXFA_Log() = default;
diff --git a/xfa/fxfa/parser/cxfa_manifest.cpp b/xfa/fxfa/parser/cxfa_manifest.cpp
index 8d9a9fa..7442c13 100644
--- a/xfa/fxfa/parser/cxfa_manifest.cpp
+++ b/xfa/fxfa/parser/cxfa_manifest.cpp
@@ -14,6 +14,7 @@
 const CXFA_Node::PropertyData kManifestPropertyData[] = {
     {XFA_Element::Extras, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kManifestAttributeData[] = {
     {XFA_Attribute::Id, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Name, XFA_AttributeType::CData, nullptr},
@@ -23,8 +24,6 @@
     {XFA_Attribute::Usehref, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kManifestName[] = L"manifest";
-
 }  // namespace
 
 CXFA_Manifest::CXFA_Manifest(CXFA_Document* doc, XFA_PacketType packet)
@@ -35,7 +34,6 @@
                 XFA_Element::Manifest,
                 kManifestPropertyData,
                 kManifestAttributeData,
-                kManifestName,
                 pdfium::MakeUnique<CJX_Manifest>(this)) {}
 
-CXFA_Manifest::~CXFA_Manifest() {}
+CXFA_Manifest::~CXFA_Manifest() = default;
diff --git a/xfa/fxfa/parser/cxfa_map.cpp b/xfa/fxfa/parser/cxfa_map.cpp
index fb264a5..36909d0 100644
--- a/xfa/fxfa/parser/cxfa_map.cpp
+++ b/xfa/fxfa/parser/cxfa_map.cpp
@@ -22,8 +22,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kMapName[] = L"map";
-
 }  // namespace
 
 CXFA_Map::CXFA_Map(CXFA_Document* doc, XFA_PacketType packet)
@@ -34,7 +32,6 @@
                 XFA_Element::Map,
                 nullptr,
                 kMapAttributeData,
-                kMapName,
                 pdfium::MakeUnique<CJX_Map>(this)) {}
 
-CXFA_Map::~CXFA_Map() {}
+CXFA_Map::~CXFA_Map() = default;
diff --git a/xfa/fxfa/parser/cxfa_margin.cpp b/xfa/fxfa/parser/cxfa_margin.cpp
index 56bcc13..27277a9 100644
--- a/xfa/fxfa/parser/cxfa_margin.cpp
+++ b/xfa/fxfa/parser/cxfa_margin.cpp
@@ -14,6 +14,7 @@
 const CXFA_Node::PropertyData kMarginPropertyData[] = {
     {XFA_Element::Extras, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kMarginAttributeData[] = {
     {XFA_Attribute::Id, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Use, XFA_AttributeType::CData, nullptr},
@@ -24,8 +25,6 @@
     {XFA_Attribute::Usehref, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kMarginName[] = L"margin";
-
 }  // namespace
 
 CXFA_Margin::CXFA_Margin(CXFA_Document* doc, XFA_PacketType packet)
@@ -36,10 +35,9 @@
                 XFA_Element::Margin,
                 kMarginPropertyData,
                 kMarginAttributeData,
-                kMarginName,
                 pdfium::MakeUnique<CJX_Margin>(this)) {}
 
-CXFA_Margin::~CXFA_Margin() {}
+CXFA_Margin::~CXFA_Margin() = default;
 
 float CXFA_Margin::GetLeftInset() const {
   return TryLeftInset().value_or(0);
diff --git a/xfa/fxfa/parser/cxfa_mdp.cpp b/xfa/fxfa/parser/cxfa_mdp.cpp
index f64822f..ab3b0f7 100644
--- a/xfa/fxfa/parser/cxfa_mdp.cpp
+++ b/xfa/fxfa/parser/cxfa_mdp.cpp
@@ -20,8 +20,6 @@
     {XFA_Attribute::Permissions, XFA_AttributeType::Integer, (void*)2},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kMdpName[] = L"mdp";
-
 }  // namespace
 
 CXFA_Mdp::CXFA_Mdp(CXFA_Document* doc, XFA_PacketType packet)
@@ -32,7 +30,6 @@
                 XFA_Element::Mdp,
                 nullptr,
                 kMdpAttributeData,
-                kMdpName,
                 pdfium::MakeUnique<CJX_Mdp>(this)) {}
 
-CXFA_Mdp::~CXFA_Mdp() {}
+CXFA_Mdp::~CXFA_Mdp() = default;
diff --git a/xfa/fxfa/parser/cxfa_medium.cpp b/xfa/fxfa/parser/cxfa_medium.cpp
index 7e47e83..45c2a54 100644
--- a/xfa/fxfa/parser/cxfa_medium.cpp
+++ b/xfa/fxfa/parser/cxfa_medium.cpp
@@ -27,8 +27,6 @@
     {XFA_Attribute::Long, XFA_AttributeType::Measure, (void*)L"0in"},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kMediumName[] = L"medium";
-
 }  // namespace
 
 CXFA_Medium::CXFA_Medium(CXFA_Document* doc, XFA_PacketType packet)
@@ -39,7 +37,6 @@
                 XFA_Element::Medium,
                 nullptr,
                 kMediumAttributeData,
-                kMediumName,
                 pdfium::MakeUnique<CJX_Medium>(this)) {}
 
-CXFA_Medium::~CXFA_Medium() {}
+CXFA_Medium::~CXFA_Medium() = default;
diff --git a/xfa/fxfa/parser/cxfa_mediuminfo.cpp b/xfa/fxfa/parser/cxfa_mediuminfo.cpp
index b17bd6f..8725159 100644
--- a/xfa/fxfa/parser/cxfa_mediuminfo.cpp
+++ b/xfa/fxfa/parser/cxfa_mediuminfo.cpp
@@ -11,13 +11,12 @@
 const CXFA_Node::PropertyData kMediumInfoPropertyData[] = {
     {XFA_Element::Map, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kMediumInfoAttributeData[] = {
     {XFA_Attribute::Desc, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kMediumInfoName[] = L"mediumInfo";
-
 }  // namespace
 
 CXFA_MediumInfo::CXFA_MediumInfo(CXFA_Document* doc, XFA_PacketType packet)
@@ -27,7 +26,6 @@
                 XFA_ObjectType::Node,
                 XFA_Element::MediumInfo,
                 kMediumInfoPropertyData,
-                kMediumInfoAttributeData,
-                kMediumInfoName) {}
+                kMediumInfoAttributeData) {}
 
-CXFA_MediumInfo::~CXFA_MediumInfo() {}
+CXFA_MediumInfo::~CXFA_MediumInfo() = default;
diff --git a/xfa/fxfa/parser/cxfa_meridiem.cpp b/xfa/fxfa/parser/cxfa_meridiem.cpp
index 3e88b03..d4138e0 100644
--- a/xfa/fxfa/parser/cxfa_meridiem.cpp
+++ b/xfa/fxfa/parser/cxfa_meridiem.cpp
@@ -6,12 +6,6 @@
 
 #include "xfa/fxfa/parser/cxfa_meridiem.h"
 
-namespace {
-
-constexpr wchar_t kMeridiemName[] = L"meridiem";
-
-}  // namespace
-
 CXFA_Meridiem::CXFA_Meridiem(CXFA_Document* doc, XFA_PacketType packet)
     : CXFA_Node(doc,
                 packet,
@@ -19,7 +13,6 @@
                 XFA_ObjectType::ContentNode,
                 XFA_Element::Meridiem,
                 nullptr,
-                nullptr,
-                kMeridiemName) {}
+                nullptr) {}
 
-CXFA_Meridiem::~CXFA_Meridiem() {}
+CXFA_Meridiem::~CXFA_Meridiem() = default;
diff --git a/xfa/fxfa/parser/cxfa_meridiemnames.cpp b/xfa/fxfa/parser/cxfa_meridiemnames.cpp
index a5f2e4d..6f6788e 100644
--- a/xfa/fxfa/parser/cxfa_meridiemnames.cpp
+++ b/xfa/fxfa/parser/cxfa_meridiemnames.cpp
@@ -12,8 +12,6 @@
     {XFA_Element::Meridiem, 2, 0},
     {XFA_Element::Unknown, 0, 0}};
 
-constexpr wchar_t kMeridiemNamesName[] = L"meridiemNames";
-
 }  // namespace
 
 CXFA_MeridiemNames::CXFA_MeridiemNames(CXFA_Document* doc,
@@ -24,7 +22,6 @@
                 XFA_ObjectType::Node,
                 XFA_Element::MeridiemNames,
                 kMeridiemNamesPropertyData,
-                nullptr,
-                kMeridiemNamesName) {}
+                nullptr) {}
 
-CXFA_MeridiemNames::~CXFA_MeridiemNames() {}
+CXFA_MeridiemNames::~CXFA_MeridiemNames() = default;
diff --git a/xfa/fxfa/parser/cxfa_message.cpp b/xfa/fxfa/parser/cxfa_message.cpp
index aa5a378..529ddf4 100644
--- a/xfa/fxfa/parser/cxfa_message.cpp
+++ b/xfa/fxfa/parser/cxfa_message.cpp
@@ -15,6 +15,7 @@
     {XFA_Element::MsgId, 1, 0},
     {XFA_Element::Severity, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kMessageAttributeData[] = {
     {XFA_Attribute::Id, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Use, XFA_AttributeType::CData, nullptr},
@@ -23,8 +24,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kMessageName[] = L"message";
-
 }  // namespace
 
 CXFA_Message::CXFA_Message(CXFA_Document* doc, XFA_PacketType packet)
@@ -36,7 +35,6 @@
           XFA_Element::Message,
           kMessagePropertyData,
           kMessageAttributeData,
-          kMessageName,
           pdfium::MakeUnique<CJX_Message>(this)) {}
 
-CXFA_Message::~CXFA_Message() {}
+CXFA_Message::~CXFA_Message() = default;
diff --git a/xfa/fxfa/parser/cxfa_messaging.cpp b/xfa/fxfa/parser/cxfa_messaging.cpp
index 68401b9..e97a165 100644
--- a/xfa/fxfa/parser/cxfa_messaging.cpp
+++ b/xfa/fxfa/parser/cxfa_messaging.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kMessagingName[] = L"messaging";
-
 }  // namespace
 
 CXFA_Messaging::CXFA_Messaging(CXFA_Document* doc, XFA_PacketType packet)
@@ -24,7 +22,6 @@
                 XFA_ObjectType::Node,
                 XFA_Element::Messaging,
                 nullptr,
-                kMessagingAttributeData,
-                kMessagingName) {}
+                kMessagingAttributeData) {}
 
-CXFA_Messaging::~CXFA_Messaging() {}
+CXFA_Messaging::~CXFA_Messaging() = default;
diff --git a/xfa/fxfa/parser/cxfa_mode.cpp b/xfa/fxfa/parser/cxfa_mode.cpp
index bdca52e..b936b07 100644
--- a/xfa/fxfa/parser/cxfa_mode.cpp
+++ b/xfa/fxfa/parser/cxfa_mode.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kModeName[] = L"mode";
-
 }  // namespace
 
 CXFA_Mode::CXFA_Mode(CXFA_Document* doc, XFA_PacketType packet)
@@ -24,7 +22,6 @@
                 XFA_ObjectType::ContentNode,
                 XFA_Element::Mode,
                 nullptr,
-                kModeAttributeData,
-                kModeName) {}
+                kModeAttributeData) {}
 
-CXFA_Mode::~CXFA_Mode() {}
+CXFA_Mode::~CXFA_Mode() = default;
diff --git a/xfa/fxfa/parser/cxfa_modifyannots.cpp b/xfa/fxfa/parser/cxfa_modifyannots.cpp
index ca2c888..5d1296d 100644
--- a/xfa/fxfa/parser/cxfa_modifyannots.cpp
+++ b/xfa/fxfa/parser/cxfa_modifyannots.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kModifyAnnotsName[] = L"modifyAnnots";
-
 }  // namespace
 
 CXFA_ModifyAnnots::CXFA_ModifyAnnots(CXFA_Document* doc, XFA_PacketType packet)
@@ -24,7 +22,6 @@
                 XFA_ObjectType::ContentNode,
                 XFA_Element::ModifyAnnots,
                 nullptr,
-                kModifyAnnotsAttributeData,
-                kModifyAnnotsName) {}
+                kModifyAnnotsAttributeData) {}
 
-CXFA_ModifyAnnots::~CXFA_ModifyAnnots() {}
+CXFA_ModifyAnnots::~CXFA_ModifyAnnots() = default;
diff --git a/xfa/fxfa/parser/cxfa_month.cpp b/xfa/fxfa/parser/cxfa_month.cpp
index 63be429..78704e3 100644
--- a/xfa/fxfa/parser/cxfa_month.cpp
+++ b/xfa/fxfa/parser/cxfa_month.cpp
@@ -6,12 +6,6 @@
 
 #include "xfa/fxfa/parser/cxfa_month.h"
 
-namespace {
-
-constexpr wchar_t kMonthName[] = L"month";
-
-}  // namespace
-
 CXFA_Month::CXFA_Month(CXFA_Document* doc, XFA_PacketType packet)
     : CXFA_Node(doc,
                 packet,
@@ -19,7 +13,6 @@
                 XFA_ObjectType::ContentNode,
                 XFA_Element::Month,
                 nullptr,
-                nullptr,
-                kMonthName) {}
+                nullptr) {}
 
-CXFA_Month::~CXFA_Month() {}
+CXFA_Month::~CXFA_Month() = default;
diff --git a/xfa/fxfa/parser/cxfa_monthnames.cpp b/xfa/fxfa/parser/cxfa_monthnames.cpp
index 04fba6b..b8e586a 100644
--- a/xfa/fxfa/parser/cxfa_monthnames.cpp
+++ b/xfa/fxfa/parser/cxfa_monthnames.cpp
@@ -11,12 +11,11 @@
 const CXFA_Node::PropertyData kMonthNamesPropertyData[] = {
     {XFA_Element::Month, 12, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kMonthNamesAttributeData[] = {
     {XFA_Attribute::Abbr, XFA_AttributeType::Boolean, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kMonthNamesName[] = L"monthNames";
-
 }  // namespace
 
 CXFA_MonthNames::CXFA_MonthNames(CXFA_Document* doc, XFA_PacketType packet)
@@ -26,7 +25,6 @@
                 XFA_ObjectType::Node,
                 XFA_Element::MonthNames,
                 kMonthNamesPropertyData,
-                kMonthNamesAttributeData,
-                kMonthNamesName) {}
+                kMonthNamesAttributeData) {}
 
-CXFA_MonthNames::~CXFA_MonthNames() {}
+CXFA_MonthNames::~CXFA_MonthNames() = default;
diff --git a/xfa/fxfa/parser/cxfa_msgid.cpp b/xfa/fxfa/parser/cxfa_msgid.cpp
index b9a771e..51d678a 100644
--- a/xfa/fxfa/parser/cxfa_msgid.cpp
+++ b/xfa/fxfa/parser/cxfa_msgid.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kMsgIdName[] = L"msgId";
-
 }  // namespace
 
 CXFA_MsgId::CXFA_MsgId(CXFA_Document* doc, XFA_PacketType packet)
@@ -24,7 +22,6 @@
                 XFA_ObjectType::NodeV,
                 XFA_Element::MsgId,
                 nullptr,
-                kMsgIdAttributeData,
-                kMsgIdName) {}
+                kMsgIdAttributeData) {}
 
-CXFA_MsgId::~CXFA_MsgId() {}
+CXFA_MsgId::~CXFA_MsgId() = default;
diff --git a/xfa/fxfa/parser/cxfa_nameattr.cpp b/xfa/fxfa/parser/cxfa_nameattr.cpp
index 1bfb2f5..0df7a02 100644
--- a/xfa/fxfa/parser/cxfa_nameattr.cpp
+++ b/xfa/fxfa/parser/cxfa_nameattr.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kNameAttrName[] = L"nameAttr";
-
 }  // namespace
 
 CXFA_NameAttr::CXFA_NameAttr(CXFA_Document* doc, XFA_PacketType packet)
@@ -24,7 +22,6 @@
                 XFA_ObjectType::NodeV,
                 XFA_Element::NameAttr,
                 nullptr,
-                kNameAttrAttributeData,
-                kNameAttrName) {}
+                kNameAttrAttributeData) {}
 
-CXFA_NameAttr::~CXFA_NameAttr() {}
+CXFA_NameAttr::~CXFA_NameAttr() = default;
diff --git a/xfa/fxfa/parser/cxfa_neverembed.cpp b/xfa/fxfa/parser/cxfa_neverembed.cpp
index 7cc0526..4d2e8f3 100644
--- a/xfa/fxfa/parser/cxfa_neverembed.cpp
+++ b/xfa/fxfa/parser/cxfa_neverembed.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kNeverEmbedName[] = L"neverEmbed";
-
 }  // namespace
 
 CXFA_NeverEmbed::CXFA_NeverEmbed(CXFA_Document* doc, XFA_PacketType packet)
@@ -24,7 +22,6 @@
                 XFA_ObjectType::NodeV,
                 XFA_Element::NeverEmbed,
                 nullptr,
-                kNeverEmbedAttributeData,
-                kNeverEmbedName) {}
+                kNeverEmbedAttributeData) {}
 
-CXFA_NeverEmbed::~CXFA_NeverEmbed() {}
+CXFA_NeverEmbed::~CXFA_NeverEmbed() = default;
diff --git a/xfa/fxfa/parser/cxfa_node.cpp b/xfa/fxfa/parser/cxfa_node.cpp
index 8ec8da1..73e6be7 100644
--- a/xfa/fxfa/parser/cxfa_node.cpp
+++ b/xfa/fxfa/parser/cxfa_node.cpp
@@ -837,9 +837,8 @@
                      XFA_Element eType,
                      const PropertyData* properties,
                      const AttributeData* attributes,
-                     const WideStringView& elementName,
                      std::unique_ptr<CJX_Object> js_node)
-    : CXFA_Object(pDoc, oType, eType, elementName, std::move(js_node)),
+    : CXFA_Object(pDoc, oType, eType, std::move(js_node)),
       m_Properties(properties),
       m_Attributes(attributes),
       m_ValidPackets(validPackets),
@@ -853,8 +852,7 @@
                      XFA_ObjectType oType,
                      XFA_Element eType,
                      const PropertyData* properties,
-                     const AttributeData* attributes,
-                     const WideStringView& elementName)
+                     const AttributeData* attributes)
     : CXFA_Node(pDoc,
                 ePacket,
                 validPackets,
@@ -862,7 +860,6 @@
                 eType,
                 properties,
                 attributes,
-                elementName,
                 pdfium::MakeUnique<CJX_Node>(this)) {}
 
 CXFA_Node::~CXFA_Node() = default;
@@ -5545,7 +5542,7 @@
       node = pdfium::MakeUnique<CXFA_Signature>(doc, packet);
       break;
     case XFA_Element::ADBE_JSConsole:
-      node = pdfium::MakeUnique<CXFA_aDBE_JSConsole>(doc, packet);
+      node = pdfium::MakeUnique<CXFA_ADBE_JSConsole>(doc, packet);
       break;
     case XFA_Element::Caption:
       node = pdfium::MakeUnique<CXFA_Caption>(doc, packet);
@@ -5650,7 +5647,7 @@
       node = pdfium::MakeUnique<CXFA_EffectiveOutputPolicy>(doc, packet);
       break;
     case XFA_Element::ADBE_JSDebugger:
-      node = pdfium::MakeUnique<CXFA_aDBE_JSDebugger>(doc, packet);
+      node = pdfium::MakeUnique<CXFA_ADBE_JSDebugger>(doc, packet);
       break;
     case XFA_Element::Acrobat7:
       node = pdfium::MakeUnique<CXFA_Acrobat7>(doc, packet);
diff --git a/xfa/fxfa/parser/cxfa_node.h b/xfa/fxfa/parser/cxfa_node.h
index 139587e..0f02e50 100644
--- a/xfa/fxfa/parser/cxfa_node.h
+++ b/xfa/fxfa/parser/cxfa_node.h
@@ -380,7 +380,6 @@
             XFA_Element eType,
             const PropertyData* properties,
             const AttributeData* attributes,
-            const WideStringView& elementName,
             std::unique_ptr<CJX_Object> js_node);
   CXFA_Node(CXFA_Document* pDoc,
             XFA_PacketType ePacket,
@@ -388,8 +387,7 @@
             XFA_ObjectType oType,
             XFA_Element eType,
             const PropertyData* properties,
-            const AttributeData* attributes,
-            const WideStringView& elementName);
+            const AttributeData* attributes);
 
  private:
   void ProcessScriptTestValidate(CXFA_FFDocView* docView,
diff --git a/xfa/fxfa/parser/cxfa_node_unittest.cpp b/xfa/fxfa/parser/cxfa_node_unittest.cpp
index f65c237..d1e016c 100644
--- a/xfa/fxfa/parser/cxfa_node_unittest.cpp
+++ b/xfa/fxfa/parser/cxfa_node_unittest.cpp
@@ -17,10 +17,9 @@
                   XFA_PacketType::Form,
                   (XFA_XDPPACKET_Template | XFA_XDPPACKET_Form),
                   XFA_ObjectType::Node,
-                  XFA_Element::Unknown,
+                  XFA_Element::Node,
                   nullptr,
-                  nullptr,
-                  L"TestNode") {}
+                  nullptr) {}
 
   ~TestNode() override = default;
 };
diff --git a/xfa/fxfa/parser/cxfa_nodehelper.cpp b/xfa/fxfa/parser/cxfa_nodehelper.cpp
index b40572b..2bf1f70 100644
--- a/xfa/fxfa/parser/cxfa_nodehelper.cpp
+++ b/xfa/fxfa/parser/cxfa_nodehelper.cpp
@@ -249,7 +249,7 @@
   bool bIsProperty = NodeIsProperty(refNode);
   if (refNode->IsUnnamed() ||
       (bIsProperty && refNode->GetElementType() != XFA_Element::PageSet)) {
-    ws = refNode->GetClassName();
+    ws = WideString::FromASCII(refNode->GetClassName());
     return WideString::Format(
         L"#%ls[%d]", ws.c_str(),
         GetIndex(refNode, XFA_LOGIC_Transparent, bIsProperty, true));
diff --git a/xfa/fxfa/parser/cxfa_numberofcopies.cpp b/xfa/fxfa/parser/cxfa_numberofcopies.cpp
index fdf2374..66739cf 100644
--- a/xfa/fxfa/parser/cxfa_numberofcopies.cpp
+++ b/xfa/fxfa/parser/cxfa_numberofcopies.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kNumberOfCopiesName[] = L"numberOfCopies";
-
 }  // namespace
 
 CXFA_NumberOfCopies::CXFA_NumberOfCopies(CXFA_Document* doc,
@@ -25,7 +23,6 @@
                 XFA_ObjectType::ContentNode,
                 XFA_Element::NumberOfCopies,
                 nullptr,
-                kNumberOfCopiesAttributeData,
-                kNumberOfCopiesName) {}
+                kNumberOfCopiesAttributeData) {}
 
-CXFA_NumberOfCopies::~CXFA_NumberOfCopies() {}
+CXFA_NumberOfCopies::~CXFA_NumberOfCopies() = default;
diff --git a/xfa/fxfa/parser/cxfa_numberpattern.cpp b/xfa/fxfa/parser/cxfa_numberpattern.cpp
index 4d8ca1b..1968341 100644
--- a/xfa/fxfa/parser/cxfa_numberpattern.cpp
+++ b/xfa/fxfa/parser/cxfa_numberpattern.cpp
@@ -13,8 +13,6 @@
      (void*)XFA_AttributeValue::Numeric},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kNumberPatternName[] = L"numberPattern";
-
 }  // namespace
 
 CXFA_NumberPattern::CXFA_NumberPattern(CXFA_Document* doc,
@@ -25,7 +23,6 @@
                 XFA_ObjectType::ContentNode,
                 XFA_Element::NumberPattern,
                 nullptr,
-                kNumberPatternAttributeData,
-                kNumberPatternName) {}
+                kNumberPatternAttributeData) {}
 
-CXFA_NumberPattern::~CXFA_NumberPattern() {}
+CXFA_NumberPattern::~CXFA_NumberPattern() = default;
diff --git a/xfa/fxfa/parser/cxfa_numberpatterns.cpp b/xfa/fxfa/parser/cxfa_numberpatterns.cpp
index 28dab94..6f448c0 100644
--- a/xfa/fxfa/parser/cxfa_numberpatterns.cpp
+++ b/xfa/fxfa/parser/cxfa_numberpatterns.cpp
@@ -12,8 +12,6 @@
     {XFA_Element::NumberPattern, 4, 0},
     {XFA_Element::Unknown, 0, 0}};
 
-constexpr wchar_t kNumberPatternsName[] = L"numberPatterns";
-
 }  // namespace
 
 CXFA_NumberPatterns::CXFA_NumberPatterns(CXFA_Document* doc,
@@ -24,7 +22,6 @@
                 XFA_ObjectType::Node,
                 XFA_Element::NumberPatterns,
                 kNumberPatternsPropertyData,
-                nullptr,
-                kNumberPatternsName) {}
+                nullptr) {}
 
-CXFA_NumberPatterns::~CXFA_NumberPatterns() {}
+CXFA_NumberPatterns::~CXFA_NumberPatterns() = default;
diff --git a/xfa/fxfa/parser/cxfa_numbersymbol.cpp b/xfa/fxfa/parser/cxfa_numbersymbol.cpp
index 582b12b..c65b7db 100644
--- a/xfa/fxfa/parser/cxfa_numbersymbol.cpp
+++ b/xfa/fxfa/parser/cxfa_numbersymbol.cpp
@@ -13,8 +13,6 @@
      (void*)XFA_AttributeValue::Decimal},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kNumberSymbolName[] = L"numberSymbol";
-
 }  // namespace
 
 CXFA_NumberSymbol::CXFA_NumberSymbol(CXFA_Document* doc, XFA_PacketType packet)
@@ -24,7 +22,6 @@
                 XFA_ObjectType::ContentNode,
                 XFA_Element::NumberSymbol,
                 nullptr,
-                kNumberSymbolAttributeData,
-                kNumberSymbolName) {}
+                kNumberSymbolAttributeData) {}
 
-CXFA_NumberSymbol::~CXFA_NumberSymbol() {}
+CXFA_NumberSymbol::~CXFA_NumberSymbol() = default;
diff --git a/xfa/fxfa/parser/cxfa_numbersymbols.cpp b/xfa/fxfa/parser/cxfa_numbersymbols.cpp
index 959877a..20e1dc0 100644
--- a/xfa/fxfa/parser/cxfa_numbersymbols.cpp
+++ b/xfa/fxfa/parser/cxfa_numbersymbols.cpp
@@ -12,8 +12,6 @@
     {XFA_Element::NumberSymbol, 5, 0},
     {XFA_Element::Unknown, 0, 0}};
 
-constexpr wchar_t kNumberSymbolsName[] = L"numberSymbols";
-
 }  // namespace
 
 CXFA_NumberSymbols::CXFA_NumberSymbols(CXFA_Document* doc,
@@ -24,7 +22,6 @@
                 XFA_ObjectType::Node,
                 XFA_Element::NumberSymbols,
                 kNumberSymbolsPropertyData,
-                nullptr,
-                kNumberSymbolsName) {}
+                nullptr) {}
 
-CXFA_NumberSymbols::~CXFA_NumberSymbols() {}
+CXFA_NumberSymbols::~CXFA_NumberSymbols() = default;
diff --git a/xfa/fxfa/parser/cxfa_numericedit.cpp b/xfa/fxfa/parser/cxfa_numericedit.cpp
index 20e0e41..6914594 100644
--- a/xfa/fxfa/parser/cxfa_numericedit.cpp
+++ b/xfa/fxfa/parser/cxfa_numericedit.cpp
@@ -17,6 +17,7 @@
     {XFA_Element::Comb, 1, 0},
     {XFA_Element::Extras, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kNumericEditAttributeData[] = {
     {XFA_Attribute::Id, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Use, XFA_AttributeType::CData, nullptr},
@@ -25,8 +26,6 @@
      (void*)XFA_AttributeValue::Auto},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kNumericEditName[] = L"numericEdit";
-
 }  // namespace
 
 CXFA_NumericEdit::CXFA_NumericEdit(CXFA_Document* doc, XFA_PacketType packet)
@@ -37,10 +36,9 @@
                 XFA_Element::NumericEdit,
                 kNumericEditPropertyData,
                 kNumericEditAttributeData,
-                kNumericEditName,
                 pdfium::MakeUnique<CJX_NumericEdit>(this)) {}
 
-CXFA_NumericEdit::~CXFA_NumericEdit() {}
+CXFA_NumericEdit::~CXFA_NumericEdit() = default;
 
 XFA_Element CXFA_NumericEdit::GetValueNodeType() const {
   return XFA_Element::Float;
diff --git a/xfa/fxfa/parser/cxfa_object.cpp b/xfa/fxfa/parser/cxfa_object.cpp
index 024dba2..b898f7a 100644
--- a/xfa/fxfa/parser/cxfa_object.cpp
+++ b/xfa/fxfa/parser/cxfa_object.cpp
@@ -17,17 +17,17 @@
 #include "xfa/fxfa/parser/cxfa_node.h"
 #include "xfa/fxfa/parser/cxfa_thisproxy.h"
 #include "xfa/fxfa/parser/cxfa_treelist.h"
+#include "xfa/fxfa/parser/xfa_basic_data.h"
 
 CXFA_Object::CXFA_Object(CXFA_Document* pDocument,
                          XFA_ObjectType objectType,
                          XFA_Element elementType,
-                         const WideStringView& elementName,
                          std::unique_ptr<CJX_Object> jsObject)
     : m_pDocument(pDocument),
       m_objectType(objectType),
       m_elementType(elementType),
-      m_elementNameHash(FX_HashCode_GetW(elementName, false)),
-      m_elementName(elementName),
+      m_elementName(XFA_ElementToName(elementType)),
+      m_elementNameHash(FX_HashCode_GetAsIfW(m_elementName, false)),
       m_pJSObject(std::move(jsObject)) {}
 
 CXFA_Object::~CXFA_Object() = default;
diff --git a/xfa/fxfa/parser/cxfa_object.h b/xfa/fxfa/parser/cxfa_object.h
index 173bf23..71a2d1d 100644
--- a/xfa/fxfa/parser/cxfa_object.h
+++ b/xfa/fxfa/parser/cxfa_object.h
@@ -85,7 +85,7 @@
   }
 
   XFA_Element GetElementType() const { return m_elementType; }
-  WideStringView GetClassName() const { return m_elementName; }
+  ByteStringView GetClassName() const { return m_elementName; }
   uint32_t GetClassHashCode() const { return m_elementNameHash; }
 
   WideString GetSOMExpression();
@@ -94,14 +94,13 @@
   CXFA_Object(CXFA_Document* pDocument,
               XFA_ObjectType objectType,
               XFA_Element eType,
-              const WideStringView& elementName,
               std::unique_ptr<CJX_Object> jsObject);
 
   UnownedPtr<CXFA_Document> const m_pDocument;
   const XFA_ObjectType m_objectType;
   const XFA_Element m_elementType;
+  const ByteStringView m_elementName;
   const uint32_t m_elementNameHash;
-  const WideStringView m_elementName;
   std::unique_ptr<CJX_Object> m_pJSObject;
 };
 
diff --git a/xfa/fxfa/parser/cxfa_occur.cpp b/xfa/fxfa/parser/cxfa_occur.cpp
index 0e16ef2..b5b3149 100644
--- a/xfa/fxfa/parser/cxfa_occur.cpp
+++ b/xfa/fxfa/parser/cxfa_occur.cpp
@@ -14,6 +14,7 @@
 const CXFA_Node::PropertyData kOccurPropertyData[] = {
     {XFA_Element::Extras, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kOccurAttributeData[] = {
     {XFA_Attribute::Id, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Max, XFA_AttributeType::Integer, (void*)1},
@@ -23,8 +24,6 @@
     {XFA_Attribute::Usehref, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kOccurName[] = L"occur";
-
 }  // namespace
 
 CXFA_Occur::CXFA_Occur(CXFA_Document* doc, XFA_PacketType packet)
@@ -35,10 +34,9 @@
                 XFA_Element::Occur,
                 kOccurPropertyData,
                 kOccurAttributeData,
-                kOccurName,
                 pdfium::MakeUnique<CJX_Occur>(this)) {}
 
-CXFA_Occur::~CXFA_Occur() {}
+CXFA_Occur::~CXFA_Occur() = default;
 
 int32_t CXFA_Occur::GetMax() {
   Optional<int32_t> max = JSObject()->TryInteger(XFA_Attribute::Max, true);
diff --git a/xfa/fxfa/parser/cxfa_oid.cpp b/xfa/fxfa/parser/cxfa_oid.cpp
index ca457aa..a27f182 100644
--- a/xfa/fxfa/parser/cxfa_oid.cpp
+++ b/xfa/fxfa/parser/cxfa_oid.cpp
@@ -18,8 +18,6 @@
     {XFA_Attribute::Usehref, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kOidName[] = L"oid";
-
 }  // namespace
 
 CXFA_Oid::CXFA_Oid(CXFA_Document* doc, XFA_PacketType packet)
@@ -30,7 +28,6 @@
                 XFA_Element::Oid,
                 nullptr,
                 kOidAttributeData,
-                kOidName,
                 pdfium::MakeUnique<CJX_Oid>(this)) {}
 
-CXFA_Oid::~CXFA_Oid() {}
+CXFA_Oid::~CXFA_Oid() = default;
diff --git a/xfa/fxfa/parser/cxfa_oids.cpp b/xfa/fxfa/parser/cxfa_oids.cpp
index 4d76434..46c419f 100644
--- a/xfa/fxfa/parser/cxfa_oids.cpp
+++ b/xfa/fxfa/parser/cxfa_oids.cpp
@@ -19,8 +19,6 @@
     {XFA_Attribute::Usehref, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kOidsName[] = L"oids";
-
 }  // namespace
 
 CXFA_Oids::CXFA_Oids(CXFA_Document* doc, XFA_PacketType packet)
@@ -31,7 +29,6 @@
                 XFA_Element::Oids,
                 nullptr,
                 kOidsAttributeData,
-                kOidsName,
                 pdfium::MakeUnique<CJX_Oids>(this)) {}
 
-CXFA_Oids::~CXFA_Oids() {}
+CXFA_Oids::~CXFA_Oids() = default;
diff --git a/xfa/fxfa/parser/cxfa_openaction.cpp b/xfa/fxfa/parser/cxfa_openaction.cpp
index 5a322e7..b50c89c 100644
--- a/xfa/fxfa/parser/cxfa_openaction.cpp
+++ b/xfa/fxfa/parser/cxfa_openaction.cpp
@@ -11,13 +11,12 @@
 const CXFA_Node::PropertyData kOpenActionPropertyData[] = {
     {XFA_Element::Destination, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kOpenActionAttributeData[] = {
     {XFA_Attribute::Desc, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kOpenActionName[] = L"openAction";
-
 }  // namespace
 
 CXFA_OpenAction::CXFA_OpenAction(CXFA_Document* doc, XFA_PacketType packet)
@@ -27,7 +26,6 @@
                 XFA_ObjectType::Node,
                 XFA_Element::OpenAction,
                 kOpenActionPropertyData,
-                kOpenActionAttributeData,
-                kOpenActionName) {}
+                kOpenActionAttributeData) {}
 
-CXFA_OpenAction::~CXFA_OpenAction() {}
+CXFA_OpenAction::~CXFA_OpenAction() = default;
diff --git a/xfa/fxfa/parser/cxfa_operation.cpp b/xfa/fxfa/parser/cxfa_operation.cpp
index 39bba1a..2bf5b17 100644
--- a/xfa/fxfa/parser/cxfa_operation.cpp
+++ b/xfa/fxfa/parser/cxfa_operation.cpp
@@ -20,8 +20,6 @@
     {XFA_Attribute::Input, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kOperationName[] = L"operation";
-
 }  // namespace
 
 CXFA_Operation::CXFA_Operation(CXFA_Document* doc, XFA_PacketType packet)
@@ -32,7 +30,6 @@
                 XFA_Element::Operation,
                 nullptr,
                 kOperationAttributeData,
-                kOperationName,
                 pdfium::MakeUnique<CJX_Operation>(this)) {}
 
-CXFA_Operation::~CXFA_Operation() {}
+CXFA_Operation::~CXFA_Operation() = default;
diff --git a/xfa/fxfa/parser/cxfa_output.cpp b/xfa/fxfa/parser/cxfa_output.cpp
index dfd297d..798eda6 100644
--- a/xfa/fxfa/parser/cxfa_output.cpp
+++ b/xfa/fxfa/parser/cxfa_output.cpp
@@ -13,13 +13,12 @@
     {XFA_Element::Uri, 1, 0},
     {XFA_Element::Type, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kOutputAttributeData[] = {
     {XFA_Attribute::Desc, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kOutputName[] = L"output";
-
 }  // namespace
 
 CXFA_Output::CXFA_Output(CXFA_Document* doc, XFA_PacketType packet)
@@ -29,7 +28,6 @@
                 XFA_ObjectType::Node,
                 XFA_Element::Output,
                 kOutputPropertyData,
-                kOutputAttributeData,
-                kOutputName) {}
+                kOutputAttributeData) {}
 
-CXFA_Output::~CXFA_Output() {}
+CXFA_Output::~CXFA_Output() = default;
diff --git a/xfa/fxfa/parser/cxfa_outputbin.cpp b/xfa/fxfa/parser/cxfa_outputbin.cpp
index 9864a1d..ac5dd1f 100644
--- a/xfa/fxfa/parser/cxfa_outputbin.cpp
+++ b/xfa/fxfa/parser/cxfa_outputbin.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kOutputBinName[] = L"outputBin";
-
 }  // namespace
 
 CXFA_OutputBin::CXFA_OutputBin(CXFA_Document* doc, XFA_PacketType packet)
@@ -24,7 +22,6 @@
                 XFA_ObjectType::ContentNode,
                 XFA_Element::OutputBin,
                 nullptr,
-                kOutputBinAttributeData,
-                kOutputBinName) {}
+                kOutputBinAttributeData) {}
 
-CXFA_OutputBin::~CXFA_OutputBin() {}
+CXFA_OutputBin::~CXFA_OutputBin() = default;
diff --git a/xfa/fxfa/parser/cxfa_outputxsl.cpp b/xfa/fxfa/parser/cxfa_outputxsl.cpp
index 5791907..509b562 100644
--- a/xfa/fxfa/parser/cxfa_outputxsl.cpp
+++ b/xfa/fxfa/parser/cxfa_outputxsl.cpp
@@ -11,13 +11,12 @@
 const CXFA_Node::PropertyData kOutputXSLPropertyData[] = {
     {XFA_Element::Uri, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kOutputXSLAttributeData[] = {
     {XFA_Attribute::Desc, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kOutputXSLName[] = L"outputXSL";
-
 }  // namespace
 
 CXFA_OutputXSL::CXFA_OutputXSL(CXFA_Document* doc, XFA_PacketType packet)
@@ -27,7 +26,6 @@
                 XFA_ObjectType::Node,
                 XFA_Element::OutputXSL,
                 kOutputXSLPropertyData,
-                kOutputXSLAttributeData,
-                kOutputXSLName) {}
+                kOutputXSLAttributeData) {}
 
-CXFA_OutputXSL::~CXFA_OutputXSL() {}
+CXFA_OutputXSL::~CXFA_OutputXSL() = default;
diff --git a/xfa/fxfa/parser/cxfa_overflow.cpp b/xfa/fxfa/parser/cxfa_overflow.cpp
index bc47698..5686595 100644
--- a/xfa/fxfa/parser/cxfa_overflow.cpp
+++ b/xfa/fxfa/parser/cxfa_overflow.cpp
@@ -20,8 +20,6 @@
     {XFA_Attribute::Leader, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kOverflowName[] = L"overflow";
-
 }  // namespace
 
 CXFA_Overflow::CXFA_Overflow(CXFA_Document* doc, XFA_PacketType packet)
@@ -32,7 +30,6 @@
                 XFA_Element::Overflow,
                 nullptr,
                 kOverflowAttributeData,
-                kOverflowName,
                 pdfium::MakeUnique<CJX_Overflow>(this)) {}
 
-CXFA_Overflow::~CXFA_Overflow() {}
+CXFA_Overflow::~CXFA_Overflow() = default;
diff --git a/xfa/fxfa/parser/cxfa_overprint.cpp b/xfa/fxfa/parser/cxfa_overprint.cpp
index 7ade64c..e2e9f37 100644
--- a/xfa/fxfa/parser/cxfa_overprint.cpp
+++ b/xfa/fxfa/parser/cxfa_overprint.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kOverprintName[] = L"overprint";
-
 }  // namespace
 
 CXFA_Overprint::CXFA_Overprint(CXFA_Document* doc, XFA_PacketType packet)
@@ -24,7 +22,6 @@
                 XFA_ObjectType::ContentNode,
                 XFA_Element::Overprint,
                 nullptr,
-                kOverprintAttributeData,
-                kOverprintName) {}
+                kOverprintAttributeData) {}
 
-CXFA_Overprint::~CXFA_Overprint() {}
+CXFA_Overprint::~CXFA_Overprint() = default;
diff --git a/xfa/fxfa/parser/cxfa_packet.cpp b/xfa/fxfa/parser/cxfa_packet.cpp
index 3280186..5b09f95 100644
--- a/xfa/fxfa/parser/cxfa_packet.cpp
+++ b/xfa/fxfa/parser/cxfa_packet.cpp
@@ -9,12 +9,6 @@
 #include "fxjs/xfa/cjx_packet.h"
 #include "third_party/base/ptr_util.h"
 
-namespace {
-
-constexpr wchar_t kPacketName[] = L"packet";
-
-}  // namespace
-
 CXFA_Packet::CXFA_Packet(CXFA_Document* doc, XFA_PacketType packet)
     : CXFA_Node(doc,
                 packet,
@@ -23,7 +17,6 @@
                 XFA_Element::Packet,
                 nullptr,
                 nullptr,
-                kPacketName,
                 pdfium::MakeUnique<CJX_Packet>(this)) {}
 
-CXFA_Packet::~CXFA_Packet() {}
+CXFA_Packet::~CXFA_Packet() = default;
diff --git a/xfa/fxfa/parser/cxfa_packets.cpp b/xfa/fxfa/parser/cxfa_packets.cpp
index b641f2e..2ec1e3d 100644
--- a/xfa/fxfa/parser/cxfa_packets.cpp
+++ b/xfa/fxfa/parser/cxfa_packets.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kPacketsName[] = L"packets";
-
 }  // namespace
 
 CXFA_Packets::CXFA_Packets(CXFA_Document* doc, XFA_PacketType packet)
@@ -24,7 +22,6 @@
                 XFA_ObjectType::ContentNode,
                 XFA_Element::Packets,
                 nullptr,
-                kPacketsAttributeData,
-                kPacketsName) {}
+                kPacketsAttributeData) {}
 
-CXFA_Packets::~CXFA_Packets() {}
+CXFA_Packets::~CXFA_Packets() = default;
diff --git a/xfa/fxfa/parser/cxfa_pagearea.cpp b/xfa/fxfa/parser/cxfa_pagearea.cpp
index 9462f29..09f37e9 100644
--- a/xfa/fxfa/parser/cxfa_pagearea.cpp
+++ b/xfa/fxfa/parser/cxfa_pagearea.cpp
@@ -17,6 +17,7 @@
     {XFA_Element::Extras, 1, 0},
     {XFA_Element::Occur, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kPageAreaAttributeData[] = {
     {XFA_Attribute::Id, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Name, XFA_AttributeType::CData, nullptr},
@@ -33,8 +34,6 @@
      (void*)XFA_AttributeValue::Any},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kPageAreaName[] = L"pageArea";
-
 }  // namespace
 
 CXFA_PageArea::CXFA_PageArea(CXFA_Document* doc, XFA_PacketType packet)
@@ -45,7 +44,6 @@
                 XFA_Element::PageArea,
                 kPageAreaPropertyData,
                 kPageAreaAttributeData,
-                kPageAreaName,
                 pdfium::MakeUnique<CJX_PageArea>(this)) {}
 
-CXFA_PageArea::~CXFA_PageArea() {}
+CXFA_PageArea::~CXFA_PageArea() = default;
diff --git a/xfa/fxfa/parser/cxfa_pageoffset.cpp b/xfa/fxfa/parser/cxfa_pageoffset.cpp
index 864b89d..8d3e19e 100644
--- a/xfa/fxfa/parser/cxfa_pageoffset.cpp
+++ b/xfa/fxfa/parser/cxfa_pageoffset.cpp
@@ -15,8 +15,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kPageOffsetName[] = L"pageOffset";
-
 }  // namespace
 
 CXFA_PageOffset::CXFA_PageOffset(CXFA_Document* doc, XFA_PacketType packet)
@@ -26,7 +24,6 @@
                 XFA_ObjectType::Node,
                 XFA_Element::PageOffset,
                 nullptr,
-                kPageOffsetAttributeData,
-                kPageOffsetName) {}
+                kPageOffsetAttributeData) {}
 
-CXFA_PageOffset::~CXFA_PageOffset() {}
+CXFA_PageOffset::~CXFA_PageOffset() = default;
diff --git a/xfa/fxfa/parser/cxfa_pagerange.cpp b/xfa/fxfa/parser/cxfa_pagerange.cpp
index 6136d8c..f0419ac 100644
--- a/xfa/fxfa/parser/cxfa_pagerange.cpp
+++ b/xfa/fxfa/parser/cxfa_pagerange.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kPageRangeName[] = L"pageRange";
-
 }  // namespace
 
 CXFA_PageRange::CXFA_PageRange(CXFA_Document* doc, XFA_PacketType packet)
@@ -24,7 +22,6 @@
                 XFA_ObjectType::ContentNode,
                 XFA_Element::PageRange,
                 nullptr,
-                kPageRangeAttributeData,
-                kPageRangeName) {}
+                kPageRangeAttributeData) {}
 
-CXFA_PageRange::~CXFA_PageRange() {}
+CXFA_PageRange::~CXFA_PageRange() = default;
diff --git a/xfa/fxfa/parser/cxfa_pageset.cpp b/xfa/fxfa/parser/cxfa_pageset.cpp
index 350651e..8909693 100644
--- a/xfa/fxfa/parser/cxfa_pageset.cpp
+++ b/xfa/fxfa/parser/cxfa_pageset.cpp
@@ -15,6 +15,7 @@
     {XFA_Element::Extras, 1, 0},
     {XFA_Element::Occur, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kPageSetAttributeData[] = {
     {XFA_Attribute::Id, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Name, XFA_AttributeType::CData, nullptr},
@@ -27,8 +28,6 @@
     {XFA_Attribute::Usehref, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kPageSetName[] = L"pageSet";
-
 }  // namespace
 
 CXFA_PageSet::CXFA_PageSet(CXFA_Document* doc, XFA_PacketType packet)
@@ -39,7 +38,6 @@
                 XFA_Element::PageSet,
                 kPageSetPropertyData,
                 kPageSetAttributeData,
-                kPageSetName,
                 pdfium::MakeUnique<CJX_PageSet>(this)) {}
 
-CXFA_PageSet::~CXFA_PageSet() {}
+CXFA_PageSet::~CXFA_PageSet() = default;
diff --git a/xfa/fxfa/parser/cxfa_pagination.cpp b/xfa/fxfa/parser/cxfa_pagination.cpp
index d6870fd..8c0d39d 100644
--- a/xfa/fxfa/parser/cxfa_pagination.cpp
+++ b/xfa/fxfa/parser/cxfa_pagination.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kPaginationName[] = L"pagination";
-
 }  // namespace
 
 CXFA_Pagination::CXFA_Pagination(CXFA_Document* doc, XFA_PacketType packet)
@@ -24,7 +22,6 @@
                 XFA_ObjectType::ContentNode,
                 XFA_Element::Pagination,
                 nullptr,
-                kPaginationAttributeData,
-                kPaginationName) {}
+                kPaginationAttributeData) {}
 
-CXFA_Pagination::~CXFA_Pagination() {}
+CXFA_Pagination::~CXFA_Pagination() = default;
diff --git a/xfa/fxfa/parser/cxfa_paginationoverride.cpp b/xfa/fxfa/parser/cxfa_paginationoverride.cpp
index 05158dd..f627263 100644
--- a/xfa/fxfa/parser/cxfa_paginationoverride.cpp
+++ b/xfa/fxfa/parser/cxfa_paginationoverride.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kPaginationOverrideName[] = L"paginationOverride";
-
 }  // namespace
 
 CXFA_PaginationOverride::CXFA_PaginationOverride(CXFA_Document* doc,
@@ -25,7 +23,6 @@
                 XFA_ObjectType::ContentNode,
                 XFA_Element::PaginationOverride,
                 nullptr,
-                kPaginationOverrideAttributeData,
-                kPaginationOverrideName) {}
+                kPaginationOverrideAttributeData) {}
 
-CXFA_PaginationOverride::~CXFA_PaginationOverride() {}
+CXFA_PaginationOverride::~CXFA_PaginationOverride() = default;
diff --git a/xfa/fxfa/parser/cxfa_para.cpp b/xfa/fxfa/parser/cxfa_para.cpp
index 9c7243b..5ed6a51 100644
--- a/xfa/fxfa/parser/cxfa_para.cpp
+++ b/xfa/fxfa/parser/cxfa_para.cpp
@@ -15,6 +15,7 @@
 const CXFA_Node::PropertyData kParaPropertyData[] = {
     {XFA_Element::Hyphenation, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kParaAttributeData[] = {
     {XFA_Attribute::Id, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::HAlign, XFA_AttributeType::Enum,
@@ -37,8 +38,6 @@
     {XFA_Attribute::SpaceAbove, XFA_AttributeType::Measure, (void*)L"0in"},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kParaName[] = L"para";
-
 }  // namespace
 
 CXFA_Para::CXFA_Para(CXFA_Document* doc, XFA_PacketType packet)
@@ -49,10 +48,9 @@
                 XFA_Element::Para,
                 kParaPropertyData,
                 kParaAttributeData,
-                kParaName,
                 pdfium::MakeUnique<CJX_Para>(this)) {}
 
-CXFA_Para::~CXFA_Para() {}
+CXFA_Para::~CXFA_Para() = default;
 
 XFA_AttributeValue CXFA_Para::GetHorizontalAlign() {
   return JSObject()
diff --git a/xfa/fxfa/parser/cxfa_part.cpp b/xfa/fxfa/parser/cxfa_part.cpp
index e725845..e4aa06d 100644
--- a/xfa/fxfa/parser/cxfa_part.cpp
+++ b/xfa/fxfa/parser/cxfa_part.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kPartName[] = L"part";
-
 }  // namespace
 
 CXFA_Part::CXFA_Part(CXFA_Document* doc, XFA_PacketType packet)
@@ -24,7 +22,6 @@
                 XFA_ObjectType::ContentNode,
                 XFA_Element::Part,
                 nullptr,
-                kPartAttributeData,
-                kPartName) {}
+                kPartAttributeData) {}
 
-CXFA_Part::~CXFA_Part() {}
+CXFA_Part::~CXFA_Part() = default;
diff --git a/xfa/fxfa/parser/cxfa_password.cpp b/xfa/fxfa/parser/cxfa_password.cpp
index d1145e4..2197623 100644
--- a/xfa/fxfa/parser/cxfa_password.cpp
+++ b/xfa/fxfa/parser/cxfa_password.cpp
@@ -18,8 +18,6 @@
     {XFA_Attribute::Usehref, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kPasswordName[] = L"password";
-
 }  // namespace
 
 CXFA_Password::CXFA_Password(CXFA_Document* doc, XFA_PacketType packet)
@@ -30,7 +28,6 @@
                 XFA_Element::Password,
                 nullptr,
                 kPasswordAttributeData,
-                kPasswordName,
                 pdfium::MakeUnique<CJX_Password>(this)) {}
 
-CXFA_Password::~CXFA_Password() {}
+CXFA_Password::~CXFA_Password() = default;
diff --git a/xfa/fxfa/parser/cxfa_passwordedit.cpp b/xfa/fxfa/parser/cxfa_passwordedit.cpp
index 35612f6..475cc16 100644
--- a/xfa/fxfa/parser/cxfa_passwordedit.cpp
+++ b/xfa/fxfa/parser/cxfa_passwordedit.cpp
@@ -15,6 +15,7 @@
     {XFA_Element::Border, 1, 0},
     {XFA_Element::Extras, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kPasswordEditAttributeData[] = {
     {XFA_Attribute::Id, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Use, XFA_AttributeType::CData, nullptr},
@@ -24,8 +25,6 @@
      (void*)XFA_AttributeValue::Auto},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kPasswordEditName[] = L"passwordEdit";
-
 }  // namespace
 
 CXFA_PasswordEdit::CXFA_PasswordEdit(CXFA_Document* doc, XFA_PacketType packet)
@@ -35,10 +34,9 @@
                 XFA_ObjectType::Node,
                 XFA_Element::PasswordEdit,
                 kPasswordEditPropertyData,
-                kPasswordEditAttributeData,
-                kPasswordEditName) {}
+                kPasswordEditAttributeData) {}
 
-CXFA_PasswordEdit::~CXFA_PasswordEdit() {}
+CXFA_PasswordEdit::~CXFA_PasswordEdit() = default;
 
 XFA_FFWidgetType CXFA_PasswordEdit::GetDefaultFFWidgetType() const {
   return XFA_FFWidgetType::kPasswordEdit;
diff --git a/xfa/fxfa/parser/cxfa_pattern.cpp b/xfa/fxfa/parser/cxfa_pattern.cpp
index f5c2e78..9b0a995 100644
--- a/xfa/fxfa/parser/cxfa_pattern.cpp
+++ b/xfa/fxfa/parser/cxfa_pattern.cpp
@@ -17,6 +17,7 @@
     {XFA_Element::Color, 1, 0},
     {XFA_Element::Extras, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kPatternAttributeData[] = {
     {XFA_Attribute::Id, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Use, XFA_AttributeType::CData, nullptr},
@@ -25,8 +26,6 @@
     {XFA_Attribute::Usehref, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kPatternName[] = L"pattern";
-
 }  // namespace
 
 CXFA_Pattern::CXFA_Pattern(CXFA_Document* doc, XFA_PacketType packet)
@@ -37,10 +36,9 @@
                 XFA_Element::Pattern,
                 kPatternPropertyData,
                 kPatternAttributeData,
-                kPatternName,
                 pdfium::MakeUnique<CJX_Pattern>(this)) {}
 
-CXFA_Pattern::~CXFA_Pattern() {}
+CXFA_Pattern::~CXFA_Pattern() = default;
 
 CXFA_Color* CXFA_Pattern::GetColorIfExists() {
   return GetChild<CXFA_Color>(0, XFA_Element::Color, false);
diff --git a/xfa/fxfa/parser/cxfa_pcl.cpp b/xfa/fxfa/parser/cxfa_pcl.cpp
index 00b68e8..c3fbb1b 100644
--- a/xfa/fxfa/parser/cxfa_pcl.cpp
+++ b/xfa/fxfa/parser/cxfa_pcl.cpp
@@ -14,14 +14,13 @@
     {XFA_Element::PageOffset, 1, 0}, {XFA_Element::OutputBin, 1, 0},
     {XFA_Element::Staple, 1, 0},     {XFA_Element::MediumInfo, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kPclAttributeData[] = {
     {XFA_Attribute::Name, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Desc, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kPclName[] = L"pcl";
-
 }  // namespace
 
 CXFA_Pcl::CXFA_Pcl(CXFA_Document* doc, XFA_PacketType packet)
@@ -31,7 +30,6 @@
                 XFA_ObjectType::Node,
                 XFA_Element::Pcl,
                 kPclPropertyData,
-                kPclAttributeData,
-                kPclName) {}
+                kPclAttributeData) {}
 
-CXFA_Pcl::~CXFA_Pcl() {}
+CXFA_Pcl::~CXFA_Pcl() = default;
diff --git a/xfa/fxfa/parser/cxfa_pdf.cpp b/xfa/fxfa/parser/cxfa_pdf.cpp
index 5a257bd..96a22c6 100644
--- a/xfa/fxfa/parser/cxfa_pdf.cpp
+++ b/xfa/fxfa/parser/cxfa_pdf.cpp
@@ -29,14 +29,13 @@
     {XFA_Element::Linearized, 1, 0},
     {XFA_Element::Tagged, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kPdfAttributeData[] = {
     {XFA_Attribute::Name, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Desc, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kPdfName[] = L"pdf";
-
 }  // namespace
 
 CXFA_Pdf::CXFA_Pdf(CXFA_Document* doc, XFA_PacketType packet)
@@ -46,7 +45,6 @@
                 XFA_ObjectType::Node,
                 XFA_Element::Pdf,
                 kPdfPropertyData,
-                kPdfAttributeData,
-                kPdfName) {}
+                kPdfAttributeData) {}
 
-CXFA_Pdf::~CXFA_Pdf() {}
+CXFA_Pdf::~CXFA_Pdf() = default;
diff --git a/xfa/fxfa/parser/cxfa_pdfa.cpp b/xfa/fxfa/parser/cxfa_pdfa.cpp
index b954488..d41417d 100644
--- a/xfa/fxfa/parser/cxfa_pdfa.cpp
+++ b/xfa/fxfa/parser/cxfa_pdfa.cpp
@@ -14,13 +14,12 @@
     {XFA_Element::IncludeXDPContent, 1, 0},
     {XFA_Element::Conformance, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kPdfaAttributeData[] = {
     {XFA_Attribute::Desc, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kPdfaName[] = L"pdfa";
-
 }  // namespace
 
 CXFA_Pdfa::CXFA_Pdfa(CXFA_Document* doc, XFA_PacketType packet)
@@ -30,7 +29,6 @@
                 XFA_ObjectType::Node,
                 XFA_Element::Pdfa,
                 kPdfaPropertyData,
-                kPdfaAttributeData,
-                kPdfaName) {}
+                kPdfaAttributeData) {}
 
-CXFA_Pdfa::~CXFA_Pdfa() {}
+CXFA_Pdfa::~CXFA_Pdfa() = default;
diff --git a/xfa/fxfa/parser/cxfa_permissions.cpp b/xfa/fxfa/parser/cxfa_permissions.cpp
index 3ae215c..499a0d7 100644
--- a/xfa/fxfa/parser/cxfa_permissions.cpp
+++ b/xfa/fxfa/parser/cxfa_permissions.cpp
@@ -19,13 +19,12 @@
     {XFA_Element::PrintHighQuality, 1, 0},
     {XFA_Element::DocumentAssembly, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kPermissionsAttributeData[] = {
     {XFA_Attribute::Desc, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kPermissionsName[] = L"permissions";
-
 }  // namespace
 
 CXFA_Permissions::CXFA_Permissions(CXFA_Document* doc, XFA_PacketType packet)
@@ -35,7 +34,6 @@
                 XFA_ObjectType::Node,
                 XFA_Element::Permissions,
                 kPermissionsPropertyData,
-                kPermissionsAttributeData,
-                kPermissionsName) {}
+                kPermissionsAttributeData) {}
 
-CXFA_Permissions::~CXFA_Permissions() {}
+CXFA_Permissions::~CXFA_Permissions() = default;
diff --git a/xfa/fxfa/parser/cxfa_picktraybypdfsize.cpp b/xfa/fxfa/parser/cxfa_picktraybypdfsize.cpp
index a2e58c2..c536b1d 100644
--- a/xfa/fxfa/parser/cxfa_picktraybypdfsize.cpp
+++ b/xfa/fxfa/parser/cxfa_picktraybypdfsize.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kPickTrayByPDFSizeName[] = L"pickTrayByPDFSize";
-
 }  // namespace
 
 CXFA_PickTrayByPDFSize::CXFA_PickTrayByPDFSize(CXFA_Document* doc,
@@ -25,7 +23,6 @@
                 XFA_ObjectType::ContentNode,
                 XFA_Element::PickTrayByPDFSize,
                 nullptr,
-                kPickTrayByPDFSizeAttributeData,
-                kPickTrayByPDFSizeName) {}
+                kPickTrayByPDFSizeAttributeData) {}
 
-CXFA_PickTrayByPDFSize::~CXFA_PickTrayByPDFSize() {}
+CXFA_PickTrayByPDFSize::~CXFA_PickTrayByPDFSize() = default;
diff --git a/xfa/fxfa/parser/cxfa_picture.cpp b/xfa/fxfa/parser/cxfa_picture.cpp
index 8b366d9..c1099e9 100644
--- a/xfa/fxfa/parser/cxfa_picture.cpp
+++ b/xfa/fxfa/parser/cxfa_picture.cpp
@@ -19,8 +19,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kPictureName[] = L"picture";
-
 }  // namespace
 
 CXFA_Picture::CXFA_Picture(CXFA_Document* doc, XFA_PacketType packet)
@@ -32,7 +30,6 @@
           XFA_Element::Picture,
           nullptr,
           kPictureAttributeData,
-          kPictureName,
           pdfium::MakeUnique<CJX_Picture>(this)) {}
 
-CXFA_Picture::~CXFA_Picture() {}
+CXFA_Picture::~CXFA_Picture() = default;
diff --git a/xfa/fxfa/parser/cxfa_plaintextmetadata.cpp b/xfa/fxfa/parser/cxfa_plaintextmetadata.cpp
index 723499c..71e7c76 100644
--- a/xfa/fxfa/parser/cxfa_plaintextmetadata.cpp
+++ b/xfa/fxfa/parser/cxfa_plaintextmetadata.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kPlaintextMetadataName[] = L"plaintextMetadata";
-
 }  // namespace
 
 CXFA_PlaintextMetadata::CXFA_PlaintextMetadata(CXFA_Document* doc,
@@ -25,7 +23,6 @@
                 XFA_ObjectType::ContentNode,
                 XFA_Element::PlaintextMetadata,
                 nullptr,
-                kPlaintextMetadataAttributeData,
-                kPlaintextMetadataName) {}
+                kPlaintextMetadataAttributeData) {}
 
-CXFA_PlaintextMetadata::~CXFA_PlaintextMetadata() {}
+CXFA_PlaintextMetadata::~CXFA_PlaintextMetadata() = default;
diff --git a/xfa/fxfa/parser/cxfa_presence.cpp b/xfa/fxfa/parser/cxfa_presence.cpp
index e37a7aa..66bc8fa 100644
--- a/xfa/fxfa/parser/cxfa_presence.cpp
+++ b/xfa/fxfa/parser/cxfa_presence.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kPresenceName[] = L"presence";
-
 }  // namespace
 
 CXFA_Presence::CXFA_Presence(CXFA_Document* doc, XFA_PacketType packet)
@@ -24,7 +22,6 @@
                 XFA_ObjectType::NodeV,
                 XFA_Element::Presence,
                 nullptr,
-                kPresenceAttributeData,
-                kPresenceName) {}
+                kPresenceAttributeData) {}
 
-CXFA_Presence::~CXFA_Presence() {}
+CXFA_Presence::~CXFA_Presence() = default;
diff --git a/xfa/fxfa/parser/cxfa_present.cpp b/xfa/fxfa/parser/cxfa_present.cpp
index 9eebbbf..21fed2a 100644
--- a/xfa/fxfa/parser/cxfa_present.cpp
+++ b/xfa/fxfa/parser/cxfa_present.cpp
@@ -24,13 +24,12 @@
     {XFA_Element::Destination, 1, 0},
     {XFA_Element::IncrementalMerge, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kPresentAttributeData[] = {
     {XFA_Attribute::Desc, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kPresentName[] = L"present";
-
 }  // namespace
 
 CXFA_Present::CXFA_Present(CXFA_Document* doc, XFA_PacketType packet)
@@ -40,7 +39,6 @@
                 XFA_ObjectType::Node,
                 XFA_Element::Present,
                 kPresentPropertyData,
-                kPresentAttributeData,
-                kPresentName) {}
+                kPresentAttributeData) {}
 
-CXFA_Present::~CXFA_Present() {}
+CXFA_Present::~CXFA_Present() = default;
diff --git a/xfa/fxfa/parser/cxfa_print.cpp b/xfa/fxfa/parser/cxfa_print.cpp
index cf09ccd..b99485e 100644
--- a/xfa/fxfa/parser/cxfa_print.cpp
+++ b/xfa/fxfa/parser/cxfa_print.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kPrintName[] = L"print";
-
 }  // namespace
 
 CXFA_Print::CXFA_Print(CXFA_Document* doc, XFA_PacketType packet)
@@ -24,7 +22,6 @@
                 XFA_ObjectType::ContentNode,
                 XFA_Element::Print,
                 nullptr,
-                kPrintAttributeData,
-                kPrintName) {}
+                kPrintAttributeData) {}
 
-CXFA_Print::~CXFA_Print() {}
+CXFA_Print::~CXFA_Print() = default;
diff --git a/xfa/fxfa/parser/cxfa_printername.cpp b/xfa/fxfa/parser/cxfa_printername.cpp
index 6acda51..2f0a7d9 100644
--- a/xfa/fxfa/parser/cxfa_printername.cpp
+++ b/xfa/fxfa/parser/cxfa_printername.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kPrinterNameName[] = L"printerName";
-
 }  // namespace
 
 CXFA_PrinterName::CXFA_PrinterName(CXFA_Document* doc, XFA_PacketType packet)
@@ -24,7 +22,6 @@
                 XFA_ObjectType::ContentNode,
                 XFA_Element::PrinterName,
                 nullptr,
-                kPrinterNameAttributeData,
-                kPrinterNameName) {}
+                kPrinterNameAttributeData) {}
 
-CXFA_PrinterName::~CXFA_PrinterName() {}
+CXFA_PrinterName::~CXFA_PrinterName() = default;
diff --git a/xfa/fxfa/parser/cxfa_printhighquality.cpp b/xfa/fxfa/parser/cxfa_printhighquality.cpp
index c88767d..f7a1c7e 100644
--- a/xfa/fxfa/parser/cxfa_printhighquality.cpp
+++ b/xfa/fxfa/parser/cxfa_printhighquality.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kPrintHighQualityName[] = L"printHighQuality";
-
 }  // namespace
 
 CXFA_PrintHighQuality::CXFA_PrintHighQuality(CXFA_Document* doc,
@@ -25,7 +23,6 @@
                 XFA_ObjectType::ContentNode,
                 XFA_Element::PrintHighQuality,
                 nullptr,
-                kPrintHighQualityAttributeData,
-                kPrintHighQualityName) {}
+                kPrintHighQualityAttributeData) {}
 
-CXFA_PrintHighQuality::~CXFA_PrintHighQuality() {}
+CXFA_PrintHighQuality::~CXFA_PrintHighQuality() = default;
diff --git a/xfa/fxfa/parser/cxfa_printscaling.cpp b/xfa/fxfa/parser/cxfa_printscaling.cpp
index a995eda..583701e 100644
--- a/xfa/fxfa/parser/cxfa_printscaling.cpp
+++ b/xfa/fxfa/parser/cxfa_printscaling.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kPrintScalingName[] = L"printScaling";
-
 }  // namespace
 
 CXFA_PrintScaling::CXFA_PrintScaling(CXFA_Document* doc, XFA_PacketType packet)
@@ -24,7 +22,6 @@
                 XFA_ObjectType::ContentNode,
                 XFA_Element::PrintScaling,
                 nullptr,
-                kPrintScalingAttributeData,
-                kPrintScalingName) {}
+                kPrintScalingAttributeData) {}
 
-CXFA_PrintScaling::~CXFA_PrintScaling() {}
+CXFA_PrintScaling::~CXFA_PrintScaling() = default;
diff --git a/xfa/fxfa/parser/cxfa_producer.cpp b/xfa/fxfa/parser/cxfa_producer.cpp
index 0bdbbcf..8735e2a 100644
--- a/xfa/fxfa/parser/cxfa_producer.cpp
+++ b/xfa/fxfa/parser/cxfa_producer.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kProducerName[] = L"producer";
-
 }  // namespace
 
 CXFA_Producer::CXFA_Producer(CXFA_Document* doc, XFA_PacketType packet)
@@ -24,7 +22,6 @@
                 XFA_ObjectType::ContentNode,
                 XFA_Element::Producer,
                 nullptr,
-                kProducerAttributeData,
-                kProducerName) {}
+                kProducerAttributeData) {}
 
-CXFA_Producer::~CXFA_Producer() {}
+CXFA_Producer::~CXFA_Producer() = default;
diff --git a/xfa/fxfa/parser/cxfa_proto.cpp b/xfa/fxfa/parser/cxfa_proto.cpp
index eb98047..40c8fff 100644
--- a/xfa/fxfa/parser/cxfa_proto.cpp
+++ b/xfa/fxfa/parser/cxfa_proto.cpp
@@ -6,12 +6,6 @@
 
 #include "xfa/fxfa/parser/cxfa_proto.h"
 
-namespace {
-
-constexpr wchar_t kProtoName[] = L"proto";
-
-}  // namespace
-
 CXFA_Proto::CXFA_Proto(CXFA_Document* doc, XFA_PacketType packet)
     : CXFA_Node(doc,
                 packet,
@@ -19,7 +13,6 @@
                 XFA_ObjectType::Node,
                 XFA_Element::Proto,
                 nullptr,
-                nullptr,
-                kProtoName) {}
+                nullptr) {}
 
-CXFA_Proto::~CXFA_Proto() {}
+CXFA_Proto::~CXFA_Proto() = default;
diff --git a/xfa/fxfa/parser/cxfa_ps.cpp b/xfa/fxfa/parser/cxfa_ps.cpp
index e4408a1..0f10b90 100644
--- a/xfa/fxfa/parser/cxfa_ps.cpp
+++ b/xfa/fxfa/parser/cxfa_ps.cpp
@@ -14,14 +14,13 @@
     {XFA_Element::OutputBin, 1, 0}, {XFA_Element::Compress, 1, 0},
     {XFA_Element::Staple, 1, 0},    {XFA_Element::MediumInfo, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kPsAttributeData[] = {
     {XFA_Attribute::Name, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Desc, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kPsName[] = L"ps";
-
 }  // namespace
 
 CXFA_Ps::CXFA_Ps(CXFA_Document* doc, XFA_PacketType packet)
@@ -31,7 +30,6 @@
                 XFA_ObjectType::Node,
                 XFA_Element::Ps,
                 kPsPropertyData,
-                kPsAttributeData,
-                kPsName) {}
+                kPsAttributeData) {}
 
-CXFA_Ps::~CXFA_Ps() {}
+CXFA_Ps::~CXFA_Ps() = default;
diff --git a/xfa/fxfa/parser/cxfa_psmap.cpp b/xfa/fxfa/parser/cxfa_psmap.cpp
index 9421432..d83c534 100644
--- a/xfa/fxfa/parser/cxfa_psmap.cpp
+++ b/xfa/fxfa/parser/cxfa_psmap.cpp
@@ -6,12 +6,6 @@
 
 #include "xfa/fxfa/parser/cxfa_psmap.h"
 
-namespace {
-
-constexpr wchar_t kPsMapName[] = L"psMap";
-
-}  // namespace
-
 CXFA_PsMap::CXFA_PsMap(CXFA_Document* doc, XFA_PacketType packet)
     : CXFA_Node(doc,
                 packet,
@@ -19,7 +13,6 @@
                 XFA_ObjectType::Node,
                 XFA_Element::PsMap,
                 nullptr,
-                nullptr,
-                kPsMapName) {}
+                nullptr) {}
 
-CXFA_PsMap::~CXFA_PsMap() {}
+CXFA_PsMap::~CXFA_PsMap() = default;
diff --git a/xfa/fxfa/parser/cxfa_query.cpp b/xfa/fxfa/parser/cxfa_query.cpp
index dd0c617..3f6444b 100644
--- a/xfa/fxfa/parser/cxfa_query.cpp
+++ b/xfa/fxfa/parser/cxfa_query.cpp
@@ -15,6 +15,7 @@
     {XFA_Element::RecordSet, 1, 0},
     {XFA_Element::Select, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kQueryAttributeData[] = {
     {XFA_Attribute::Id, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Name, XFA_AttributeType::CData, nullptr},
@@ -24,8 +25,6 @@
     {XFA_Attribute::Usehref, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kQueryName[] = L"query";
-
 }  // namespace
 
 CXFA_Query::CXFA_Query(CXFA_Document* doc, XFA_PacketType packet)
@@ -36,7 +35,6 @@
                 XFA_Element::Query,
                 kQueryPropertyData,
                 kQueryAttributeData,
-                kQueryName,
                 pdfium::MakeUnique<CJX_Query>(this)) {}
 
-CXFA_Query::~CXFA_Query() {}
+CXFA_Query::~CXFA_Query() = default;
diff --git a/xfa/fxfa/parser/cxfa_radial.cpp b/xfa/fxfa/parser/cxfa_radial.cpp
index 0543b07..c85beb8 100644
--- a/xfa/fxfa/parser/cxfa_radial.cpp
+++ b/xfa/fxfa/parser/cxfa_radial.cpp
@@ -19,6 +19,7 @@
     {XFA_Element::Color, 1, 0},
     {XFA_Element::Extras, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kRadialAttributeData[] = {
     {XFA_Attribute::Id, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Use, XFA_AttributeType::CData, nullptr},
@@ -27,8 +28,6 @@
     {XFA_Attribute::Usehref, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kRadialName[] = L"radial";
-
 }  // namespace
 
 CXFA_Radial::CXFA_Radial(CXFA_Document* doc, XFA_PacketType packet)
@@ -39,10 +38,9 @@
                 XFA_Element::Radial,
                 kRadialPropertyData,
                 kRadialAttributeData,
-                kRadialName,
                 pdfium::MakeUnique<CJX_Radial>(this)) {}
 
-CXFA_Radial::~CXFA_Radial() {}
+CXFA_Radial::~CXFA_Radial() = default;
 
 bool CXFA_Radial::IsToEdge() {
   return JSObject()
diff --git a/xfa/fxfa/parser/cxfa_range.cpp b/xfa/fxfa/parser/cxfa_range.cpp
index 9dec94e..76b3fc2 100644
--- a/xfa/fxfa/parser/cxfa_range.cpp
+++ b/xfa/fxfa/parser/cxfa_range.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kRangeName[] = L"range";
-
 }  // namespace
 
 CXFA_Range::CXFA_Range(CXFA_Document* doc, XFA_PacketType packet)
@@ -24,7 +22,6 @@
                 XFA_ObjectType::NodeV,
                 XFA_Element::Range,
                 nullptr,
-                kRangeAttributeData,
-                kRangeName) {}
+                kRangeAttributeData) {}
 
-CXFA_Range::~CXFA_Range() {}
+CXFA_Range::~CXFA_Range() = default;
diff --git a/xfa/fxfa/parser/cxfa_reason.cpp b/xfa/fxfa/parser/cxfa_reason.cpp
index 6578f7d..4551f7c 100644
--- a/xfa/fxfa/parser/cxfa_reason.cpp
+++ b/xfa/fxfa/parser/cxfa_reason.cpp
@@ -18,8 +18,6 @@
     {XFA_Attribute::Usehref, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kReasonName[] = L"reason";
-
 }  // namespace
 
 CXFA_Reason::CXFA_Reason(CXFA_Document* doc, XFA_PacketType packet)
@@ -30,7 +28,6 @@
                 XFA_Element::Reason,
                 nullptr,
                 kReasonAttributeData,
-                kReasonName,
                 pdfium::MakeUnique<CJX_Reason>(this)) {}
 
-CXFA_Reason::~CXFA_Reason() {}
+CXFA_Reason::~CXFA_Reason() = default;
diff --git a/xfa/fxfa/parser/cxfa_reasons.cpp b/xfa/fxfa/parser/cxfa_reasons.cpp
index 63ca32b..67c7516 100644
--- a/xfa/fxfa/parser/cxfa_reasons.cpp
+++ b/xfa/fxfa/parser/cxfa_reasons.cpp
@@ -19,8 +19,6 @@
     {XFA_Attribute::Usehref, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kReasonsName[] = L"reasons";
-
 }  // namespace
 
 CXFA_Reasons::CXFA_Reasons(CXFA_Document* doc, XFA_PacketType packet)
@@ -31,7 +29,6 @@
                 XFA_Element::Reasons,
                 nullptr,
                 kReasonsAttributeData,
-                kReasonsName,
                 pdfium::MakeUnique<CJX_Reasons>(this)) {}
 
-CXFA_Reasons::~CXFA_Reasons() {}
+CXFA_Reasons::~CXFA_Reasons() = default;
diff --git a/xfa/fxfa/parser/cxfa_record.cpp b/xfa/fxfa/parser/cxfa_record.cpp
index af09f8a..75a8daf 100644
--- a/xfa/fxfa/parser/cxfa_record.cpp
+++ b/xfa/fxfa/parser/cxfa_record.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kRecordName[] = L"record";
-
 }  // namespace
 
 CXFA_Record::CXFA_Record(CXFA_Document* doc, XFA_PacketType packet)
@@ -24,7 +22,6 @@
                 XFA_ObjectType::NodeV,
                 XFA_Element::Record,
                 nullptr,
-                kRecordAttributeData,
-                kRecordName) {}
+                kRecordAttributeData) {}
 
-CXFA_Record::~CXFA_Record() {}
+CXFA_Record::~CXFA_Record() = default;
diff --git a/xfa/fxfa/parser/cxfa_recordset.cpp b/xfa/fxfa/parser/cxfa_recordset.cpp
index a16af23..7a5cbec 100644
--- a/xfa/fxfa/parser/cxfa_recordset.cpp
+++ b/xfa/fxfa/parser/cxfa_recordset.cpp
@@ -29,8 +29,6 @@
      (void*)XFA_AttributeValue::Client},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kRecordSetName[] = L"recordSet";
-
 }  // namespace
 
 CXFA_RecordSet::CXFA_RecordSet(CXFA_Document* doc, XFA_PacketType packet)
@@ -41,7 +39,6 @@
                 XFA_Element::RecordSet,
                 nullptr,
                 kRecordSetAttributeData,
-                kRecordSetName,
                 pdfium::MakeUnique<CJX_RecordSet>(this)) {}
 
-CXFA_RecordSet::~CXFA_RecordSet() {}
+CXFA_RecordSet::~CXFA_RecordSet() = default;
diff --git a/xfa/fxfa/parser/cxfa_rectangle.cpp b/xfa/fxfa/parser/cxfa_rectangle.cpp
index 7f07097..93bae1e 100644
--- a/xfa/fxfa/parser/cxfa_rectangle.cpp
+++ b/xfa/fxfa/parser/cxfa_rectangle.cpp
@@ -20,6 +20,7 @@
     {XFA_Element::Corner, 4, 0},
     {XFA_Element::Fill, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kRectangleAttributeData[] = {
     {XFA_Attribute::Id, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Use, XFA_AttributeType::CData, nullptr},
@@ -28,8 +29,6 @@
      (void*)XFA_AttributeValue::Even},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kRectangleName[] = L"rectangle";
-
 }  // namespace
 
 CXFA_Rectangle::CXFA_Rectangle(CXFA_Document* doc, XFA_PacketType packet)
@@ -40,7 +39,6 @@
                XFA_Element::Rectangle,
                kRectanglePropertyData,
                kRectangleAttributeData,
-               kRectangleName,
                pdfium::MakeUnique<CJX_Rectangle>(this)) {}
 
 CXFA_Rectangle::CXFA_Rectangle(CXFA_Document* pDoc,
@@ -50,7 +48,6 @@
                                XFA_Element eType,
                                const PropertyData* properties,
                                const AttributeData* attributes,
-                               const WideStringView& elementName,
                                std::unique_ptr<CJX_Object> js_node)
     : CXFA_Box(pDoc,
                ePacket,
@@ -59,7 +56,6 @@
                eType,
                properties,
                attributes,
-               elementName,
                std::move(js_node)) {}
 
 CXFA_Rectangle::~CXFA_Rectangle() {}
diff --git a/xfa/fxfa/parser/cxfa_rectangle.h b/xfa/fxfa/parser/cxfa_rectangle.h
index b117e66..e2405a0 100644
--- a/xfa/fxfa/parser/cxfa_rectangle.h
+++ b/xfa/fxfa/parser/cxfa_rectangle.h
@@ -34,7 +34,6 @@
                  XFA_Element eType,
                  const PropertyData* properties,
                  const AttributeData* attributes,
-                 const WideStringView& elementName,
                  std::unique_ptr<CJX_Object> js_node);
 
  private:
diff --git a/xfa/fxfa/parser/cxfa_ref.cpp b/xfa/fxfa/parser/cxfa_ref.cpp
index 951c830..adb4c81 100644
--- a/xfa/fxfa/parser/cxfa_ref.cpp
+++ b/xfa/fxfa/parser/cxfa_ref.cpp
@@ -17,8 +17,6 @@
     {XFA_Attribute::Usehref, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kRefName[] = L"ref";
-
 }  // namespace
 
 CXFA_Ref::CXFA_Ref(CXFA_Document* doc, XFA_PacketType packet)
@@ -29,7 +27,6 @@
                 XFA_Element::Ref,
                 nullptr,
                 kRefAttributeData,
-                kRefName,
                 pdfium::MakeUnique<CJX_Ref>(this)) {}
 
-CXFA_Ref::~CXFA_Ref() {}
+CXFA_Ref::~CXFA_Ref() = default;
diff --git a/xfa/fxfa/parser/cxfa_relevant.cpp b/xfa/fxfa/parser/cxfa_relevant.cpp
index 95f907a..9894244 100644
--- a/xfa/fxfa/parser/cxfa_relevant.cpp
+++ b/xfa/fxfa/parser/cxfa_relevant.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kRelevantName[] = L"relevant";
-
 }  // namespace
 
 CXFA_Relevant::CXFA_Relevant(CXFA_Document* doc, XFA_PacketType packet)
@@ -24,7 +22,6 @@
                 XFA_ObjectType::NodeV,
                 XFA_Element::Relevant,
                 nullptr,
-                kRelevantAttributeData,
-                kRelevantName) {}
+                kRelevantAttributeData) {}
 
-CXFA_Relevant::~CXFA_Relevant() {}
+CXFA_Relevant::~CXFA_Relevant() = default;
diff --git a/xfa/fxfa/parser/cxfa_rename.cpp b/xfa/fxfa/parser/cxfa_rename.cpp
index 32a6e0d..bd133a7 100644
--- a/xfa/fxfa/parser/cxfa_rename.cpp
+++ b/xfa/fxfa/parser/cxfa_rename.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kRenameName[] = L"rename";
-
 }  // namespace
 
 CXFA_Rename::CXFA_Rename(CXFA_Document* doc, XFA_PacketType packet)
@@ -24,7 +22,6 @@
                 XFA_ObjectType::NodeV,
                 XFA_Element::Rename,
                 nullptr,
-                kRenameAttributeData,
-                kRenameName) {}
+                kRenameAttributeData) {}
 
-CXFA_Rename::~CXFA_Rename() {}
+CXFA_Rename::~CXFA_Rename() = default;
diff --git a/xfa/fxfa/parser/cxfa_renderpolicy.cpp b/xfa/fxfa/parser/cxfa_renderpolicy.cpp
index 19c1302..50d9bfa 100644
--- a/xfa/fxfa/parser/cxfa_renderpolicy.cpp
+++ b/xfa/fxfa/parser/cxfa_renderpolicy.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kRenderPolicyName[] = L"renderPolicy";
-
 }  // namespace
 
 CXFA_RenderPolicy::CXFA_RenderPolicy(CXFA_Document* doc, XFA_PacketType packet)
@@ -24,7 +22,6 @@
                 XFA_ObjectType::ContentNode,
                 XFA_Element::RenderPolicy,
                 nullptr,
-                kRenderPolicyAttributeData,
-                kRenderPolicyName) {}
+                kRenderPolicyAttributeData) {}
 
-CXFA_RenderPolicy::~CXFA_RenderPolicy() {}
+CXFA_RenderPolicy::~CXFA_RenderPolicy() = default;
diff --git a/xfa/fxfa/parser/cxfa_rootelement.cpp b/xfa/fxfa/parser/cxfa_rootelement.cpp
index 031f8b0..451f065 100644
--- a/xfa/fxfa/parser/cxfa_rootelement.cpp
+++ b/xfa/fxfa/parser/cxfa_rootelement.cpp
@@ -18,8 +18,6 @@
     {XFA_Attribute::Usehref, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kRootElementName[] = L"rootElement";
-
 }  // namespace
 
 CXFA_RootElement::CXFA_RootElement(CXFA_Document* doc, XFA_PacketType packet)
@@ -30,7 +28,6 @@
                 XFA_Element::RootElement,
                 nullptr,
                 kRootElementAttributeData,
-                kRootElementName,
                 pdfium::MakeUnique<CJX_RootElement>(this)) {}
 
-CXFA_RootElement::~CXFA_RootElement() {}
+CXFA_RootElement::~CXFA_RootElement() = default;
diff --git a/xfa/fxfa/parser/cxfa_runscripts.cpp b/xfa/fxfa/parser/cxfa_runscripts.cpp
index 204bdeb..7f25513 100644
--- a/xfa/fxfa/parser/cxfa_runscripts.cpp
+++ b/xfa/fxfa/parser/cxfa_runscripts.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kRunScriptsName[] = L"runScripts";
-
 }  // namespace
 
 CXFA_RunScripts::CXFA_RunScripts(CXFA_Document* doc, XFA_PacketType packet)
@@ -24,7 +22,6 @@
                 XFA_ObjectType::ContentNode,
                 XFA_Element::RunScripts,
                 nullptr,
-                kRunScriptsAttributeData,
-                kRunScriptsName) {}
+                kRunScriptsAttributeData) {}
 
-CXFA_RunScripts::~CXFA_RunScripts() {}
+CXFA_RunScripts::~CXFA_RunScripts() = default;
diff --git a/xfa/fxfa/parser/cxfa_script.cpp b/xfa/fxfa/parser/cxfa_script.cpp
index 3f40c36..e24741d 100644
--- a/xfa/fxfa/parser/cxfa_script.cpp
+++ b/xfa/fxfa/parser/cxfa_script.cpp
@@ -16,6 +16,7 @@
     {XFA_Element::CurrentPage, 1, 0},
     {XFA_Element::RunScripts, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kScriptAttributeData[] = {
     {XFA_Attribute::Id, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Name, XFA_AttributeType::CData, nullptr},
@@ -29,8 +30,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kScriptName[] = L"script";
-
 }  // namespace
 
 CXFA_Script::CXFA_Script(CXFA_Document* doc, XFA_PacketType packet)
@@ -42,10 +41,9 @@
           XFA_Element::Script,
           kScriptPropertyData,
           kScriptAttributeData,
-          kScriptName,
           pdfium::MakeUnique<CJX_Script>(this)) {}
 
-CXFA_Script::~CXFA_Script() {}
+CXFA_Script::~CXFA_Script() = default;
 
 CXFA_Script::Type CXFA_Script::GetContentType() {
   Optional<WideString> cData =
diff --git a/xfa/fxfa/parser/cxfa_scriptmodel.cpp b/xfa/fxfa/parser/cxfa_scriptmodel.cpp
index e52db25..5109541 100644
--- a/xfa/fxfa/parser/cxfa_scriptmodel.cpp
+++ b/xfa/fxfa/parser/cxfa_scriptmodel.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kScriptModelName[] = L"scriptModel";
-
 }  // namespace
 
 CXFA_ScriptModel::CXFA_ScriptModel(CXFA_Document* doc, XFA_PacketType packet)
@@ -24,7 +22,6 @@
                 XFA_ObjectType::ContentNode,
                 XFA_Element::ScriptModel,
                 nullptr,
-                kScriptModelAttributeData,
-                kScriptModelName) {}
+                kScriptModelAttributeData) {}
 
-CXFA_ScriptModel::~CXFA_ScriptModel() {}
+CXFA_ScriptModel::~CXFA_ScriptModel() = default;
diff --git a/xfa/fxfa/parser/cxfa_select.cpp b/xfa/fxfa/parser/cxfa_select.cpp
index 8b8feb8..dcff379 100644
--- a/xfa/fxfa/parser/cxfa_select.cpp
+++ b/xfa/fxfa/parser/cxfa_select.cpp
@@ -18,8 +18,6 @@
     {XFA_Attribute::Usehref, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kSelectName[] = L"select";
-
 }  // namespace
 
 CXFA_Select::CXFA_Select(CXFA_Document* doc, XFA_PacketType packet)
@@ -30,7 +28,6 @@
                 XFA_Element::Select,
                 nullptr,
                 kSelectAttributeData,
-                kSelectName,
                 pdfium::MakeUnique<CJX_Select>(this)) {}
 
-CXFA_Select::~CXFA_Select() {}
+CXFA_Select::~CXFA_Select() = default;
diff --git a/xfa/fxfa/parser/cxfa_setproperty.cpp b/xfa/fxfa/parser/cxfa_setproperty.cpp
index c583869..6a5fc05 100644
--- a/xfa/fxfa/parser/cxfa_setproperty.cpp
+++ b/xfa/fxfa/parser/cxfa_setproperty.cpp
@@ -17,8 +17,6 @@
     {XFA_Attribute::Target, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kSetPropertyName[] = L"setProperty";
-
 }  // namespace
 
 CXFA_SetProperty::CXFA_SetProperty(CXFA_Document* doc, XFA_PacketType packet)
@@ -29,7 +27,6 @@
                 XFA_Element::SetProperty,
                 nullptr,
                 kSetPropertyAttributeData,
-                kSetPropertyName,
                 pdfium::MakeUnique<CJX_SetProperty>(this)) {}
 
-CXFA_SetProperty::~CXFA_SetProperty() {}
+CXFA_SetProperty::~CXFA_SetProperty() = default;
diff --git a/xfa/fxfa/parser/cxfa_severity.cpp b/xfa/fxfa/parser/cxfa_severity.cpp
index d8b85de..8241f65 100644
--- a/xfa/fxfa/parser/cxfa_severity.cpp
+++ b/xfa/fxfa/parser/cxfa_severity.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kSeverityName[] = L"severity";
-
 }  // namespace
 
 CXFA_Severity::CXFA_Severity(CXFA_Document* doc, XFA_PacketType packet)
@@ -24,7 +22,6 @@
                 XFA_ObjectType::NodeV,
                 XFA_Element::Severity,
                 nullptr,
-                kSeverityAttributeData,
-                kSeverityName) {}
+                kSeverityAttributeData) {}
 
-CXFA_Severity::~CXFA_Severity() {}
+CXFA_Severity::~CXFA_Severity() = default;
diff --git a/xfa/fxfa/parser/cxfa_sharptext.cpp b/xfa/fxfa/parser/cxfa_sharptext.cpp
index 077c7ce..61e7499 100644
--- a/xfa/fxfa/parser/cxfa_sharptext.cpp
+++ b/xfa/fxfa/parser/cxfa_sharptext.cpp
@@ -12,8 +12,6 @@
     {XFA_Attribute::Value, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kSharptextName[] = L"#text";
-
 }  // namespace
 
 CXFA_Sharptext::CXFA_Sharptext(CXFA_Document* doc, XFA_PacketType packet)
@@ -25,7 +23,6 @@
                 XFA_ObjectType::NodeV,
                 XFA_Element::Sharptext,
                 nullptr,
-                kSharptextAttributeData,
-                kSharptextName) {}
+                kSharptextAttributeData) {}
 
-CXFA_Sharptext::~CXFA_Sharptext() {}
+CXFA_Sharptext::~CXFA_Sharptext() = default;
diff --git a/xfa/fxfa/parser/cxfa_sharpxhtml.cpp b/xfa/fxfa/parser/cxfa_sharpxhtml.cpp
index eb2d83d..9eaaa2d 100644
--- a/xfa/fxfa/parser/cxfa_sharpxhtml.cpp
+++ b/xfa/fxfa/parser/cxfa_sharpxhtml.cpp
@@ -12,8 +12,6 @@
     {XFA_Attribute::Value, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kSharpxHTMLName[] = L"#xHTML";
-
 }  // namespace
 
 CXFA_SharpxHTML::CXFA_SharpxHTML(CXFA_Document* doc, XFA_PacketType packet)
@@ -25,7 +23,6 @@
                 XFA_ObjectType::NodeV,
                 XFA_Element::SharpxHTML,
                 nullptr,
-                kSharpxHTMLAttributeData,
-                kSharpxHTMLName) {}
+                kSharpxHTMLAttributeData) {}
 
-CXFA_SharpxHTML::~CXFA_SharpxHTML() {}
+CXFA_SharpxHTML::~CXFA_SharpxHTML() = default;
diff --git a/xfa/fxfa/parser/cxfa_sharpxml.cpp b/xfa/fxfa/parser/cxfa_sharpxml.cpp
index 2485795..a953474 100644
--- a/xfa/fxfa/parser/cxfa_sharpxml.cpp
+++ b/xfa/fxfa/parser/cxfa_sharpxml.cpp
@@ -12,8 +12,6 @@
     {XFA_Attribute::Value, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kSharpxmlName[] = L"#xml";
-
 }  // namespace
 
 CXFA_Sharpxml::CXFA_Sharpxml(CXFA_Document* doc, XFA_PacketType packet)
@@ -23,7 +21,6 @@
                 XFA_ObjectType::NodeV,
                 XFA_Element::Sharpxml,
                 nullptr,
-                kSharpxmlAttributeData,
-                kSharpxmlName) {}
+                kSharpxmlAttributeData) {}
 
-CXFA_Sharpxml::~CXFA_Sharpxml() {}
+CXFA_Sharpxml::~CXFA_Sharpxml() = default;
diff --git a/xfa/fxfa/parser/cxfa_signature.cpp b/xfa/fxfa/parser/cxfa_signature.cpp
index 626755a..ce50d61 100644
--- a/xfa/fxfa/parser/cxfa_signature.cpp
+++ b/xfa/fxfa/parser/cxfa_signature.cpp
@@ -15,6 +15,7 @@
     {XFA_Element::Margin, 1, 0}, {XFA_Element::Filter, 1, 0},
     {XFA_Element::Border, 1, 0}, {XFA_Element::Manifest, 1, 0},
     {XFA_Element::Extras, 1, 0}, {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kSignatureAttributeData[] = {
     {XFA_Attribute::Id, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Use, XFA_AttributeType::CData, nullptr},
@@ -23,8 +24,6 @@
     {XFA_Attribute::Usehref, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kSignatureName[] = L"signature";
-
 }  // namespace
 
 CXFA_Signature::CXFA_Signature(CXFA_Document* doc, XFA_PacketType packet)
@@ -35,10 +34,9 @@
                 XFA_Element::Signature,
                 kSignaturePropertyData,
                 kSignatureAttributeData,
-                kSignatureName,
                 pdfium::MakeUnique<CJX_Signature>(this)) {}
 
-CXFA_Signature::~CXFA_Signature() {}
+CXFA_Signature::~CXFA_Signature() = default;
 
 XFA_FFWidgetType CXFA_Signature::GetDefaultFFWidgetType() const {
   return XFA_FFWidgetType::kSignature;
diff --git a/xfa/fxfa/parser/cxfa_signatureproperties.cpp b/xfa/fxfa/parser/cxfa_signatureproperties.cpp
index 0f2ca87..27844e9 100644
--- a/xfa/fxfa/parser/cxfa_signatureproperties.cpp
+++ b/xfa/fxfa/parser/cxfa_signatureproperties.cpp
@@ -16,8 +16,6 @@
     {XFA_Attribute::Usehref, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kSignaturePropertiesName[] = L"signatureProperties";
-
 }  // namespace
 
 CXFA_SignatureProperties::CXFA_SignatureProperties(CXFA_Document* doc,
@@ -29,7 +27,6 @@
                 XFA_Element::SignatureProperties,
                 nullptr,
                 kSignaturePropertiesAttributeData,
-                kSignaturePropertiesName,
                 pdfium::MakeUnique<CJX_SignatureProperties>(this)) {}
 
-CXFA_SignatureProperties::~CXFA_SignatureProperties() {}
+CXFA_SignatureProperties::~CXFA_SignatureProperties() = default;
diff --git a/xfa/fxfa/parser/cxfa_signdata.cpp b/xfa/fxfa/parser/cxfa_signdata.cpp
index 74966d5..183db3d 100644
--- a/xfa/fxfa/parser/cxfa_signdata.cpp
+++ b/xfa/fxfa/parser/cxfa_signdata.cpp
@@ -15,6 +15,7 @@
     {XFA_Element::Filter, 1, 0},
     {XFA_Element::Manifest, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kSignDataAttributeData[] = {
     {XFA_Attribute::Id, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Ref, XFA_AttributeType::CData, nullptr},
@@ -25,8 +26,6 @@
     {XFA_Attribute::Target, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kSignDataName[] = L"signData";
-
 }  // namespace
 
 CXFA_SignData::CXFA_SignData(CXFA_Document* doc, XFA_PacketType packet)
@@ -37,7 +36,6 @@
                 XFA_Element::SignData,
                 kSignDataPropertyData,
                 kSignDataAttributeData,
-                kSignDataName,
                 pdfium::MakeUnique<CJX_SignData>(this)) {}
 
-CXFA_SignData::~CXFA_SignData() {}
+CXFA_SignData::~CXFA_SignData() = default;
diff --git a/xfa/fxfa/parser/cxfa_signing.cpp b/xfa/fxfa/parser/cxfa_signing.cpp
index a4b4df7..a96de6f 100644
--- a/xfa/fxfa/parser/cxfa_signing.cpp
+++ b/xfa/fxfa/parser/cxfa_signing.cpp
@@ -19,8 +19,6 @@
     {XFA_Attribute::Usehref, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kSigningName[] = L"signing";
-
 }  // namespace
 
 CXFA_Signing::CXFA_Signing(CXFA_Document* doc, XFA_PacketType packet)
@@ -31,7 +29,6 @@
                 XFA_Element::Signing,
                 nullptr,
                 kSigningAttributeData,
-                kSigningName,
                 pdfium::MakeUnique<CJX_Signing>(this)) {}
 
-CXFA_Signing::~CXFA_Signing() {}
+CXFA_Signing::~CXFA_Signing() = default;
diff --git a/xfa/fxfa/parser/cxfa_silentprint.cpp b/xfa/fxfa/parser/cxfa_silentprint.cpp
index f7a2e7c..1c41e50 100644
--- a/xfa/fxfa/parser/cxfa_silentprint.cpp
+++ b/xfa/fxfa/parser/cxfa_silentprint.cpp
@@ -12,13 +12,12 @@
     {XFA_Element::AddSilentPrint, 1, 0},
     {XFA_Element::PrinterName, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kSilentPrintAttributeData[] = {
     {XFA_Attribute::Desc, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kSilentPrintName[] = L"silentPrint";
-
 }  // namespace
 
 CXFA_SilentPrint::CXFA_SilentPrint(CXFA_Document* doc, XFA_PacketType packet)
@@ -28,7 +27,6 @@
                 XFA_ObjectType::Node,
                 XFA_Element::SilentPrint,
                 kSilentPrintPropertyData,
-                kSilentPrintAttributeData,
-                kSilentPrintName) {}
+                kSilentPrintAttributeData) {}
 
-CXFA_SilentPrint::~CXFA_SilentPrint() {}
+CXFA_SilentPrint::~CXFA_SilentPrint() = default;
diff --git a/xfa/fxfa/parser/cxfa_soapaction.cpp b/xfa/fxfa/parser/cxfa_soapaction.cpp
index 0ec62e3..a8e8b49 100644
--- a/xfa/fxfa/parser/cxfa_soapaction.cpp
+++ b/xfa/fxfa/parser/cxfa_soapaction.cpp
@@ -18,8 +18,6 @@
     {XFA_Attribute::Usehref, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kSoapActionName[] = L"soapAction";
-
 }  // namespace
 
 CXFA_SoapAction::CXFA_SoapAction(CXFA_Document* doc, XFA_PacketType packet)
@@ -30,7 +28,6 @@
                 XFA_Element::SoapAction,
                 nullptr,
                 kSoapActionAttributeData,
-                kSoapActionName,
                 pdfium::MakeUnique<CJX_SoapAction>(this)) {}
 
-CXFA_SoapAction::~CXFA_SoapAction() {}
+CXFA_SoapAction::~CXFA_SoapAction() = default;
diff --git a/xfa/fxfa/parser/cxfa_soapaddress.cpp b/xfa/fxfa/parser/cxfa_soapaddress.cpp
index 24d9634..aded887 100644
--- a/xfa/fxfa/parser/cxfa_soapaddress.cpp
+++ b/xfa/fxfa/parser/cxfa_soapaddress.cpp
@@ -18,8 +18,6 @@
     {XFA_Attribute::Usehref, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kSoapAddressName[] = L"soapAddress";
-
 }  // namespace
 
 CXFA_SoapAddress::CXFA_SoapAddress(CXFA_Document* doc, XFA_PacketType packet)
@@ -30,7 +28,6 @@
                 XFA_Element::SoapAddress,
                 nullptr,
                 kSoapAddressAttributeData,
-                kSoapAddressName,
                 pdfium::MakeUnique<CJX_SoapAddress>(this)) {}
 
-CXFA_SoapAddress::~CXFA_SoapAddress() {}
+CXFA_SoapAddress::~CXFA_SoapAddress() = default;
diff --git a/xfa/fxfa/parser/cxfa_solid.cpp b/xfa/fxfa/parser/cxfa_solid.cpp
index 9dc1636..0d06a63 100644
--- a/xfa/fxfa/parser/cxfa_solid.cpp
+++ b/xfa/fxfa/parser/cxfa_solid.cpp
@@ -14,14 +14,13 @@
 const CXFA_Node::PropertyData kSolidPropertyData[] = {
     {XFA_Element::Extras, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kSolidAttributeData[] = {
     {XFA_Attribute::Id, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Use, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Usehref, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kSolidName[] = L"solid";
-
 }  // namespace
 
 CXFA_Solid::CXFA_Solid(CXFA_Document* doc, XFA_PacketType packet)
@@ -32,7 +31,6 @@
                 XFA_Element::Solid,
                 kSolidPropertyData,
                 kSolidAttributeData,
-                kSolidName,
                 pdfium::MakeUnique<CJX_Solid>(this)) {}
 
-CXFA_Solid::~CXFA_Solid() {}
+CXFA_Solid::~CXFA_Solid() = default;
diff --git a/xfa/fxfa/parser/cxfa_source.cpp b/xfa/fxfa/parser/cxfa_source.cpp
index 3f7dcec..05fdb1c 100644
--- a/xfa/fxfa/parser/cxfa_source.cpp
+++ b/xfa/fxfa/parser/cxfa_source.cpp
@@ -14,6 +14,7 @@
 const CXFA_Node::PropertyData kSourcePropertyData[] = {
     {XFA_Element::Connect, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kSourceAttributeData[] = {
     {XFA_Attribute::Id, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Name, XFA_AttributeType::CData, nullptr},
@@ -21,8 +22,6 @@
     {XFA_Attribute::Usehref, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kSourceName[] = L"source";
-
 }  // namespace
 
 CXFA_Source::CXFA_Source(CXFA_Document* doc, XFA_PacketType packet)
@@ -33,7 +32,6 @@
                 XFA_Element::Source,
                 kSourcePropertyData,
                 kSourceAttributeData,
-                kSourceName,
                 pdfium::MakeUnique<CJX_Source>(this)) {}
 
-CXFA_Source::~CXFA_Source() {}
+CXFA_Source::~CXFA_Source() = default;
diff --git a/xfa/fxfa/parser/cxfa_sourceset.cpp b/xfa/fxfa/parser/cxfa_sourceset.cpp
index cbc54b6..a968e4e 100644
--- a/xfa/fxfa/parser/cxfa_sourceset.cpp
+++ b/xfa/fxfa/parser/cxfa_sourceset.cpp
@@ -18,8 +18,6 @@
     {XFA_Attribute::Usehref, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kSourceSetName[] = L"sourceSet";
-
 }  // namespace
 
 CXFA_SourceSet::CXFA_SourceSet(CXFA_Document* doc, XFA_PacketType packet)
@@ -30,7 +28,6 @@
                 XFA_Element::SourceSet,
                 nullptr,
                 kSourceSetAttributeData,
-                kSourceSetName,
                 pdfium::MakeUnique<CJX_SourceSet>(this)) {}
 
-CXFA_SourceSet::~CXFA_SourceSet() {}
+CXFA_SourceSet::~CXFA_SourceSet() = default;
diff --git a/xfa/fxfa/parser/cxfa_speak.cpp b/xfa/fxfa/parser/cxfa_speak.cpp
index 3043789..f72cd4b 100644
--- a/xfa/fxfa/parser/cxfa_speak.cpp
+++ b/xfa/fxfa/parser/cxfa_speak.cpp
@@ -21,8 +21,6 @@
     {XFA_Attribute::Disable, XFA_AttributeType::Boolean, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kSpeakName[] = L"speak";
-
 }  // namespace
 
 CXFA_Speak::CXFA_Speak(CXFA_Document* doc, XFA_PacketType packet)
@@ -33,7 +31,6 @@
                 XFA_Element::Speak,
                 nullptr,
                 kSpeakAttributeData,
-                kSpeakName,
                 pdfium::MakeUnique<CJX_Speak>(this)) {}
 
-CXFA_Speak::~CXFA_Speak() {}
+CXFA_Speak::~CXFA_Speak() = default;
diff --git a/xfa/fxfa/parser/cxfa_staple.cpp b/xfa/fxfa/parser/cxfa_staple.cpp
index d2efc17..94f6c71 100644
--- a/xfa/fxfa/parser/cxfa_staple.cpp
+++ b/xfa/fxfa/parser/cxfa_staple.cpp
@@ -15,8 +15,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kStapleName[] = L"staple";
-
 }  // namespace
 
 CXFA_Staple::CXFA_Staple(CXFA_Document* doc, XFA_PacketType packet)
@@ -26,7 +24,6 @@
                 XFA_ObjectType::Node,
                 XFA_Element::Staple,
                 nullptr,
-                kStapleAttributeData,
-                kStapleName) {}
+                kStapleAttributeData) {}
 
-CXFA_Staple::~CXFA_Staple() {}
+CXFA_Staple::~CXFA_Staple() = default;
diff --git a/xfa/fxfa/parser/cxfa_startnode.cpp b/xfa/fxfa/parser/cxfa_startnode.cpp
index 8d9573f..fa522f3 100644
--- a/xfa/fxfa/parser/cxfa_startnode.cpp
+++ b/xfa/fxfa/parser/cxfa_startnode.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kStartNodeName[] = L"startNode";
-
 }  // namespace
 
 CXFA_StartNode::CXFA_StartNode(CXFA_Document* doc, XFA_PacketType packet)
@@ -24,7 +22,6 @@
                 XFA_ObjectType::NodeV,
                 XFA_Element::StartNode,
                 nullptr,
-                kStartNodeAttributeData,
-                kStartNodeName) {}
+                kStartNodeAttributeData) {}
 
-CXFA_StartNode::~CXFA_StartNode() {}
+CXFA_StartNode::~CXFA_StartNode() = default;
diff --git a/xfa/fxfa/parser/cxfa_startpage.cpp b/xfa/fxfa/parser/cxfa_startpage.cpp
index 45f804a..dad34a7 100644
--- a/xfa/fxfa/parser/cxfa_startpage.cpp
+++ b/xfa/fxfa/parser/cxfa_startpage.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kStartPageName[] = L"startPage";
-
 }  // namespace
 
 CXFA_StartPage::CXFA_StartPage(CXFA_Document* doc, XFA_PacketType packet)
@@ -24,7 +22,6 @@
                 XFA_ObjectType::NodeV,
                 XFA_Element::StartPage,
                 nullptr,
-                kStartPageAttributeData,
-                kStartPageName) {}
+                kStartPageAttributeData) {}
 
-CXFA_StartPage::~CXFA_StartPage() {}
+CXFA_StartPage::~CXFA_StartPage() = default;
diff --git a/xfa/fxfa/parser/cxfa_stipple.cpp b/xfa/fxfa/parser/cxfa_stipple.cpp
index 19ca0ca..9d14146 100644
--- a/xfa/fxfa/parser/cxfa_stipple.cpp
+++ b/xfa/fxfa/parser/cxfa_stipple.cpp
@@ -16,6 +16,7 @@
     {XFA_Element::Color, 1, 0},
     {XFA_Element::Extras, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kStippleAttributeData[] = {
     {XFA_Attribute::Id, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Use, XFA_AttributeType::CData, nullptr},
@@ -23,8 +24,6 @@
     {XFA_Attribute::Usehref, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kStippleName[] = L"stipple";
-
 }  // namespace
 
 CXFA_Stipple::CXFA_Stipple(CXFA_Document* doc, XFA_PacketType packet)
@@ -35,10 +34,9 @@
                 XFA_Element::Stipple,
                 kStipplePropertyData,
                 kStippleAttributeData,
-                kStippleName,
                 pdfium::MakeUnique<CJX_Stipple>(this)) {}
 
-CXFA_Stipple::~CXFA_Stipple() {}
+CXFA_Stipple::~CXFA_Stipple() = default;
 
 CXFA_Color* CXFA_Stipple::GetColorIfExists() {
   return GetChild<CXFA_Color>(0, XFA_Element::Color, false);
diff --git a/xfa/fxfa/parser/cxfa_stroke.cpp b/xfa/fxfa/parser/cxfa_stroke.cpp
index a85442f..cfce0ff 100644
--- a/xfa/fxfa/parser/cxfa_stroke.cpp
+++ b/xfa/fxfa/parser/cxfa_stroke.cpp
@@ -68,7 +68,6 @@
                          XFA_Element eType,
                          const PropertyData* properties,
                          const AttributeData* attributes,
-                         const WideStringView& elementName,
                          std::unique_ptr<CJX_Object> js_node)
     : CXFA_Node(pDoc,
                 ePacket,
@@ -77,7 +76,6 @@
                 eType,
                 properties,
                 attributes,
-                elementName,
                 std::move(js_node)) {}
 
 CXFA_Stroke::~CXFA_Stroke() = default;
diff --git a/xfa/fxfa/parser/cxfa_stroke.h b/xfa/fxfa/parser/cxfa_stroke.h
index 4c4036c..3854673 100644
--- a/xfa/fxfa/parser/cxfa_stroke.h
+++ b/xfa/fxfa/parser/cxfa_stroke.h
@@ -58,7 +58,6 @@
               XFA_Element eType,
               const PropertyData* properties,
               const AttributeData* attributes,
-              const WideStringView& elementName,
               std::unique_ptr<CJX_Object> js_node);
 };
 
diff --git a/xfa/fxfa/parser/cxfa_subform.cpp b/xfa/fxfa/parser/cxfa_subform.cpp
index 0a9b9ca..2d699d7 100644
--- a/xfa/fxfa/parser/cxfa_subform.cpp
+++ b/xfa/fxfa/parser/cxfa_subform.cpp
@@ -21,6 +21,7 @@
     {XFA_Element::Bookend, 1, 0}, {XFA_Element::Calculate, 1, 0},
     {XFA_Element::Extras, 1, 0},  {XFA_Element::Variables, 1, 0},
     {XFA_Element::Occur, 1, 0},   {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kSubformAttributeData[] = {
     {XFA_Attribute::H, XFA_AttributeType::Measure, (void*)L"0in"},
     {XFA_Attribute::W, XFA_AttributeType::Measure, (void*)L"0in"},
@@ -59,8 +60,6 @@
      (void*)XFA_AttributeValue::Name},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kSubformName[] = L"subform";
-
 }  // namespace
 
 CXFA_Subform::CXFA_Subform(CXFA_Document* doc, XFA_PacketType packet)
@@ -71,7 +70,6 @@
                 XFA_Element::Subform,
                 kSubformPropertyData,
                 kSubformAttributeData,
-                kSubformName,
                 pdfium::MakeUnique<CJX_Subform>(this)) {}
 
-CXFA_Subform::~CXFA_Subform() {}
+CXFA_Subform::~CXFA_Subform() = default;
diff --git a/xfa/fxfa/parser/cxfa_subformset.cpp b/xfa/fxfa/parser/cxfa_subformset.cpp
index 1f61346..a292632 100644
--- a/xfa/fxfa/parser/cxfa_subformset.cpp
+++ b/xfa/fxfa/parser/cxfa_subformset.cpp
@@ -16,6 +16,7 @@
     {XFA_Element::Desc, 1, 0},   {XFA_Element::Bookend, 1, 0},
     {XFA_Element::Extras, 1, 0}, {XFA_Element::Occur, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kSubformSetAttributeData[] = {
     {XFA_Attribute::Id, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Name, XFA_AttributeType::CData, nullptr},
@@ -26,8 +27,6 @@
     {XFA_Attribute::Usehref, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kSubformSetName[] = L"subformSet";
-
 }  // namespace
 
 CXFA_SubformSet::CXFA_SubformSet(CXFA_Document* doc, XFA_PacketType packet)
@@ -38,7 +37,6 @@
                 XFA_Element::SubformSet,
                 kSubformSetPropertyData,
                 kSubformSetAttributeData,
-                kSubformSetName,
                 pdfium::MakeUnique<CJX_SubformSet>(this)) {}
 
-CXFA_SubformSet::~CXFA_SubformSet() {}
+CXFA_SubformSet::~CXFA_SubformSet() = default;
diff --git a/xfa/fxfa/parser/cxfa_subjectdn.cpp b/xfa/fxfa/parser/cxfa_subjectdn.cpp
index 15572ee..0698823 100644
--- a/xfa/fxfa/parser/cxfa_subjectdn.cpp
+++ b/xfa/fxfa/parser/cxfa_subjectdn.cpp
@@ -19,8 +19,6 @@
     {XFA_Attribute::Usehref, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kSubjectDNName[] = L"subjectDN";
-
 }  // namespace
 
 CXFA_SubjectDN::CXFA_SubjectDN(CXFA_Document* doc, XFA_PacketType packet)
@@ -31,7 +29,6 @@
                 XFA_Element::SubjectDN,
                 nullptr,
                 kSubjectDNAttributeData,
-                kSubjectDNName,
                 pdfium::MakeUnique<CJX_SubjectDN>(this)) {}
 
-CXFA_SubjectDN::~CXFA_SubjectDN() {}
+CXFA_SubjectDN::~CXFA_SubjectDN() = default;
diff --git a/xfa/fxfa/parser/cxfa_subjectdns.cpp b/xfa/fxfa/parser/cxfa_subjectdns.cpp
index a99662e..c927c94 100644
--- a/xfa/fxfa/parser/cxfa_subjectdns.cpp
+++ b/xfa/fxfa/parser/cxfa_subjectdns.cpp
@@ -19,8 +19,6 @@
     {XFA_Attribute::Usehref, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kSubjectDNsName[] = L"subjectDNs";
-
 }  // namespace
 
 CXFA_SubjectDNs::CXFA_SubjectDNs(CXFA_Document* doc, XFA_PacketType packet)
@@ -31,7 +29,6 @@
                 XFA_Element::SubjectDNs,
                 nullptr,
                 kSubjectDNsAttributeData,
-                kSubjectDNsName,
                 pdfium::MakeUnique<CJX_SubjectDNs>(this)) {}
 
-CXFA_SubjectDNs::~CXFA_SubjectDNs() {}
+CXFA_SubjectDNs::~CXFA_SubjectDNs() = default;
diff --git a/xfa/fxfa/parser/cxfa_submit.cpp b/xfa/fxfa/parser/cxfa_submit.cpp
index 9d9c816..6b77df7 100644
--- a/xfa/fxfa/parser/cxfa_submit.cpp
+++ b/xfa/fxfa/parser/cxfa_submit.cpp
@@ -14,6 +14,7 @@
 const CXFA_Node::PropertyData kSubmitPropertyData[] = {
     {XFA_Element::Encrypt, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kSubmitAttributeData[] = {
     {XFA_Attribute::Id, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Use, XFA_AttributeType::CData, nullptr},
@@ -26,8 +27,6 @@
     {XFA_Attribute::XdpContent, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kSubmitName[] = L"submit";
-
 }  // namespace
 
 CXFA_Submit::CXFA_Submit(CXFA_Document* doc, XFA_PacketType packet)
@@ -38,10 +37,9 @@
                 XFA_Element::Submit,
                 kSubmitPropertyData,
                 kSubmitAttributeData,
-                kSubmitName,
                 pdfium::MakeUnique<CJX_Submit>(this)) {}
 
-CXFA_Submit::~CXFA_Submit() {}
+CXFA_Submit::~CXFA_Submit() = default;
 
 bool CXFA_Submit::IsSubmitEmbedPDF() {
   return JSObject()->GetBoolean(XFA_Attribute::EmbedPDF);
diff --git a/xfa/fxfa/parser/cxfa_submitformat.cpp b/xfa/fxfa/parser/cxfa_submitformat.cpp
index 68fa882..b175936 100644
--- a/xfa/fxfa/parser/cxfa_submitformat.cpp
+++ b/xfa/fxfa/parser/cxfa_submitformat.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kSubmitFormatName[] = L"submitFormat";
-
 }  // namespace
 
 CXFA_SubmitFormat::CXFA_SubmitFormat(CXFA_Document* doc, XFA_PacketType packet)
@@ -24,7 +22,6 @@
                 XFA_ObjectType::ContentNode,
                 XFA_Element::SubmitFormat,
                 nullptr,
-                kSubmitFormatAttributeData,
-                kSubmitFormatName) {}
+                kSubmitFormatAttributeData) {}
 
-CXFA_SubmitFormat::~CXFA_SubmitFormat() {}
+CXFA_SubmitFormat::~CXFA_SubmitFormat() = default;
diff --git a/xfa/fxfa/parser/cxfa_submiturl.cpp b/xfa/fxfa/parser/cxfa_submiturl.cpp
index 4d5181d..a0dcece 100644
--- a/xfa/fxfa/parser/cxfa_submiturl.cpp
+++ b/xfa/fxfa/parser/cxfa_submiturl.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kSubmitUrlName[] = L"submitUrl";
-
 }  // namespace
 
 CXFA_SubmitUrl::CXFA_SubmitUrl(CXFA_Document* doc, XFA_PacketType packet)
@@ -24,7 +22,6 @@
                 XFA_ObjectType::ContentNode,
                 XFA_Element::SubmitUrl,
                 nullptr,
-                kSubmitUrlAttributeData,
-                kSubmitUrlName) {}
+                kSubmitUrlAttributeData) {}
 
-CXFA_SubmitUrl::~CXFA_SubmitUrl() {}
+CXFA_SubmitUrl::~CXFA_SubmitUrl() = default;
diff --git a/xfa/fxfa/parser/cxfa_subsetbelow.cpp b/xfa/fxfa/parser/cxfa_subsetbelow.cpp
index a2ba9d6..a33c504 100644
--- a/xfa/fxfa/parser/cxfa_subsetbelow.cpp
+++ b/xfa/fxfa/parser/cxfa_subsetbelow.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kSubsetBelowName[] = L"subsetBelow";
-
 }  // namespace
 
 CXFA_SubsetBelow::CXFA_SubsetBelow(CXFA_Document* doc, XFA_PacketType packet)
@@ -24,7 +22,6 @@
                 XFA_ObjectType::ContentNode,
                 XFA_Element::SubsetBelow,
                 nullptr,
-                kSubsetBelowAttributeData,
-                kSubsetBelowName) {}
+                kSubsetBelowAttributeData) {}
 
-CXFA_SubsetBelow::~CXFA_SubsetBelow() {}
+CXFA_SubsetBelow::~CXFA_SubsetBelow() = default;
diff --git a/xfa/fxfa/parser/cxfa_suppressbanner.cpp b/xfa/fxfa/parser/cxfa_suppressbanner.cpp
index 2656ba9..b72cea1 100644
--- a/xfa/fxfa/parser/cxfa_suppressbanner.cpp
+++ b/xfa/fxfa/parser/cxfa_suppressbanner.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kSuppressBannerName[] = L"suppressBanner";
-
 }  // namespace
 
 CXFA_SuppressBanner::CXFA_SuppressBanner(CXFA_Document* doc,
@@ -25,7 +23,6 @@
                 XFA_ObjectType::ContentNode,
                 XFA_Element::SuppressBanner,
                 nullptr,
-                kSuppressBannerAttributeData,
-                kSuppressBannerName) {}
+                kSuppressBannerAttributeData) {}
 
-CXFA_SuppressBanner::~CXFA_SuppressBanner() {}
+CXFA_SuppressBanner::~CXFA_SuppressBanner() = default;
diff --git a/xfa/fxfa/parser/cxfa_tagged.cpp b/xfa/fxfa/parser/cxfa_tagged.cpp
index eac328e..7a8884d 100644
--- a/xfa/fxfa/parser/cxfa_tagged.cpp
+++ b/xfa/fxfa/parser/cxfa_tagged.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kTaggedName[] = L"tagged";
-
 }  // namespace
 
 CXFA_Tagged::CXFA_Tagged(CXFA_Document* doc, XFA_PacketType packet)
@@ -24,7 +22,6 @@
                 XFA_ObjectType::ContentNode,
                 XFA_Element::Tagged,
                 nullptr,
-                kTaggedAttributeData,
-                kTaggedName) {}
+                kTaggedAttributeData) {}
 
-CXFA_Tagged::~CXFA_Tagged() {}
+CXFA_Tagged::~CXFA_Tagged() = default;
diff --git a/xfa/fxfa/parser/cxfa_template.cpp b/xfa/fxfa/parser/cxfa_template.cpp
index fe0609e..eefd755 100644
--- a/xfa/fxfa/parser/cxfa_template.cpp
+++ b/xfa/fxfa/parser/cxfa_template.cpp
@@ -16,6 +16,7 @@
     {XFA_Element::StartPage, 1, 0}, {XFA_Element::Relevant, 1, 0},
     {XFA_Element::Base, 1, 0},      {XFA_Element::Extras, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kTemplateAttributeData[] = {
     {XFA_Attribute::Desc, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::BaseProfile, XFA_AttributeType::Enum,
@@ -23,8 +24,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kTemplateName[] = L"template";
-
 }  // namespace
 
 CXFA_Template::CXFA_Template(CXFA_Document* doc, XFA_PacketType packet)
@@ -36,7 +35,6 @@
           XFA_Element::Template,
           kTemplatePropertyData,
           kTemplateAttributeData,
-          kTemplateName,
           pdfium::MakeUnique<CJX_Template>(this)) {}
 
-CXFA_Template::~CXFA_Template() {}
+CXFA_Template::~CXFA_Template() = default;
diff --git a/xfa/fxfa/parser/cxfa_templatecache.cpp b/xfa/fxfa/parser/cxfa_templatecache.cpp
index e66223b..31aaeea 100644
--- a/xfa/fxfa/parser/cxfa_templatecache.cpp
+++ b/xfa/fxfa/parser/cxfa_templatecache.cpp
@@ -14,8 +14,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kTemplateCacheName[] = L"templateCache";
-
 }  // namespace
 
 CXFA_TemplateCache::CXFA_TemplateCache(CXFA_Document* doc,
@@ -26,7 +24,6 @@
                 XFA_ObjectType::Node,
                 XFA_Element::TemplateCache,
                 nullptr,
-                kTemplateCacheAttributeData,
-                kTemplateCacheName) {}
+                kTemplateCacheAttributeData) {}
 
-CXFA_TemplateCache::~CXFA_TemplateCache() {}
+CXFA_TemplateCache::~CXFA_TemplateCache() = default;
diff --git a/xfa/fxfa/parser/cxfa_text.cpp b/xfa/fxfa/parser/cxfa_text.cpp
index 818fb22..6b882ef 100644
--- a/xfa/fxfa/parser/cxfa_text.cpp
+++ b/xfa/fxfa/parser/cxfa_text.cpp
@@ -20,8 +20,6 @@
     {XFA_Attribute::Usehref, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kTextName[] = L"text";
-
 }  // namespace
 
 CXFA_Text::CXFA_Text(CXFA_Document* doc, XFA_PacketType packet)
@@ -33,10 +31,9 @@
                 XFA_Element::Text,
                 nullptr,
                 kTextAttributeData,
-                kTextName,
                 pdfium::MakeUnique<CJX_Text>(this)) {}
 
-CXFA_Text::~CXFA_Text() {}
+CXFA_Text::~CXFA_Text() = default;
 
 WideString CXFA_Text::GetContent() {
   return JSObject()->GetContent(false);
diff --git a/xfa/fxfa/parser/cxfa_textedit.cpp b/xfa/fxfa/parser/cxfa_textedit.cpp
index 881c194..0f64dc1 100644
--- a/xfa/fxfa/parser/cxfa_textedit.cpp
+++ b/xfa/fxfa/parser/cxfa_textedit.cpp
@@ -17,6 +17,7 @@
     {XFA_Element::Comb, 1, 0},
     {XFA_Element::Extras, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kTextEditAttributeData[] = {
     {XFA_Attribute::Id, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::VScrollPolicy, XFA_AttributeType::Enum,
@@ -29,8 +30,6 @@
      (void*)XFA_AttributeValue::Auto},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kTextEditName[] = L"textEdit";
-
 }  // namespace
 
 CXFA_TextEdit::CXFA_TextEdit(CXFA_Document* doc, XFA_PacketType packet)
@@ -41,10 +40,9 @@
                 XFA_Element::TextEdit,
                 kTextEditPropertyData,
                 kTextEditAttributeData,
-                kTextEditName,
                 pdfium::MakeUnique<CJX_TextEdit>(this)) {}
 
-CXFA_TextEdit::~CXFA_TextEdit() {}
+CXFA_TextEdit::~CXFA_TextEdit() = default;
 
 XFA_FFWidgetType CXFA_TextEdit::GetDefaultFFWidgetType() const {
   return XFA_FFWidgetType::kTextEdit;
diff --git a/xfa/fxfa/parser/cxfa_thisproxy.cpp b/xfa/fxfa/parser/cxfa_thisproxy.cpp
index 60a90b0..3654409 100644
--- a/xfa/fxfa/parser/cxfa_thisproxy.cpp
+++ b/xfa/fxfa/parser/cxfa_thisproxy.cpp
@@ -13,8 +13,7 @@
 CXFA_ThisProxy::CXFA_ThisProxy(CXFA_Node* pThisNode, CXFA_Node* pScriptNode)
     : CXFA_Object(pThisNode->GetDocument(),
                   XFA_ObjectType::ThisProxy,
-                  XFA_Element::Unknown,
-                  WideStringView(),
+                  XFA_Element::Object,
                   pdfium::MakeUnique<CJX_Object>(this)),
       m_pThisNode(pThisNode),
       m_pScriptNode(pScriptNode) {}
diff --git a/xfa/fxfa/parser/cxfa_threshold.cpp b/xfa/fxfa/parser/cxfa_threshold.cpp
index dc41c53..a7f05b0 100644
--- a/xfa/fxfa/parser/cxfa_threshold.cpp
+++ b/xfa/fxfa/parser/cxfa_threshold.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kThresholdName[] = L"threshold";
-
 }  // namespace
 
 CXFA_Threshold::CXFA_Threshold(CXFA_Document* doc, XFA_PacketType packet)
@@ -24,7 +22,6 @@
                 XFA_ObjectType::NodeV,
                 XFA_Element::Threshold,
                 nullptr,
-                kThresholdAttributeData,
-                kThresholdName) {}
+                kThresholdAttributeData) {}
 
-CXFA_Threshold::~CXFA_Threshold() {}
+CXFA_Threshold::~CXFA_Threshold() = default;
diff --git a/xfa/fxfa/parser/cxfa_time.cpp b/xfa/fxfa/parser/cxfa_time.cpp
index 15f0478..41cd86a 100644
--- a/xfa/fxfa/parser/cxfa_time.cpp
+++ b/xfa/fxfa/parser/cxfa_time.cpp
@@ -18,8 +18,6 @@
     {XFA_Attribute::Usehref, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kTimeName[] = L"time";
-
 }  // namespace
 
 CXFA_Time::CXFA_Time(CXFA_Document* doc, XFA_PacketType packet)
@@ -30,7 +28,6 @@
                 XFA_Element::Time,
                 nullptr,
                 kTimeAttributeData,
-                kTimeName,
                 pdfium::MakeUnique<CJX_Time>(this)) {}
 
-CXFA_Time::~CXFA_Time() {}
+CXFA_Time::~CXFA_Time() = default;
diff --git a/xfa/fxfa/parser/cxfa_timepattern.cpp b/xfa/fxfa/parser/cxfa_timepattern.cpp
index f8cb7cf..2a5617f 100644
--- a/xfa/fxfa/parser/cxfa_timepattern.cpp
+++ b/xfa/fxfa/parser/cxfa_timepattern.cpp
@@ -13,8 +13,6 @@
      (void*)XFA_AttributeValue::Med},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kTimePatternName[] = L"timePattern";
-
 }  // namespace
 
 CXFA_TimePattern::CXFA_TimePattern(CXFA_Document* doc, XFA_PacketType packet)
@@ -24,7 +22,6 @@
                 XFA_ObjectType::ContentNode,
                 XFA_Element::TimePattern,
                 nullptr,
-                kTimePatternAttributeData,
-                kTimePatternName) {}
+                kTimePatternAttributeData) {}
 
-CXFA_TimePattern::~CXFA_TimePattern() {}
+CXFA_TimePattern::~CXFA_TimePattern() = default;
diff --git a/xfa/fxfa/parser/cxfa_timepatterns.cpp b/xfa/fxfa/parser/cxfa_timepatterns.cpp
index da4e187..3cce7b3 100644
--- a/xfa/fxfa/parser/cxfa_timepatterns.cpp
+++ b/xfa/fxfa/parser/cxfa_timepatterns.cpp
@@ -12,8 +12,6 @@
     {XFA_Element::TimePattern, 4, 0},
     {XFA_Element::Unknown, 0, 0}};
 
-constexpr wchar_t kTimePatternsName[] = L"timePatterns";
-
 }  // namespace
 
 CXFA_TimePatterns::CXFA_TimePatterns(CXFA_Document* doc, XFA_PacketType packet)
@@ -23,7 +21,6 @@
                 XFA_ObjectType::Node,
                 XFA_Element::TimePatterns,
                 kTimePatternsPropertyData,
-                nullptr,
-                kTimePatternsName) {}
+                nullptr) {}
 
-CXFA_TimePatterns::~CXFA_TimePatterns() {}
+CXFA_TimePatterns::~CXFA_TimePatterns() = default;
diff --git a/xfa/fxfa/parser/cxfa_timestamp.cpp b/xfa/fxfa/parser/cxfa_timestamp.cpp
index 3258abc..3bfef61 100644
--- a/xfa/fxfa/parser/cxfa_timestamp.cpp
+++ b/xfa/fxfa/parser/cxfa_timestamp.cpp
@@ -19,8 +19,6 @@
     {XFA_Attribute::Usehref, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kTimeStampName[] = L"timeStamp";
-
 }  // namespace
 
 CXFA_TimeStamp::CXFA_TimeStamp(CXFA_Document* doc, XFA_PacketType packet)
@@ -30,7 +28,6 @@
                 XFA_ObjectType::Node,
                 XFA_Element::TimeStamp,
                 nullptr,
-                kTimeStampAttributeData,
-                kTimeStampName) {}
+                kTimeStampAttributeData) {}
 
-CXFA_TimeStamp::~CXFA_TimeStamp() {}
+CXFA_TimeStamp::~CXFA_TimeStamp() = default;
diff --git a/xfa/fxfa/parser/cxfa_to.cpp b/xfa/fxfa/parser/cxfa_to.cpp
index 745f015..9836ea8 100644
--- a/xfa/fxfa/parser/cxfa_to.cpp
+++ b/xfa/fxfa/parser/cxfa_to.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kToName[] = L"to";
-
 }  // namespace
 
 CXFA_To::CXFA_To(CXFA_Document* doc, XFA_PacketType packet)
@@ -24,7 +22,6 @@
                 XFA_ObjectType::ContentNode,
                 XFA_Element::To,
                 nullptr,
-                kToAttributeData,
-                kToName) {}
+                kToAttributeData) {}
 
-CXFA_To::~CXFA_To() {}
+CXFA_To::~CXFA_To() = default;
diff --git a/xfa/fxfa/parser/cxfa_tooltip.cpp b/xfa/fxfa/parser/cxfa_tooltip.cpp
index 85ebb2b..c721626 100644
--- a/xfa/fxfa/parser/cxfa_tooltip.cpp
+++ b/xfa/fxfa/parser/cxfa_tooltip.cpp
@@ -18,8 +18,6 @@
     {XFA_Attribute::Usehref, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kToolTipName[] = L"toolTip";
-
 }  // namespace
 
 CXFA_ToolTip::CXFA_ToolTip(CXFA_Document* doc, XFA_PacketType packet)
@@ -30,7 +28,6 @@
                 XFA_Element::ToolTip,
                 nullptr,
                 kToolTipAttributeData,
-                kToolTipName,
                 pdfium::MakeUnique<CJX_ToolTip>(this)) {}
 
-CXFA_ToolTip::~CXFA_ToolTip() {}
+CXFA_ToolTip::~CXFA_ToolTip() = default;
diff --git a/xfa/fxfa/parser/cxfa_trace.cpp b/xfa/fxfa/parser/cxfa_trace.cpp
index 8503816..955d55b 100644
--- a/xfa/fxfa/parser/cxfa_trace.cpp
+++ b/xfa/fxfa/parser/cxfa_trace.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kTraceName[] = L"trace";
-
 }  // namespace
 
 CXFA_Trace::CXFA_Trace(CXFA_Document* doc, XFA_PacketType packet)
@@ -24,7 +22,6 @@
                 XFA_ObjectType::Node,
                 XFA_Element::Trace,
                 nullptr,
-                kTraceAttributeData,
-                kTraceName) {}
+                kTraceAttributeData) {}
 
-CXFA_Trace::~CXFA_Trace() {}
+CXFA_Trace::~CXFA_Trace() = default;
diff --git a/xfa/fxfa/parser/cxfa_transform.cpp b/xfa/fxfa/parser/cxfa_transform.cpp
index 03c5178..a3de7df 100644
--- a/xfa/fxfa/parser/cxfa_transform.cpp
+++ b/xfa/fxfa/parser/cxfa_transform.cpp
@@ -13,14 +13,13 @@
     {XFA_Element::IfEmpty, 1, 0},     {XFA_Element::Presence, 1, 0},
     {XFA_Element::Picture, 1, 0},     {XFA_Element::NameAttr, 1, 0},
     {XFA_Element::GroupParent, 1, 0}, {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kTransformAttributeData[] = {
     {XFA_Attribute::Ref, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Desc, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kTransformName[] = L"transform";
-
 }  // namespace
 
 CXFA_Transform::CXFA_Transform(CXFA_Document* doc, XFA_PacketType packet)
@@ -30,7 +29,6 @@
                 XFA_ObjectType::Node,
                 XFA_Element::Transform,
                 kTransformPropertyData,
-                kTransformAttributeData,
-                kTransformName) {}
+                kTransformAttributeData) {}
 
-CXFA_Transform::~CXFA_Transform() {}
+CXFA_Transform::~CXFA_Transform() = default;
diff --git a/xfa/fxfa/parser/cxfa_traversal.cpp b/xfa/fxfa/parser/cxfa_traversal.cpp
index cb327a0..158d346 100644
--- a/xfa/fxfa/parser/cxfa_traversal.cpp
+++ b/xfa/fxfa/parser/cxfa_traversal.cpp
@@ -14,14 +14,13 @@
 const CXFA_Node::PropertyData kTraversalPropertyData[] = {
     {XFA_Element::Extras, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kTraversalAttributeData[] = {
     {XFA_Attribute::Id, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Use, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Usehref, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kTraversalName[] = L"traversal";
-
 }  // namespace
 
 CXFA_Traversal::CXFA_Traversal(CXFA_Document* doc, XFA_PacketType packet)
@@ -32,7 +31,6 @@
                 XFA_Element::Traversal,
                 kTraversalPropertyData,
                 kTraversalAttributeData,
-                kTraversalName,
                 pdfium::MakeUnique<CJX_Traversal>(this)) {}
 
-CXFA_Traversal::~CXFA_Traversal() {}
+CXFA_Traversal::~CXFA_Traversal() = default;
diff --git a/xfa/fxfa/parser/cxfa_traverse.cpp b/xfa/fxfa/parser/cxfa_traverse.cpp
index 3325ef8..59f0415 100644
--- a/xfa/fxfa/parser/cxfa_traverse.cpp
+++ b/xfa/fxfa/parser/cxfa_traverse.cpp
@@ -15,6 +15,7 @@
     {XFA_Element::Script, 1, 0},
     {XFA_Element::Extras, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kTraverseAttributeData[] = {
     {XFA_Attribute::Id, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Ref, XFA_AttributeType::CData, nullptr},
@@ -24,8 +25,6 @@
     {XFA_Attribute::Usehref, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kTraverseName[] = L"traverse";
-
 }  // namespace
 
 CXFA_Traverse::CXFA_Traverse(CXFA_Document* doc, XFA_PacketType packet)
@@ -36,7 +35,6 @@
                 XFA_Element::Traverse,
                 kTraversePropertyData,
                 kTraverseAttributeData,
-                kTraverseName,
                 pdfium::MakeUnique<CJX_Traverse>(this)) {}
 
 CXFA_Traverse::~CXFA_Traverse() {}
diff --git a/xfa/fxfa/parser/cxfa_treelist.cpp b/xfa/fxfa/parser/cxfa_treelist.cpp
index 1c1ab2d..3d0f748 100644
--- a/xfa/fxfa/parser/cxfa_treelist.cpp
+++ b/xfa/fxfa/parser/cxfa_treelist.cpp
@@ -17,7 +17,6 @@
     : CXFA_List(pDocument,
                 XFA_ObjectType::TreeList,
                 XFA_Element::TreeList,
-                WideStringView(L"treeList"),
                 pdfium::MakeUnique<CJX_TreeList>(this)) {}
 
 CXFA_TreeList::~CXFA_TreeList() = default;
diff --git a/xfa/fxfa/parser/cxfa_type.cpp b/xfa/fxfa/parser/cxfa_type.cpp
index 56274ce..bfaa66c 100644
--- a/xfa/fxfa/parser/cxfa_type.cpp
+++ b/xfa/fxfa/parser/cxfa_type.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kTypeName[] = L"type";
-
 }  // namespace
 
 CXFA_Type::CXFA_Type(CXFA_Document* doc, XFA_PacketType packet)
@@ -24,7 +22,6 @@
                 XFA_ObjectType::ContentNode,
                 XFA_Element::Type,
                 nullptr,
-                kTypeAttributeData,
-                kTypeName) {}
+                kTypeAttributeData) {}
 
-CXFA_Type::~CXFA_Type() {}
+CXFA_Type::~CXFA_Type() = default;
diff --git a/xfa/fxfa/parser/cxfa_typeface.cpp b/xfa/fxfa/parser/cxfa_typeface.cpp
index 0e480eb..80e674b 100644
--- a/xfa/fxfa/parser/cxfa_typeface.cpp
+++ b/xfa/fxfa/parser/cxfa_typeface.cpp
@@ -12,8 +12,6 @@
     {XFA_Attribute::Name, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kTypefaceName[] = L"typeface";
-
 }  // namespace
 
 CXFA_Typeface::CXFA_Typeface(CXFA_Document* doc, XFA_PacketType packet)
@@ -23,7 +21,6 @@
                 XFA_ObjectType::Node,
                 XFA_Element::Typeface,
                 nullptr,
-                kTypefaceAttributeData,
-                kTypefaceName) {}
+                kTypefaceAttributeData) {}
 
-CXFA_Typeface::~CXFA_Typeface() {}
+CXFA_Typeface::~CXFA_Typeface() = default;
diff --git a/xfa/fxfa/parser/cxfa_typefaces.cpp b/xfa/fxfa/parser/cxfa_typefaces.cpp
index 13d2e85..562e254 100644
--- a/xfa/fxfa/parser/cxfa_typefaces.cpp
+++ b/xfa/fxfa/parser/cxfa_typefaces.cpp
@@ -6,12 +6,6 @@
 
 #include "xfa/fxfa/parser/cxfa_typefaces.h"
 
-namespace {
-
-constexpr wchar_t kTypefacesName[] = L"typefaces";
-
-}  // namespace
-
 CXFA_Typefaces::CXFA_Typefaces(CXFA_Document* doc, XFA_PacketType packet)
     : CXFA_Node(doc,
                 packet,
@@ -19,7 +13,6 @@
                 XFA_ObjectType::Node,
                 XFA_Element::Typefaces,
                 nullptr,
-                nullptr,
-                kTypefacesName) {}
+                nullptr) {}
 
-CXFA_Typefaces::~CXFA_Typefaces() {}
+CXFA_Typefaces::~CXFA_Typefaces() = default;
diff --git a/xfa/fxfa/parser/cxfa_ui.cpp b/xfa/fxfa/parser/cxfa_ui.cpp
index 8729b92..134703f 100644
--- a/xfa/fxfa/parser/cxfa_ui.cpp
+++ b/xfa/fxfa/parser/cxfa_ui.cpp
@@ -26,14 +26,13 @@
     {XFA_Element::TextEdit, 1, XFA_PROPERTYFLAG_OneOf},
     {XFA_Element::Extras, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kUiAttributeData[] = {
     {XFA_Attribute::Id, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Use, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Usehref, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kUiName[] = L"ui";
-
 }  // namespace
 
 CXFA_Ui::CXFA_Ui(CXFA_Document* doc, XFA_PacketType packet)
@@ -44,10 +43,9 @@
                 XFA_Element::Ui,
                 kUiPropertyData,
                 kUiAttributeData,
-                kUiName,
                 pdfium::MakeUnique<CJX_Ui>(this)) {}
 
-CXFA_Ui::~CXFA_Ui() {}
+CXFA_Ui::~CXFA_Ui() = default;
 
 bool CXFA_Ui::IsAOneOfChild(CXFA_Node* child) const {
   for (auto& prop : kUiPropertyData) {
diff --git a/xfa/fxfa/parser/cxfa_update.cpp b/xfa/fxfa/parser/cxfa_update.cpp
index 78378d0..c7a9169 100644
--- a/xfa/fxfa/parser/cxfa_update.cpp
+++ b/xfa/fxfa/parser/cxfa_update.cpp
@@ -18,8 +18,6 @@
     {XFA_Attribute::Usehref, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kUpdateName[] = L"update";
-
 }  // namespace
 
 CXFA_Update::CXFA_Update(CXFA_Document* doc, XFA_PacketType packet)
@@ -30,7 +28,6 @@
                 XFA_Element::Update,
                 nullptr,
                 kUpdateAttributeData,
-                kUpdateName,
                 pdfium::MakeUnique<CJX_Update>(this)) {}
 
-CXFA_Update::~CXFA_Update() {}
+CXFA_Update::~CXFA_Update() = default;
diff --git a/xfa/fxfa/parser/cxfa_uri.cpp b/xfa/fxfa/parser/cxfa_uri.cpp
index 74b3b87..186e676 100644
--- a/xfa/fxfa/parser/cxfa_uri.cpp
+++ b/xfa/fxfa/parser/cxfa_uri.cpp
@@ -20,8 +20,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kUriName[] = L"uri";
-
 }  // namespace
 
 CXFA_Uri::CXFA_Uri(CXFA_Document* doc, XFA_PacketType packet)
@@ -32,7 +30,6 @@
                 XFA_Element::Uri,
                 nullptr,
                 kUriAttributeData,
-                kUriName,
                 pdfium::MakeUnique<CJX_Uri>(this)) {}
 
-CXFA_Uri::~CXFA_Uri() {}
+CXFA_Uri::~CXFA_Uri() = default;
diff --git a/xfa/fxfa/parser/cxfa_user.cpp b/xfa/fxfa/parser/cxfa_user.cpp
index b0f9778..bd608c4 100644
--- a/xfa/fxfa/parser/cxfa_user.cpp
+++ b/xfa/fxfa/parser/cxfa_user.cpp
@@ -18,8 +18,6 @@
     {XFA_Attribute::Usehref, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kUserName[] = L"user";
-
 }  // namespace
 
 CXFA_User::CXFA_User(CXFA_Document* doc, XFA_PacketType packet)
@@ -30,7 +28,6 @@
                 XFA_Element::User,
                 nullptr,
                 kUserAttributeData,
-                kUserName,
                 pdfium::MakeUnique<CJX_User>(this)) {}
 
-CXFA_User::~CXFA_User() {}
+CXFA_User::~CXFA_User() = default;
diff --git a/xfa/fxfa/parser/cxfa_validate.cpp b/xfa/fxfa/parser/cxfa_validate.cpp
index 2514c49..7b3f611 100644
--- a/xfa/fxfa/parser/cxfa_validate.cpp
+++ b/xfa/fxfa/parser/cxfa_validate.cpp
@@ -36,7 +36,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kValidateName[] = L"validate";
 constexpr wchar_t kFormatTest[] = L"formatTest";
 constexpr wchar_t kNullTest[] = L"nullTest";
 constexpr wchar_t kScriptTest[] = L"scriptTest";
@@ -52,10 +51,9 @@
           XFA_Element::Validate,
           kValidatePropertyData,
           kValidateAttributeData,
-          kValidateName,
           pdfium::MakeUnique<CJX_Validate>(this)) {}
 
-CXFA_Validate::~CXFA_Validate() {}
+CXFA_Validate::~CXFA_Validate() = default;
 
 XFA_AttributeValue CXFA_Validate::GetFormatTest() {
   return JSObject()->GetEnum(XFA_Attribute::FormatTest);
diff --git a/xfa/fxfa/parser/cxfa_validateapprovalsignatures.cpp b/xfa/fxfa/parser/cxfa_validateapprovalsignatures.cpp
index b86fa64..e196e35 100644
--- a/xfa/fxfa/parser/cxfa_validateapprovalsignatures.cpp
+++ b/xfa/fxfa/parser/cxfa_validateapprovalsignatures.cpp
@@ -13,9 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kValidateApprovalSignaturesName[] =
-    L"validateApprovalSignatures";
-
 }  // namespace
 
 CXFA_ValidateApprovalSignatures::CXFA_ValidateApprovalSignatures(
@@ -27,7 +24,6 @@
                 XFA_ObjectType::NodeV,
                 XFA_Element::ValidateApprovalSignatures,
                 nullptr,
-                kValidateApprovalSignaturesAttributeData,
-                kValidateApprovalSignaturesName) {}
+                kValidateApprovalSignaturesAttributeData) {}
 
-CXFA_ValidateApprovalSignatures::~CXFA_ValidateApprovalSignatures() {}
+CXFA_ValidateApprovalSignatures::~CXFA_ValidateApprovalSignatures() = default;
diff --git a/xfa/fxfa/parser/cxfa_validationmessaging.cpp b/xfa/fxfa/parser/cxfa_validationmessaging.cpp
index 75267a0..6f44da7 100644
--- a/xfa/fxfa/parser/cxfa_validationmessaging.cpp
+++ b/xfa/fxfa/parser/cxfa_validationmessaging.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kValidationMessagingName[] = L"validationMessaging";
-
 }  // namespace
 
 CXFA_ValidationMessaging::CXFA_ValidationMessaging(CXFA_Document* doc,
@@ -25,7 +23,6 @@
                 XFA_ObjectType::NodeV,
                 XFA_Element::ValidationMessaging,
                 nullptr,
-                kValidationMessagingAttributeData,
-                kValidationMessagingName) {}
+                kValidationMessagingAttributeData) {}
 
-CXFA_ValidationMessaging::~CXFA_ValidationMessaging() {}
+CXFA_ValidationMessaging::~CXFA_ValidationMessaging() = default;
diff --git a/xfa/fxfa/parser/cxfa_value.cpp b/xfa/fxfa/parser/cxfa_value.cpp
index b06eebf..97344b0 100644
--- a/xfa/fxfa/parser/cxfa_value.cpp
+++ b/xfa/fxfa/parser/cxfa_value.cpp
@@ -32,6 +32,7 @@
     {XFA_Element::Float, 1, XFA_PROPERTYFLAG_OneOf},
     {XFA_Element::Line, 1, XFA_PROPERTYFLAG_OneOf},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kValueAttributeData[] = {
     {XFA_Attribute::Id, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Use, XFA_AttributeType::CData, nullptr},
@@ -40,8 +41,6 @@
     {XFA_Attribute::Override, XFA_AttributeType::Boolean, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kValueName[] = L"value";
-
 }  // namespace
 
 CXFA_Value::CXFA_Value(CXFA_Document* doc, XFA_PacketType packet)
@@ -52,10 +51,9 @@
                 XFA_Element::Value,
                 kValuePropertyData,
                 kValueAttributeData,
-                kValueName,
                 pdfium::MakeUnique<CJX_Value>(this)) {}
 
-CXFA_Value::~CXFA_Value() {}
+CXFA_Value::~CXFA_Value() = default;
 
 XFA_Element CXFA_Value::GetChildValueClassID() const {
   CXFA_Node* pNode = GetFirstChild();
diff --git a/xfa/fxfa/parser/cxfa_variables.cpp b/xfa/fxfa/parser/cxfa_variables.cpp
index 7dee73c..58340c8 100644
--- a/xfa/fxfa/parser/cxfa_variables.cpp
+++ b/xfa/fxfa/parser/cxfa_variables.cpp
@@ -17,8 +17,6 @@
     {XFA_Attribute::Usehref, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kVariablesName[] = L"variables";
-
 }  // namespace
 
 CXFA_Variables::CXFA_Variables(CXFA_Document* doc, XFA_PacketType packet)
@@ -29,7 +27,6 @@
                 XFA_Element::Variables,
                 nullptr,
                 kVariablesAttributeData,
-                kVariablesName,
                 pdfium::MakeUnique<CJX_Variables>(this)) {}
 
-CXFA_Variables::~CXFA_Variables() {}
+CXFA_Variables::~CXFA_Variables() = default;
diff --git a/xfa/fxfa/parser/cxfa_version.cpp b/xfa/fxfa/parser/cxfa_version.cpp
index ca16548..9e07a86 100644
--- a/xfa/fxfa/parser/cxfa_version.cpp
+++ b/xfa/fxfa/parser/cxfa_version.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kVersionName[] = L"version";
-
 }  // namespace
 
 CXFA_Version::CXFA_Version(CXFA_Document* doc, XFA_PacketType packet)
@@ -24,7 +22,6 @@
                 XFA_ObjectType::ContentNode,
                 XFA_Element::Version,
                 nullptr,
-                kVersionAttributeData,
-                kVersionName) {}
+                kVersionAttributeData) {}
 
-CXFA_Version::~CXFA_Version() {}
+CXFA_Version::~CXFA_Version() = default;
diff --git a/xfa/fxfa/parser/cxfa_versioncontrol.cpp b/xfa/fxfa/parser/cxfa_versioncontrol.cpp
index 78db73c..46db99d 100644
--- a/xfa/fxfa/parser/cxfa_versioncontrol.cpp
+++ b/xfa/fxfa/parser/cxfa_versioncontrol.cpp
@@ -18,8 +18,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kVersionControlName[] = L"versionControl";
-
 }  // namespace
 
 CXFA_VersionControl::CXFA_VersionControl(CXFA_Document* doc,
@@ -30,7 +28,6 @@
                 XFA_ObjectType::Node,
                 XFA_Element::VersionControl,
                 nullptr,
-                kVersionControlAttributeData,
-                kVersionControlName) {}
+                kVersionControlAttributeData) {}
 
-CXFA_VersionControl::~CXFA_VersionControl() {}
+CXFA_VersionControl::~CXFA_VersionControl() = default;
diff --git a/xfa/fxfa/parser/cxfa_viewerpreferences.cpp b/xfa/fxfa/parser/cxfa_viewerpreferences.cpp
index 3efb1c5..f861355 100644
--- a/xfa/fxfa/parser/cxfa_viewerpreferences.cpp
+++ b/xfa/fxfa/parser/cxfa_viewerpreferences.cpp
@@ -19,13 +19,12 @@
     {XFA_Element::ADBE_JSDebugger, 1, 0},
     {XFA_Element::PickTrayByPDFSize, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kViewerPreferencesAttributeData[] = {
     {XFA_Attribute::Desc, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kViewerPreferencesName[] = L"viewerPreferences";
-
 }  // namespace
 
 CXFA_ViewerPreferences::CXFA_ViewerPreferences(CXFA_Document* doc,
@@ -36,7 +35,6 @@
                 XFA_ObjectType::Node,
                 XFA_Element::ViewerPreferences,
                 kViewerPreferencesPropertyData,
-                kViewerPreferencesAttributeData,
-                kViewerPreferencesName) {}
+                kViewerPreferencesAttributeData) {}
 
-CXFA_ViewerPreferences::~CXFA_ViewerPreferences() {}
+CXFA_ViewerPreferences::~CXFA_ViewerPreferences() = default;
diff --git a/xfa/fxfa/parser/cxfa_webclient.cpp b/xfa/fxfa/parser/cxfa_webclient.cpp
index 8c8f987..8441c5d 100644
--- a/xfa/fxfa/parser/cxfa_webclient.cpp
+++ b/xfa/fxfa/parser/cxfa_webclient.cpp
@@ -12,14 +12,13 @@
     {XFA_Element::FontInfo, 1, 0},
     {XFA_Element::Xdc, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kWebClientAttributeData[] = {
     {XFA_Attribute::Name, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Desc, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kWebClientName[] = L"webClient";
-
 }  // namespace
 
 CXFA_WebClient::CXFA_WebClient(CXFA_Document* doc, XFA_PacketType packet)
@@ -29,7 +28,6 @@
                 XFA_ObjectType::Node,
                 XFA_Element::WebClient,
                 kWebClientPropertyData,
-                kWebClientAttributeData,
-                kWebClientName) {}
+                kWebClientAttributeData) {}
 
-CXFA_WebClient::~CXFA_WebClient() {}
+CXFA_WebClient::~CXFA_WebClient() = default;
diff --git a/xfa/fxfa/parser/cxfa_whitespace.cpp b/xfa/fxfa/parser/cxfa_whitespace.cpp
index f4fa7de..9b20749 100644
--- a/xfa/fxfa/parser/cxfa_whitespace.cpp
+++ b/xfa/fxfa/parser/cxfa_whitespace.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kWhitespaceName[] = L"whitespace";
-
 }  // namespace
 
 CXFA_Whitespace::CXFA_Whitespace(CXFA_Document* doc, XFA_PacketType packet)
@@ -24,7 +22,6 @@
                 XFA_ObjectType::NodeV,
                 XFA_Element::Whitespace,
                 nullptr,
-                kWhitespaceAttributeData,
-                kWhitespaceName) {}
+                kWhitespaceAttributeData) {}
 
-CXFA_Whitespace::~CXFA_Whitespace() {}
+CXFA_Whitespace::~CXFA_Whitespace() = default;
diff --git a/xfa/fxfa/parser/cxfa_window.cpp b/xfa/fxfa/parser/cxfa_window.cpp
index 4aded52..5793033 100644
--- a/xfa/fxfa/parser/cxfa_window.cpp
+++ b/xfa/fxfa/parser/cxfa_window.cpp
@@ -13,8 +13,6 @@
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kWindowName[] = L"window";
-
 }  // namespace
 
 CXFA_Window::CXFA_Window(CXFA_Document* doc, XFA_PacketType packet)
@@ -24,7 +22,6 @@
                 XFA_ObjectType::NodeV,
                 XFA_Element::Window,
                 nullptr,
-                kWindowAttributeData,
-                kWindowName) {}
+                kWindowAttributeData) {}
 
-CXFA_Window::~CXFA_Window() {}
+CXFA_Window::~CXFA_Window() = default;
diff --git a/xfa/fxfa/parser/cxfa_wsdladdress.cpp b/xfa/fxfa/parser/cxfa_wsdladdress.cpp
index abe35c8..47b8bc4 100644
--- a/xfa/fxfa/parser/cxfa_wsdladdress.cpp
+++ b/xfa/fxfa/parser/cxfa_wsdladdress.cpp
@@ -18,8 +18,6 @@
     {XFA_Attribute::Usehref, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kWsdlAddressName[] = L"wsdlAddress";
-
 }  // namespace
 
 CXFA_WsdlAddress::CXFA_WsdlAddress(CXFA_Document* doc, XFA_PacketType packet)
@@ -30,7 +28,6 @@
                 XFA_Element::WsdlAddress,
                 nullptr,
                 kWsdlAddressAttributeData,
-                kWsdlAddressName,
                 pdfium::MakeUnique<CJX_WsdlAddress>(this)) {}
 
-CXFA_WsdlAddress::~CXFA_WsdlAddress() {}
+CXFA_WsdlAddress::~CXFA_WsdlAddress() = default;
diff --git a/xfa/fxfa/parser/cxfa_wsdlconnection.cpp b/xfa/fxfa/parser/cxfa_wsdlconnection.cpp
index 1073f4f..d70d529 100644
--- a/xfa/fxfa/parser/cxfa_wsdlconnection.cpp
+++ b/xfa/fxfa/parser/cxfa_wsdlconnection.cpp
@@ -19,13 +19,12 @@
     {XFA_Element::EffectiveOutputPolicy, 1, 0},
     {XFA_Element::EffectiveInputPolicy, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kWsdlConnectionAttributeData[] = {
     {XFA_Attribute::Name, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::DataDescription, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kWsdlConnectionName[] = L"wsdlConnection";
-
 }  // namespace
 
 CXFA_WsdlConnection::CXFA_WsdlConnection(CXFA_Document* doc,
@@ -37,7 +36,6 @@
                 XFA_Element::WsdlConnection,
                 kWsdlConnectionPropertyData,
                 kWsdlConnectionAttributeData,
-                kWsdlConnectionName,
                 pdfium::MakeUnique<CJX_WsdlConnection>(this)) {}
 
-CXFA_WsdlConnection::~CXFA_WsdlConnection() {}
+CXFA_WsdlConnection::~CXFA_WsdlConnection() = default;
diff --git a/xfa/fxfa/parser/cxfa_xdc.cpp b/xfa/fxfa/parser/cxfa_xdc.cpp
index 7701cd4..8bb9b3e 100644
--- a/xfa/fxfa/parser/cxfa_xdc.cpp
+++ b/xfa/fxfa/parser/cxfa_xdc.cpp
@@ -12,13 +12,12 @@
     {XFA_Element::Uri, 1, 0},
     {XFA_Element::Xsl, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kXdcAttributeData[] = {
     {XFA_Attribute::Desc, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kXdcName[] = L"xdc";
-
 }  // namespace
 
 CXFA_Xdc::CXFA_Xdc(CXFA_Document* doc, XFA_PacketType packet)
@@ -28,7 +27,6 @@
                 XFA_ObjectType::ModelNode,
                 XFA_Element::Xdc,
                 kXdcPropertyData,
-                kXdcAttributeData,
-                kXdcName) {}
+                kXdcAttributeData) {}
 
-CXFA_Xdc::~CXFA_Xdc() {}
+CXFA_Xdc::~CXFA_Xdc() = default;
diff --git a/xfa/fxfa/parser/cxfa_xdp.cpp b/xfa/fxfa/parser/cxfa_xdp.cpp
index 5f01dfd..8395b8d 100644
--- a/xfa/fxfa/parser/cxfa_xdp.cpp
+++ b/xfa/fxfa/parser/cxfa_xdp.cpp
@@ -11,13 +11,12 @@
 const CXFA_Node::PropertyData kXdpPropertyData[] = {
     {XFA_Element::Packets, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kXdpAttributeData[] = {
     {XFA_Attribute::Desc, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kXdpName[] = L"xdp";
-
 }  // namespace
 
 CXFA_Xdp::CXFA_Xdp(CXFA_Document* doc, XFA_PacketType packet)
@@ -27,7 +26,6 @@
                 XFA_ObjectType::Node,
                 XFA_Element::Xdp,
                 kXdpPropertyData,
-                kXdpAttributeData,
-                kXdpName) {}
+                kXdpAttributeData) {}
 
-CXFA_Xdp::~CXFA_Xdp() {}
+CXFA_Xdp::~CXFA_Xdp() = default;
diff --git a/xfa/fxfa/parser/cxfa_xfa.cpp b/xfa/fxfa/parser/cxfa_xfa.cpp
index 1eb658e..00b2320 100644
--- a/xfa/fxfa/parser/cxfa_xfa.cpp
+++ b/xfa/fxfa/parser/cxfa_xfa.cpp
@@ -16,8 +16,6 @@
     {XFA_Attribute::Uuid, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kXfaName[] = L"xfa";
-
 }  // namespace
 
 CXFA_Xfa::CXFA_Xfa(CXFA_Document* doc, XFA_PacketType packet)
@@ -28,7 +26,6 @@
                 XFA_Element::Xfa,
                 nullptr,
                 kXfaAttributeData,
-                kXfaName,
                 pdfium::MakeUnique<CJX_Xfa>(this)) {}
 
-CXFA_Xfa::~CXFA_Xfa() {}
+CXFA_Xfa::~CXFA_Xfa() = default;
diff --git a/xfa/fxfa/parser/cxfa_xmlconnection.cpp b/xfa/fxfa/parser/cxfa_xmlconnection.cpp
index 31a1e41..41e1816 100644
--- a/xfa/fxfa/parser/cxfa_xmlconnection.cpp
+++ b/xfa/fxfa/parser/cxfa_xmlconnection.cpp
@@ -14,13 +14,12 @@
 const CXFA_Node::PropertyData kXmlConnectionPropertyData[] = {
     {XFA_Element::Uri, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kXmlConnectionAttributeData[] = {
     {XFA_Attribute::Name, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::DataDescription, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kXmlConnectionName[] = L"xmlConnection";
-
 }  // namespace
 
 CXFA_XmlConnection::CXFA_XmlConnection(CXFA_Document* doc,
@@ -32,7 +31,6 @@
                 XFA_Element::XmlConnection,
                 kXmlConnectionPropertyData,
                 kXmlConnectionAttributeData,
-                kXmlConnectionName,
                 pdfium::MakeUnique<CJX_XmlConnection>(this)) {}
 
-CXFA_XmlConnection::~CXFA_XmlConnection() {}
+CXFA_XmlConnection::~CXFA_XmlConnection() = default;
diff --git a/xfa/fxfa/parser/cxfa_xsdconnection.cpp b/xfa/fxfa/parser/cxfa_xsdconnection.cpp
index 06d8bd7..68c3319 100644
--- a/xfa/fxfa/parser/cxfa_xsdconnection.cpp
+++ b/xfa/fxfa/parser/cxfa_xsdconnection.cpp
@@ -15,13 +15,12 @@
     {XFA_Element::Uri, 1, 0},
     {XFA_Element::RootElement, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kXsdConnectionAttributeData[] = {
     {XFA_Attribute::Name, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::DataDescription, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kXsdConnectionName[] = L"xsdConnection";
-
 }  // namespace
 
 CXFA_XsdConnection::CXFA_XsdConnection(CXFA_Document* doc,
@@ -33,7 +32,6 @@
                 XFA_Element::XsdConnection,
                 kXsdConnectionPropertyData,
                 kXsdConnectionAttributeData,
-                kXsdConnectionName,
                 pdfium::MakeUnique<CJX_XsdConnection>(this)) {}
 
-CXFA_XsdConnection::~CXFA_XsdConnection() {}
+CXFA_XsdConnection::~CXFA_XsdConnection() = default;
diff --git a/xfa/fxfa/parser/cxfa_xsl.cpp b/xfa/fxfa/parser/cxfa_xsl.cpp
index 651250c..fc47a339 100644
--- a/xfa/fxfa/parser/cxfa_xsl.cpp
+++ b/xfa/fxfa/parser/cxfa_xsl.cpp
@@ -12,13 +12,12 @@
     {XFA_Element::Uri, 1, 0},
     {XFA_Element::Debug, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kXslAttributeData[] = {
     {XFA_Attribute::Desc, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kXslName[] = L"xsl";
-
 }  // namespace
 
 CXFA_Xsl::CXFA_Xsl(CXFA_Document* doc, XFA_PacketType packet)
@@ -28,7 +27,6 @@
                 XFA_ObjectType::Node,
                 XFA_Element::Xsl,
                 kXslPropertyData,
-                kXslAttributeData,
-                kXslName) {}
+                kXslAttributeData) {}
 
-CXFA_Xsl::~CXFA_Xsl() {}
+CXFA_Xsl::~CXFA_Xsl() = default;
diff --git a/xfa/fxfa/parser/cxfa_zpl.cpp b/xfa/fxfa/parser/cxfa_zpl.cpp
index 76fb44b..2f2f8fd 100644
--- a/xfa/fxfa/parser/cxfa_zpl.cpp
+++ b/xfa/fxfa/parser/cxfa_zpl.cpp
@@ -14,14 +14,13 @@
     {XFA_Element::BatchOutput, 1, 0},
     {XFA_Element::FlipLabel, 1, 0},
     {XFA_Element::Unknown, 0, 0}};
+
 const CXFA_Node::AttributeData kZplAttributeData[] = {
     {XFA_Attribute::Name, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Desc, XFA_AttributeType::CData, nullptr},
     {XFA_Attribute::Lock, XFA_AttributeType::Integer, (void*)0},
     {XFA_Attribute::Unknown, XFA_AttributeType::Integer, nullptr}};
 
-constexpr wchar_t kZplName[] = L"zpl";
-
 }  // namespace
 
 CXFA_Zpl::CXFA_Zpl(CXFA_Document* doc, XFA_PacketType packet)
@@ -31,7 +30,6 @@
                 XFA_ObjectType::Node,
                 XFA_Element::Zpl,
                 kZplPropertyData,
-                kZplAttributeData,
-                kZplName) {}
+                kZplAttributeData) {}
 
-CXFA_Zpl::~CXFA_Zpl() {}
+CXFA_Zpl::~CXFA_Zpl() = default;
diff --git a/xfa/fxfa/parser/elements.inc b/xfa/fxfa/parser/elements.inc
index c7689e4..76457e2 100644
--- a/xfa/fxfa/parser/elements.inc
+++ b/xfa/fxfa/parser/elements.inc
@@ -311,20 +311,20 @@
 ELEM____(0xfc78159fu, "numberSymbol", NumberSymbol, Node)
 ELEM____(0xfcbd606cu, "tagged", Tagged, Node)
 ELEM____(0xff063802u, "items", Items, Node)
-ELEM____(0xffffffffu, "******", SignaturePseudoModel, Object)
-ELEM____(0xffffffffu, "******", EventPseudoModel, Object)
-ELEM____(0xffffffffu, "******", HostPseudoModel, Object)
-ELEM____(0xffffffffu, "******", LayoutPseudoModel, Object)
-ELEM____(0xffffffffu, "******", DataWindow, Object)
-ELEM____(0xffffffffu, "******", TreeList, Placeholder1)
-ELEM____(0xffffffffu, "******", LogPseudoModel, Object)
-ELEM____(0xffffffffu, "******", List, ListDuplicate)
-ELEM____(0xffffffffu, "******", Object, Unknown)
+ELEM____(0xffffffffu, "signaturePseudoModel", SignaturePseudoModel, Object)
+ELEM____(0xffffffffu, "eventPseudoModel", EventPseudoModel, Object)
+ELEM____(0xffffffffu, "hostPseudoModel", HostPseudoModel, Object)
+ELEM____(0xffffffffu, "layoutPseudoModel", LayoutPseudoModel, Object)
+ELEM____(0xffffffffu, "dataWindow", DataWindow, Object)
+ELEM____(0xffffffffu, "treeList,", TreeList, Placeholder1)
+ELEM____(0xffffffffu, "logPseudoModel", LogPseudoModel, Object)
+ELEM____(0xffffffffu, "list", List, ListDuplicate)
+ELEM____(0xffffffffu, "object", Object, Unknown)
 ELEM____(0xffffffffu, "******", ListDuplicate, Object)
 ELEM____(0xffffffffu, "******", Placeholder1, ListDuplicate)
-ELEM____(0xffffffffu, "******", Tree, Object)
-ELEM____(0xffffffffu, "******", Node, Tree)
+ELEM____(0xffffffffu, "tree", Tree, Object)
+ELEM____(0xffffffffu, "node", Node, Tree)
 ELEM____(0xffffffffu, "******", Placeholder2, Node)
 ELEM____(0xffffffffu, "******", Placeholder3, Node)
-ELEM____(0xffffffffu, "******", Model, Node)
+ELEM____(0xffffffffu, "model", Model, Node)
 ELEM____(0xffffffffu, "******", Placeholder4, Node)
diff --git a/xfa/fxfa/parser/xfa_basic_data_unittest.cpp b/xfa/fxfa/parser/xfa_basic_data_unittest.cpp
index d0abe64..d2a2872 100644
--- a/xfa/fxfa/parser/xfa_basic_data_unittest.cpp
+++ b/xfa/fxfa/parser/xfa_basic_data_unittest.cpp
@@ -22,8 +22,8 @@
   EXPECT_EQ("conformance", XFA_ElementToName(XFA_Element::Conformance));
   EXPECT_EQ("tagged", XFA_ElementToName(XFA_Element::Tagged));
 
-  // Internal elements resolve to some sort of name.
-  EXPECT_EQ("******", XFA_ElementToName(XFA_Element::Node));
+  // Internal elements resolve back to real names.
+  EXPECT_EQ("node", XFA_ElementToName(XFA_Element::Node));
 }
 
 TEST(XFABasicDataTest, GetAttributeByName) {
diff --git a/xfa/fxfa/parser/xfa_utils.cpp b/xfa/fxfa/parser/xfa_utils.cpp
index 566556e..15fbd6f 100644
--- a/xfa/fxfa/parser/xfa_utils.cpp
+++ b/xfa/fxfa/parser/xfa_utils.cpp
@@ -297,7 +297,7 @@
 
   if (!wsChildren.IsEmpty() || !wsAttrs.IsEmpty() ||
       pNode->JSObject()->HasAttribute(XFA_Attribute::Name)) {
-    WideStringView wsElement = pNode->GetClassName();
+    WideString wsElement = WideString::FromASCII(pNode->GetClassName());
     WideString wsName;
     SaveAttribute(pNode, XFA_Attribute::Name, L"name", true, wsName);
     buf << "<";
@@ -330,7 +330,7 @@
     return;
   }
 
-  WideString wsElement(pNode->GetClassName());
+  WideString wsElement = WideString::FromASCII(pNode->GetClassName());
   pStream->WriteString("<");
   pStream->WriteString(wsElement.ToUTF8().AsStringView());
 
