Move xfa_basic_imp to cxfa_widetextread.

xfa/fxfa/parser/cxfa_node.cpp

 // Copyright 2016 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_object.h"
 
 #include <map>
 #include <memory>
 
 #include "core/fxcrt/include/fx_ext.h"
 #include "fxjs/include/cfxjse_value.h"
 #include "third_party/base/stl_util.h"
 #include "xfa/fde/xml/fde_xml_imp.h"
 #include "xfa/fgas/crt/fgas_codepage.h"
 #include "xfa/fgas/crt/fgas_system.h"
 #include "xfa/fxfa/app/xfa_ffnotify.h"
 #include "xfa/fxfa/include/cxfa_eventparam.h"
+#include "xfa/fxfa/parser/cxfa_measurement.h"
 #include "xfa/fxfa/parser/cxfa_occur.h"
 #include "xfa/fxfa/parser/cxfa_scriptcontext.h"
 #include "xfa/fxfa/parser/cxfa_simple_parser.h"
 #include "xfa/fxfa/parser/xfa_basic_data.h"
 #include "xfa/fxfa/parser/xfa_document.h"
 #include "xfa/fxfa/parser/xfa_document_layout_imp.h"
 
 namespace {
 
 void XFA_DeleteWideString(void* pData) {
@@ skipping 408 matching lines @@
 void* GetMapKey_Custom(const CFX_WideStringC& wsKey) {
   uint32_t dwKey = FX_HashCode_GetW(wsKey, false);
   return (void*)(uintptr_t)((dwKey << 1) | XFA_KEYTYPE_Custom);
 }
 
 void* GetMapKey_Element(XFA_Element eType, XFA_ATTRIBUTE eAttribute) {
   return (void*)(uintptr_t)((static_cast<int32_t>(eType) << 16) |
                             (eAttribute << 8) | XFA_KEYTYPE_Element);
 }
 
+const XFA_ATTRIBUTEINFO* GetAttributeOfElement(XFA_Element eElement,
+                                               XFA_ATTRIBUTE eAttribute,
+                                               uint32_t dwPacket) {
+  int32_t iCount = 0;
+  const uint8_t* pAttr = XFA_GetElementAttributes(eElement, iCount);
+  if (!pAttr || iCount < 1)
+    return nullptr;
+
+  if (!std::binary_search(pAttr, pAttr + iCount, eAttribute))
+    return nullptr;
+
+  const XFA_ATTRIBUTEINFO* pInfo = XFA_GetAttributeByID(eAttribute);
+  ASSERT(pInfo);
+  if (dwPacket == XFA_XDPPACKET_UNKNOWN)
+    return pInfo;
+  return (dwPacket & pInfo->dwPackets) ? pInfo : nullptr;
+}
+
+const XFA_ATTRIBUTEENUMINFO* GetAttributeEnumByID(XFA_ATTRIBUTEENUM eName) {
+  return g_XFAEnumData + eName;
+}
+
 }  // namespace
 
 static void XFA_DefaultFreeData(void* pData) {}
 
 static XFA_MAPDATABLOCKCALLBACKINFO gs_XFADefaultFreeData = {
     XFA_DefaultFreeData, nullptr};
 
 XFA_MAPMODULEDATA::XFA_MAPMODULEDATA() {}
 
 XFA_MAPMODULEDATA::~XFA_MAPMODULEDATA() {}
@@ skipping 1870 matching lines @@
   CXFA_WidgetData* pWidgetData = GetWidgetData();
   if (!pWidgetData) {
     return;
   }
   CXFA_Validate validate = pWidgetData->GetValidate(TRUE);
   if (bSetting) {
     validate.SetNullTest(pValue->ToWideString());
   } else {
     int32_t iValue = validate.GetNullTest();
     const XFA_ATTRIBUTEENUMINFO* pInfo =
-        XFA_GetAttributeEnumByID((XFA_ATTRIBUTEENUM)iValue);
+        GetAttributeEnumByID((XFA_ATTRIBUTEENUM)iValue);
     CFX_WideString wsValue;
     if (pInfo)
       wsValue = pInfo->pName;
     pValue->SetString(FX_UTF8Encode(wsValue).AsStringC());
   }
 }
 
 void CXFA_Node::Script_Som_MandatoryMessage(CFXJSE_Value* pValue,
                                             FX_BOOL bSetting,
                                             XFA_ATTRIBUTE eAttribute) {
@@ skipping 564 matching lines @@
         CFX_ByteString bsNameSpace = pArguments->GetUTF8String(2);
         strNameSpace = CFX_WideString::FromUTF8(bsNameSpace.AsStringC());
       }
     }
     XFA_Element eType = XFA_GetElementTypeForName(strTagName.AsStringC());
     CXFA_Node* pNewNode = CreateSamePacketNode(eType);
     if (!pNewNode) {
       pArguments->GetReturnValue()->SetNull();
     } else {
       if (!strName.IsEmpty()) {
-        if (XFA_GetAttributeOfElement(eType, XFA_ATTRIBUTE_Name,
-                                      XFA_XDPPACKET_UNKNOWN)) {
+        if (GetAttributeOfElement(eType, XFA_ATTRIBUTE_Name,
+                                  XFA_XDPPACKET_UNKNOWN)) {
           pNewNode->SetAttribute(XFA_ATTRIBUTE_Name, strName.AsStringC(), true);
           if (pNewNode->GetPacketID() == XFA_XDPPACKET_Datasets) {
             pNewNode->CreateXMLMappingNode();
           }
           pArguments->GetReturnValue()->Assign(
               m_pDocument->GetScriptContext()->GetJSValueFromMap(pNewNode));
         } else {
           ThrowException(XFA_IDS_NOT_HAVE_PROPERTY, strTagName.c_str(),
                          L"name");
         }
@@ skipping 767 matching lines @@
     const XFA_NOTSUREATTRIBUTE* pNotsure =
         XFA_GetNotsureAttribute(GetElementType(), pAttr->eName);
     eType = pNotsure ? pNotsure->eType : XFA_ATTRIBUTETYPE_Cdata;
   }
   switch (eType) {
     case XFA_ATTRIBUTETYPE_Enum: {
       XFA_ATTRIBUTEENUM eValue;
       if (!TryEnum(pAttr->eName, eValue, bUseDefault)) {
         return FALSE;
       }
-      wsValue = XFA_GetAttributeEnumByID(eValue)->pName;
+      wsValue = GetAttributeEnumByID(eValue)->pName;
       return TRUE;
     } break;
     case XFA_ATTRIBUTETYPE_Cdata: {
       CFX_WideStringC wsValueC;
       if (!TryCData(pAttr->eName, wsValueC, bUseDefault)) {
         return FALSE;
       }
       wsValue = wsValueC;
       return TRUE;
     } break;
@@ skipping 328 matching lines @@
   OnChanged(eAttr, bNotify, FALSE);
   if (IsNeedSavingXMLNode()) {
     ASSERT(m_pXMLNode->GetType() == FDE_XMLNODE_Element);
     const XFA_ATTRIBUTEINFO* pInfo = XFA_GetAttributeByID(eAttr);
     if (pInfo) {
       switch (eType) {
         case XFA_ATTRIBUTETYPE_Enum:
           static_cast<CFDE_XMLElement*>(m_pXMLNode)
               ->SetString(
                   pInfo->pName,
-                  XFA_GetAttributeEnumByID((XFA_ATTRIBUTEENUM)(uintptr_t)pValue)
+                  GetAttributeEnumByID((XFA_ATTRIBUTEENUM)(uintptr_t)pValue)
                       ->pName);
           break;
         case XFA_ATTRIBUTETYPE_Boolean:
           static_cast<CFDE_XMLElement*>(m_pXMLNode)
               ->SetString(pInfo->pName, pValue ? L"1" : L"0");
           break;
         case XFA_ATTRIBUTETYPE_Integer:
           static_cast<CFDE_XMLElement*>(m_pXMLNode)
               ->SetInteger(pInfo->pName, (int32_t)(uintptr_t)pValue);
           break;
@@ skipping 812 matching lines @@
 }
 
 void CXFA_Node::UpdateNameHash() {
   const XFA_NOTSUREATTRIBUTE* pNotsure =
       XFA_GetNotsureAttribute(GetElementType(), XFA_ATTRIBUTE_Name);
   CFX_WideStringC wsName;
   if (!pNotsure || pNotsure->eType == XFA_ATTRIBUTETYPE_Cdata) {
     wsName = GetCData(XFA_ATTRIBUTE_Name);
     m_dwNameHash = FX_HashCode_GetW(wsName, false);
   } else if (pNotsure->eType == XFA_ATTRIBUTETYPE_Enum) {
-    wsName = XFA_GetAttributeEnumByID(GetEnum(XFA_ATTRIBUTE_Name))->pName;
+    wsName = GetAttributeEnumByID(GetEnum(XFA_ATTRIBUTE_Name))->pName;
     m_dwNameHash = FX_HashCode_GetW(wsName, false);
   }
 }
 
 CFDE_XMLNode* CXFA_Node::CreateXMLMappingNode() {
   if (!m_pXMLNode) {
     CFX_WideString wsTag(GetCData(XFA_ATTRIBUTE_Name));
     m_pXMLNode = new CFDE_XMLElement(wsTag);
     SetFlag(XFA_NodeFlag_OwnXMLNode, false);
   }
@@ skipping 258 matching lines @@
     CXFA_Node* pSrcChild = pSrcModule->GetNodeItem(XFA_NODEITEM_FirstChild);
     CXFA_Node* pDstChild = pDstModule->GetNodeItem(XFA_NODEITEM_FirstChild);
     for (; pSrcChild && pDstChild;
          pSrcChild = pSrcChild->GetNodeItem(XFA_NODEITEM_NextSibling),
          pDstChild = pDstChild->GetNodeItem(XFA_NODEITEM_NextSibling)) {
       MoveBufferMapData(pSrcChild, pDstChild, pKey, TRUE);
     }
   }
   pSrcModule->MoveBufferMapData(pDstModule, pKey);
 }