Update GetClassID to GetElementType

xfa/fxfa/parser/xfa_document_serialize.cpp

 // Copyright 2014 PDFium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
 
 #include "xfa/fxfa/parser/xfa_document_serialize.h"
 
 #include "xfa/fde/xml/fde_xml_imp.h"
 #include "xfa/fgas/crt/fgas_codepage.h"
@@ skipping 32 matching lines @@
   CXFA_Node* pDataModel =
       ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Datasets));
   if (!pDataModel) {
     pDataDocumentParser->Release();
     return FALSE;
   }
   CXFA_Node* pDataNode = ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Data));
   if (pDataNode) {
     pDataModel->RemoveChild(pDataNode);
   }
-  if (pImportDataRoot->GetClassID() == XFA_Element::DataModel) {
+  if (pImportDataRoot->GetElementType() == XFA_Element::DataModel) {
     while (CXFA_Node* pChildNode =
                pImportDataRoot->GetNodeItem(XFA_NODEITEM_FirstChild)) {
       pImportDataRoot->RemoveChild(pChildNode);
       pDataModel->InsertChild(pChildNode);
     }
   } else {
     CFDE_XMLNode* pXMLNode = pImportDataRoot->GetXMLMappingNode();
     CFDE_XMLNode* pParentXMLNode = pXMLNode->GetNodeItem(CFDE_XMLNode::Parent);
     if (pParentXMLNode) {
       pParentXMLNode->RemoveChildNode(pXMLNode);
@@ skipping 74 matching lines @@
   wsOutput += FX_WSTRC(L" ");
   wsOutput += wsName;
   wsOutput += FX_WSTRC(L"=\"");
   wsOutput += wsValue;
   wsOutput += FX_WSTRC(L"\"");
 }
 static FX_BOOL XFA_DataExporter_AttributeSaveInDataModel(
     CXFA_Node* pNode,
     XFA_ATTRIBUTE eAttribute) {
   FX_BOOL bSaveInDataModel = FALSE;
-  if (pNode->GetClassID() != XFA_Element::Image) {
+  if (pNode->GetElementType() != XFA_Element::Image) {
     return bSaveInDataModel;
   }
   CXFA_Node* pValueNode = pNode->GetNodeItem(XFA_NODEITEM_Parent);
-  if (!pValueNode || pValueNode->GetClassID() != XFA_Element::Value) {
+  if (!pValueNode || pValueNode->GetElementType() != XFA_Element::Value) {
     return bSaveInDataModel;
   }
   CXFA_Node* pFieldNode = pValueNode->GetNodeItem(XFA_NODEITEM_Parent);
   if (pFieldNode && pFieldNode->GetBindData() &&
       eAttribute == XFA_ATTRIBUTE_Href) {
     bSaveInDataModel = TRUE;
   }
   return bSaveInDataModel;
 }
 FX_BOOL XFA_DataExporter_ContentNodeNeedtoExport(CXFA_Node* pContentNode) {
   CFX_WideString wsContent;
   if (!pContentNode->TryContent(wsContent, FALSE, FALSE))
     return FALSE;
 
   ASSERT(pContentNode->IsContentNode());
   CXFA_Node* pParentNode = pContentNode->GetNodeItem(XFA_NODEITEM_Parent);
-  if (!pParentNode || pParentNode->GetClassID() != XFA_Element::Value)
+  if (!pParentNode || pParentNode->GetElementType() != XFA_Element::Value)
     return TRUE;
 
   CXFA_Node* pGrandParentNode = pParentNode->GetNodeItem(XFA_NODEITEM_Parent);
   if (!pGrandParentNode || !pGrandParentNode->IsContainerNode())
     return TRUE;
   if (pGrandParentNode->GetBindData())
     return FALSE;
 
   CXFA_WidgetData* pWidgetData = pGrandParentNode->GetWidgetData();
   XFA_Element eUIType = pWidgetData->GetUIType();
@@ skipping 19 matching lines @@
     eVersion = XFA_VERSION_DEFAULT;
   }
   wsVersionNumber.Format(L"%i.%i", eVersion / 100, eVersion % 100);
 }
 static void XFA_DataExporter_RegenerateFormFile_Changed(
     CXFA_Node* pNode,
     CFX_WideTextBuf& buf,
     FX_BOOL bSaveXML = FALSE) {
   CFX_WideString wsAttrs;
   int32_t iAttrs = 0;
-  const uint8_t* pAttrs = XFA_GetElementAttributes(pNode->GetClassID(), iAttrs);
+  const uint8_t* pAttrs =
+      XFA_GetElementAttributes(pNode->GetElementType(), iAttrs);
   while (iAttrs--) {
     const XFA_ATTRIBUTEINFO* pAttr =
         XFA_GetAttributeByID((XFA_ATTRIBUTE)pAttrs[iAttrs]);
     if (pAttr->eName == XFA_ATTRIBUTE_Name ||
         (XFA_DataExporter_AttributeSaveInDataModel(pNode, pAttr->eName) &&
          !bSaveXML)) {
       continue;
     }
     CFX_WideString wsAttr;
     XFA_SaveAttribute(pNode, pAttr->eName, pAttr->pName, bSaveXML, wsAttr);
     wsAttrs += wsAttr;
   }
   CFX_WideString wsChildren;
   switch (pNode->GetObjectType()) {
     case XFA_ObjectType::ContentNode: {
       if (!bSaveXML && !XFA_DataExporter_ContentNodeNeedtoExport(pNode)) {
         break;
       }
       CXFA_Node* pRawValueNode = pNode->GetNodeItem(XFA_NODEITEM_FirstChild);
       while (pRawValueNode &&
-             pRawValueNode->GetClassID() != XFA_Element::SharpxHTML &&
-             pRawValueNode->GetClassID() != XFA_Element::Sharptext &&
-             pRawValueNode->GetClassID() != XFA_Element::Sharpxml) {
+             pRawValueNode->GetElementType() != XFA_Element::SharpxHTML &&
+             pRawValueNode->GetElementType() != XFA_Element::Sharptext &&
+             pRawValueNode->GetElementType() != XFA_Element::Sharpxml) {
         pRawValueNode = pRawValueNode->GetNodeItem(XFA_NODEITEM_NextSibling);
       }
       if (!pRawValueNode) {
         break;
       }
       CFX_WideString wsContentType;
       pNode->GetAttribute(XFA_ATTRIBUTE_ContentType, wsContentType, FALSE);
-      if (pRawValueNode->GetClassID() == XFA_Element::SharpxHTML &&
+      if (pRawValueNode->GetElementType() == XFA_Element::SharpxHTML &&
           wsContentType == FX_WSTRC(L"text/html")) {
         CFDE_XMLNode* pExDataXML = pNode->GetXMLMappingNode();
         if (!pExDataXML) {
           break;
         }
         CFDE_XMLNode* pRichTextXML =
             pExDataXML->GetNodeItem(CFDE_XMLNode::FirstChild);
         if (!pRichTextXML) {
           break;
         }
         IFX_MemoryStream* pMemStream = FX_CreateMemoryStream(TRUE);
         IFX_Stream* pTempStream = IFX_Stream::CreateStream(
             (IFX_FileWrite*)pMemStream, FX_STREAMACCESS_Text |
                                             FX_STREAMACCESS_Write |
                                             FX_STREAMACCESS_Append);
         pTempStream->SetCodePage(FX_CODEPAGE_UTF8);
         pRichTextXML->SaveXMLNode(pTempStream);
         wsChildren += CFX_WideString::FromUTF8(
             CFX_ByteStringC(pMemStream->GetBuffer(), pMemStream->GetSize()));
         pTempStream->Release();
         pMemStream->Release();
-      } else if (pRawValueNode->GetClassID() == XFA_Element::Sharpxml &&
+      } else if (pRawValueNode->GetElementType() == XFA_Element::Sharpxml &&
                  wsContentType == FX_WSTRC(L"text/xml")) {
         CFX_WideString wsRawValue;
         pRawValueNode->GetAttribute(XFA_ATTRIBUTE_Value, wsRawValue, FALSE);
         if (wsRawValue.IsEmpty()) {
           break;
         }
         CFX_WideStringArray wsSelTextArray;
         int32_t iStart = 0;
         int32_t iEnd = wsRawValue.Find(L'\n', iStart);
         iEnd = (iEnd == -1) ? wsRawValue.GetLength() : iEnd;
@@ skipping 33 matching lines @@
         wsChildren += XFA_ExportEncodeContent(wsValue);
       }
     } break;
     case XFA_ObjectType::TextNode:
     case XFA_ObjectType::NodeC:
     case XFA_ObjectType::NodeV: {
       CFX_WideStringC wsValue = pNode->GetCData(XFA_ATTRIBUTE_Value);
       wsChildren += XFA_ExportEncodeContent(wsValue);
     } break;
     default:
-      if (pNode->GetClassID() == XFA_Element::Items) {
+      if (pNode->GetElementType() == XFA_Element::Items) {
         CXFA_Node* pTemplateNode = pNode->GetTemplateNode();
         if (!pTemplateNode ||
             pTemplateNode->CountChildren(XFA_Element::Unknown) !=
                 pNode->CountChildren(XFA_Element::Unknown)) {
           bSaveXML = TRUE;
         }
       }
       CFX_WideTextBuf newBuf;
       CXFA_Node* pChildNode = pNode->GetNodeItem(XFA_NODEITEM_FirstChild);
       while (pChildNode) {
         XFA_DataExporter_RegenerateFormFile_Changed(pChildNode, newBuf,
                                                     bSaveXML);
         wsChildren += newBuf.AsStringC();
         newBuf.Clear();
         pChildNode = pChildNode->GetNodeItem(XFA_NODEITEM_NextSibling);
       }
       if (!bSaveXML && !wsChildren.IsEmpty() &&
-          pNode->GetClassID() == XFA_Element::Items) {
+          pNode->GetElementType() == XFA_Element::Items) {
         wsChildren.clear();
         bSaveXML = TRUE;
         CXFA_Node* pChild = pNode->GetNodeItem(XFA_NODEITEM_FirstChild);
         while (pChild) {
           XFA_DataExporter_RegenerateFormFile_Changed(pChild, newBuf, bSaveXML);
           wsChildren += newBuf.AsStringC();
           newBuf.Clear();
           pChild = pChild->GetNodeItem(XFA_NODEITEM_NextSibling);
         }
       }
@@ skipping 18 matching lines @@
       buf << FX_WSTRC(L"</");
       buf << wsElement;
       buf << FX_WSTRC(L"\n>");
     }
   }
 }
 static void XFA_DataExporter_RegenerateFormFile_Container(
     CXFA_Node* pNode,
     IFX_Stream* pStream,
     FX_BOOL bSaveXML = FALSE) {
-  XFA_Element eElement = pNode->GetClassID();
+  XFA_Element eElement = pNode->GetElementType();
   if (eElement == XFA_Element::Field || eElement == XFA_Element::Draw ||
       !pNode->IsContainerNode()) {
     CFX_WideTextBuf buf;
     XFA_DataExporter_RegenerateFormFile_Changed(pNode, buf, bSaveXML);
     FX_STRSIZE nLen = buf.GetLength();
     if (nLen > 0) {
       pStream->WriteString((const FX_WCHAR*)buf.GetBuffer(), nLen);
     }
     return;
   }
   CFX_WideStringC wsElement;
   pNode->GetClassName(wsElement);
   pStream->WriteString(L"<", 1);
   pStream->WriteString(wsElement.c_str(), wsElement.GetLength());
   CFX_WideString wsOutput;
   XFA_SaveAttribute(pNode, XFA_ATTRIBUTE_Name, FX_WSTRC(L"name"), TRUE,
                     wsOutput);
   CFX_WideString wsAttrs;
   int32_t iAttrs = 0;
-  const uint8_t* pAttrs = XFA_GetElementAttributes(pNode->GetClassID(), iAttrs);
+  const uint8_t* pAttrs =
+      XFA_GetElementAttributes(pNode->GetElementType(), iAttrs);
   while (iAttrs--) {
     const XFA_ATTRIBUTEINFO* pAttr =
         XFA_GetAttributeByID((XFA_ATTRIBUTE)pAttrs[iAttrs]);
     if (pAttr->eName == XFA_ATTRIBUTE_Name) {
       continue;
     }
     CFX_WideString wsAttr;
     XFA_SaveAttribute(pNode, pAttr->eName, pAttr->pName, FALSE, wsAttr);
     wsOutput += wsAttr;
   }
@@ skipping 140 matching lines @@
     }
     XFA_DataExporter_DealWithDataGroupNode(pExportNode);
     pElement->SetString(L"xmlns:xfa",
                         L"http://www.xfa.org/schema/xfa-data/1.0/");
     pXMLDoc->SaveXMLNode(pStream, pElement);
     pElement->RemoveAttribute(L"xmlns:xfa");
   }
   return TRUE;
 }
 void XFA_DataExporter_DealWithDataGroupNode(CXFA_Node* pDataNode) {
-  if (!pDataNode || pDataNode->GetClassID() == XFA_Element::DataValue) {
+  if (!pDataNode || pDataNode->GetElementType() == XFA_Element::DataValue) {
     return;
   }
   int32_t iChildNum = 0;
   for (CXFA_Node* pChildNode = pDataNode->GetNodeItem(XFA_NODEITEM_FirstChild);
        pChildNode;
        pChildNode = pChildNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
     iChildNum++;
     XFA_DataExporter_DealWithDataGroupNode(pChildNode);
   }
-  if (pDataNode->GetClassID() == XFA_Element::DataGroup) {
+  if (pDataNode->GetElementType() == XFA_Element::DataGroup) {
     if (iChildNum > 0) {
       CFDE_XMLNode* pXMLNode = pDataNode->GetXMLMappingNode();
       ASSERT(pXMLNode->GetType() == FDE_XMLNODE_Element);
       CFDE_XMLElement* pXMLElement = static_cast<CFDE_XMLElement*>(pXMLNode);
       if (pXMLElement->HasAttribute(L"xfa:dataNode")) {
         pXMLElement->RemoveAttribute(L"xfa:dataNode");
       }
     } else {
       CFDE_XMLNode* pXMLNode = pDataNode->GetXMLMappingNode();
       ASSERT(pXMLNode->GetType() == FDE_XMLNODE_Element);
       static_cast<CFDE_XMLElement*>(pXMLNode)->SetString(L"xfa:dataNode",
                                                          L"dataGroup");
     }
   }
 }