Remove CFX_MapPtrToPtr from xfa/fxfa.

xfa/fxfa/parser/xfa_document_datamerger_imp.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_datamerger_imp.h"
 
+#include <map>
 #include <vector>
 
 #include "core/fxcrt/fx_ext.h"
 #include "third_party/base/stl_util.h"
 #include "xfa/fde/xml/fde_xml_imp.h"
 #include "xfa/fxfa/parser/cxfa_document.h"
 #include "xfa/fxfa/parser/cxfa_layoutprocessor.h"
 #include "xfa/fxfa/parser/cxfa_occur.h"
 #include "xfa/fxfa/parser/cxfa_scriptcontext.h"
 #include "xfa/fxfa/parser/xfa_localemgr.h"
@@ skipping 330 matching lines @@
     case XFA_Element::Signature:
     case XFA_Element::TextEdit:
     default:
       FormValueNode_SetChildContent(defValue.GetNode(), wsNormalizeValue,
                                     XFA_Element::Text);
       break;
   }
 }
 
 CXFA_Node* GetGlobalBinding(CXFA_Document* pDocument, uint32_t dwNameHash) {
-  CXFA_Node* pNode = nullptr;
-  pDocument->m_rgGlobalBinding.Lookup(dwNameHash, pNode);
-  return pNode;
+  auto it = pDocument->m_rgGlobalBinding.find(dwNameHash);
+  return it != pDocument->m_rgGlobalBinding.end() ? it->second : nullptr;
 }
 
 void RegisterGlobalBinding(CXFA_Document* pDocument,
                            uint32_t dwNameHash,
                            CXFA_Node* pDataNode) {
-  pDocument->m_rgGlobalBinding.SetAt(dwNameHash, pDataNode);
+  pDocument->m_rgGlobalBinding[dwNameHash] = pDataNode;
 }
 
 CXFA_Node* ScopeMatchGlobalBinding(CXFA_Node* pDataScope,
                                    uint32_t dwNameHash,
                                    XFA_Element eMatchDataNodeType,
                                    bool bUpLevel) {
   for (CXFA_Node *pCurDataScope = pDataScope, *pLastDataScope = nullptr;
        pCurDataScope && pCurDataScope->GetPacketID() == XFA_XDPPACKET_Datasets;
        pLastDataScope = pCurDataScope,
                  pCurDataScope =
@@ skipping 368 matching lines @@
           : XFA_ATTRIBUTEENUM_Ordered;
   int32_t iCurRepeatIndex = 0;
   XFA_ATTRIBUTEENUM eParentBindMatch = XFA_ATTRIBUTEENUM_None;
   if (bDataMerge) {
     CXFA_NodeIteratorTemplate<CXFA_Node, CXFA_TraverseStrategy_XFAContainerNode>
         sNodeIterator(pTemplateNode);
     bool bAccessedDataDOM = false;
     if (eType == XFA_Element::SubformSet || eType == XFA_Element::Area) {
       sNodeIterator.MoveToNext();
     } else {
-      CFX_MapPtrTemplate<CXFA_Node*, CXFA_Node*> subformMapArray;
+      std::map<CXFA_Node*, CXFA_Node*> subformMapArray;
       CXFA_NodeArray nodeArray;
       for (; iMax < 0 || iCurRepeatIndex < iMax; iCurRepeatIndex++) {
         bool bSelfMatch = false;
         XFA_ATTRIBUTEENUM eBindMatch = XFA_ATTRIBUTEENUM_None;
         CXFA_Node* pDataNode = FindMatchingDataNode(
             pDocument, pTemplateNode, pDataScope, bAccessedDataDOM, false,
             &sNodeIterator, bSelfMatch, eBindMatch, true);
         if (!pDataNode || sNodeIterator.GetCurrent() != pTemplateNode)
           break;
 
         eParentBindMatch = eBindMatch;
         CXFA_Node* pSubformNode = XFA_NodeMerge_CloneOrMergeContainer(
             pDocument, pFormParentNode, pTemplateNode, false, pSearchArray);
         if (!pFirstInstance)
           pFirstInstance = pSubformNode;
 
         CreateDataBinding(pSubformNode, pDataNode, true);
         ASSERT(pSubformNode);
-        subformMapArray.SetAt(pSubformNode, pDataNode);
+        subformMapArray[pSubformNode] = pDataNode;
         nodeArray.Add(pSubformNode);
       }
 
-      subformMapArray.GetStartPosition();
       for (int32_t iIndex = 0; iIndex < nodeArray.GetSize(); iIndex++) {
         CXFA_Node* pSubform = nodeArray[iIndex];
-        CXFA_Node* pDataNode =
-            reinterpret_cast<CXFA_Node*>(subformMapArray.GetValueAt(pSubform));
+        CXFA_Node* pDataNode = nullptr;
+        auto it = subformMapArray.find(pSubform);
+        if (it != subformMapArray.end())
+          pDataNode = it->second;
         for (CXFA_Node* pTemplateChild =
                  pTemplateNode->GetNodeItem(XFA_NODEITEM_FirstChild);
              pTemplateChild; pTemplateChild = pTemplateChild->GetNodeItem(
                                  XFA_NODEITEM_NextSibling)) {
           if (NeedGenerateForm(pTemplateChild, bUseInstanceManager)) {
             XFA_NodeMerge_CloneOrMergeContainer(pDocument, pSubform,
                                                 pTemplateChild, true, nullptr);
           } else if (pTemplateChild->IsContainerNode()) {
             pDocument->DataMerge_CopyContainer(pTemplateChild, pSubform,
                                                pDataNode, false, true, false);
           }
         }
       }
-      subformMapArray.RemoveAll();
+      subformMapArray.clear();
     }
 
     for (; iMax < 0 || iCurRepeatIndex < iMax; iCurRepeatIndex++) {
       bool bSelfMatch = false;
       XFA_ATTRIBUTEENUM eBindMatch = XFA_ATTRIBUTEENUM_None;
       if (!FindMatchingDataNode(pDocument, pTemplateNode, pDataScope,
                                 bAccessedDataDOM, false, &sNodeIterator,
                                 bSelfMatch, eBindMatch, true)) {
         break;
       }
@@ skipping 706 matching lines @@
   }
 }
 
 void CXFA_Document::DoDataRemerge(bool bDoDataMerge) {
   CXFA_Node* pFormRoot = ToNode(GetXFAObject(XFA_HASHCODE_Form));
   if (pFormRoot) {
     while (CXFA_Node* pNode = pFormRoot->GetNodeItem(XFA_NODEITEM_FirstChild))
       pFormRoot->RemoveChild(pNode);
     pFormRoot->SetObject(XFA_ATTRIBUTE_BindingNode, nullptr);
   }
-  m_rgGlobalBinding.RemoveAll();
+  m_rgGlobalBinding.clear();
   if (bDoDataMerge)
     DoDataMerge();
 
   CXFA_LayoutProcessor* pLayoutProcessor = GetLayoutProcessor();
   pLayoutProcessor->SetForceReLayout(true);
 }