Use std::map in xfa_ffdoc.cpp

xfa/fxfa/app/xfa_ffdoc.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/include/xfa_ffdoc.h"
 
+#include <algorithm>
+
 #include "core/fpdfapi/fpdf_parser/include/cpdf_array.h"
 #include "core/fpdfapi/fpdf_parser/include/cpdf_document.h"
 #include "core/fpdfdoc/include/fpdf_doc.h"
 #include "core/fxcrt/include/fx_ext.h"
 #include "core/fxcrt/include/fx_memory.h"
 #include "xfa/fde/xml/fde_xml_imp.h"
 #include "xfa/fgas/crt/fgas_algorithm.h"
 #include "xfa/fwl/core/ifwl_notedriver.h"
 #include "xfa/fxfa/app/xfa_ffnotify.h"
 #include "xfa/fxfa/include/xfa_checksum.h"
@@ skipping 162 matching lines @@
   CXFA_Node* pDynamicRender =
       pAcrobat7->GetFirstChildByClass(XFA_ELEMENT_DynamicRender);
   if (!pDynamicRender) {
     return;
   }
   CFX_WideString wsType;
   if (pDynamicRender->TryContent(wsType) && wsType == FX_WSTRC(L"required")) {
     m_dwDocType = XFA_DOCTYPE_Dynamic;
   }
 }
+
 CXFA_FFDocView* CXFA_FFDoc::CreateDocView(uint32_t dwView) {
-  CXFA_FFDocView* pDocView =
-      (CXFA_FFDocView*)m_mapTypeToDocView.GetValueAt((void*)(uintptr_t)dwView);
-  if (!pDocView) {
-    pDocView = new CXFA_FFDocView(this);
-    m_mapTypeToDocView.SetAt((void*)(uintptr_t)dwView, pDocView);
-  }
+  auto it = m_TypeToDocViewMap.find(dwView);
+  if (it != m_TypeToDocViewMap.end())
+    return it->second;
+
+  CXFA_FFDocView* pDocView = new CXFA_FFDocView(this);
+  m_TypeToDocViewMap[dwView] = pDocView;
   return pDocView;
 }
+
 CXFA_FFDocView* CXFA_FFDoc::GetDocView(CXFA_LayoutProcessor* pLayout) {
-  FX_POSITION ps = m_mapTypeToDocView.GetStartPosition();
-  while (ps) {
-    void* pType;
-    CXFA_FFDocView* pDocView;
-    m_mapTypeToDocView.GetNextAssoc(ps, pType, (void*&)pDocView);
-    if (pDocView->GetXFALayout() == pLayout) {
-      return pDocView;
-    }
-  }
-  return NULL;
+  auto it =
+      std::find_if(m_TypeToDocViewMap.begin(), m_TypeToDocViewMap.end(),
+                   [pLayout](const std::pair<uint32_t, CXFA_FFDocView*>& pair) {
+                     return pair.second->GetXFALayout() == pLayout;
+                   });
+  return it != m_TypeToDocViewMap.end() ? it->second : nullptr;
 }
+
 CXFA_FFDocView* CXFA_FFDoc::GetDocView() {
-  FX_POSITION ps = m_mapTypeToDocView.GetStartPosition();
-  if (ps) {
-    void* pType;
-    CXFA_FFDocView* pDocView;
-    m_mapTypeToDocView.GetNextAssoc(ps, pType, (void*&)pDocView);
-    return pDocView;
-  }
-  return NULL;
+  auto it = m_TypeToDocViewMap.begin();
+  return it != m_TypeToDocViewMap.end() ? it->second : nullptr;
 }
+
 FX_BOOL CXFA_FFDoc::OpenDoc(IFX_FileRead* pStream, FX_BOOL bTakeOverFile) {
   m_bOwnStream = bTakeOverFile;
   m_pStream = pStream;
   return TRUE;
 }
 FX_BOOL CXFA_FFDoc::OpenDoc(CPDF_Document* pPDFDoc) {
   if (pPDFDoc == NULL) {
     return FALSE;
   }
   CPDF_Dictionary* pRoot = pPDFDoc->GetRoot();
@@ skipping 25 matching lines @@
   m_pPDFDoc = pPDFDoc;
   if (m_pStream) {
     m_pStream->Release();
     m_pStream = NULL;
   }
   m_pStream = pFileRead;
   m_bOwnStream = TRUE;
   return TRUE;
 }
 FX_BOOL CXFA_FFDoc::CloseDoc() {
-  FX_POSITION psClose = m_mapTypeToDocView.GetStartPosition();
-  while (psClose) {
-    void* pType;
-    CXFA_FFDocView* pDocView;
-    m_mapTypeToDocView.GetNextAssoc(psClose, pType, (void*&)pDocView);
-    pDocView->RunDocClose();
+  for (const auto& pair : m_TypeToDocViewMap)
+    pair.second->RunDocClose();
+
+  if (m_pDocument)
+    m_pDocument->ClearLayoutData();
+
+  for (const auto& pair : m_TypeToDocViewMap)
+    delete pair.second;
+
+  m_TypeToDocViewMap.clear();
+
+  if (m_pDocument) {
+    m_pDocument->GetParser()->Release();
+    m_pDocument = nullptr;
   }
-  if (m_pDocument) {
-    m_pDocument->ClearLayoutData();
-  }
-  FX_POSITION ps = m_mapTypeToDocView.GetStartPosition();
-  while (ps) {
-    void* pType;
-    CXFA_FFDocView* pDocView;
-    m_mapTypeToDocView.GetNextAssoc(ps, pType, (void*&)pDocView);
-    delete pDocView;
-  }
-  m_mapTypeToDocView.RemoveAll();
-  if (m_pDocument) {
-    IXFA_Parser* pParser = m_pDocument->GetParser();
-    pParser->Release();
-    m_pDocument = NULL;
-  }
-  if (m_pNotify) {
-    delete m_pNotify;
-    m_pNotify = NULL;
-  }
+
+  delete m_pNotify;
+  m_pNotify = nullptr;
+
   m_pApp->GetXFAFontMgr()->ReleaseDocFonts(this);
+
   if (m_dwDocType != XFA_DOCTYPE_XDP && m_pStream && m_bOwnStream) {
     m_pStream->Release();
-    m_pStream = NULL;
+    m_pStream = nullptr;
   }
-  ps = m_mapNamedImages.GetStartPosition();
-  while (ps) {
-    void* pName;
-    FX_IMAGEDIB_AND_DPI* pImage = NULL;
-    m_mapNamedImages.GetNextAssoc(ps, pName, (void*&)pImage);
-    if (pImage) {
-      delete pImage->pDibSource;
-      pImage->pDibSource = NULL;
-      FX_Free(pImage);
-      pImage = NULL;
-    }
-  }
-  m_mapNamedImages.RemoveAll();
-  IFWL_NoteDriver* pNoteDriver = FWL_GetApp()->GetNoteDriver();
-  pNoteDriver->ClearEventTargets(FALSE);
+
+  for (const auto& pair : m_HashToDibDpiMap)
+    delete pair.second.pDibSource;
+
+  m_HashToDibDpiMap.clear();
+
+  FWL_GetApp()->GetNoteDriver()->ClearEventTargets(FALSE);
   return TRUE;
 }
 void CXFA_FFDoc::SetDocType(uint32_t dwType) {
   m_dwDocType = dwType;
 }
 CPDF_Document* CXFA_FFDoc::GetPDFDoc() {
   return m_pPDFDoc;
 }
 
 CFX_DIBitmap* CXFA_FFDoc::GetPDFNamedImage(const CFX_WideStringC& wsName,

[Tom Sepez, 2016/04/22 19:16:41]

Should this just return a DIBDPI struct?

[Tom Sepez, 2016/04/22 21:51:40]

Ah, lets just leave it for the moment.

                                            int32_t& iImageXDpi,
                                            int32_t& iImageYDpi) {
   if (!m_pPDFDoc)
     return nullptr;
 
   uint32_t dwHash =
       FX_HashCode_String_GetW(wsName.c_str(), wsName.GetLength(), FALSE);
-  FX_IMAGEDIB_AND_DPI* imageDIBDpi = nullptr;
-  if (m_mapNamedImages.Lookup((void*)(uintptr_t)dwHash, (void*&)imageDIBDpi)) {
-    iImageXDpi = imageDIBDpi->iImageXDpi;
-    iImageYDpi = imageDIBDpi->iImageYDpi;
-    return static_cast<CFX_DIBitmap*>(imageDIBDpi->pDibSource);
+  auto it = m_HashToDibDpiMap.find(dwHash);
+  if (it != m_HashToDibDpiMap.end()) {
+    iImageXDpi = it->second.iImageXDpi;
+    iImageYDpi = it->second.iImageYDpi;
+    return static_cast<CFX_DIBitmap*>(it->second.pDibSource);
   }
 
   CPDF_Dictionary* pRoot = m_pPDFDoc->GetRoot();
   if (!pRoot)
     return nullptr;
 
   CPDF_Dictionary* pNames = pRoot->GetDictBy("Names");
   if (!pNames)
     return nullptr;
 
   CPDF_Dictionary* pXFAImages = pNames->GetDictBy("XFAImages");
   if (!pXFAImages)
     return nullptr;
 
   CPDF_NameTree nametree(pXFAImages);
   CFX_ByteString bsName = PDF_EncodeText(wsName.c_str(), wsName.GetLength());
   CPDF_Object* pObject = nametree.LookupValue(bsName);
   if (!pObject) {
     for (size_t i = 0; i < nametree.GetCount(); i++) {
       CFX_ByteString bsTemp;
       CPDF_Object* pTempObject = nametree.LookupValue(i, bsTemp);
       if (bsTemp == bsName) {
         pObject = pTempObject;
         break;
       }
     }
   }
 
   if (!pObject || !pObject->IsStream())

[Lei Zhang, 2016/04/22 23:37:50]

CPDF_Stream* pStream = ToStream(pObject);
if (!pStream)
  return nullptr.

Use pStream on line 349.

[Tom Sepez, 2016/04/25 18:23:06]

Done.

     return nullptr;
 
-  if (!imageDIBDpi) {
-    imageDIBDpi = FX_Alloc(FX_IMAGEDIB_AND_DPI, 1);
-    imageDIBDpi->pDibSource = nullptr;
-    imageDIBDpi->iImageXDpi = 0;
-    imageDIBDpi->iImageYDpi = 0;
-    CPDF_StreamAcc streamAcc;
-    streamAcc.LoadAllData((CPDF_Stream*)pObject);
-    IFX_FileRead* pImageFileRead = FX_CreateMemoryStream(
-        (uint8_t*)streamAcc.GetData(), streamAcc.GetSize());
-    imageDIBDpi->pDibSource = XFA_LoadImageFromBuffer(
-        pImageFileRead, FXCODEC_IMAGE_UNKNOWN, iImageXDpi, iImageYDpi);
-    imageDIBDpi->iImageXDpi = iImageXDpi;
-    imageDIBDpi->iImageYDpi = iImageYDpi;
-    pImageFileRead->Release();
-  }
-  m_mapNamedImages.SetAt((void*)(uintptr_t)dwHash, imageDIBDpi);
-  return (CFX_DIBitmap*)imageDIBDpi->pDibSource;
+  CPDF_StreamAcc streamAcc;
+  streamAcc.LoadAllData((CPDF_Stream*)pObject);
+
+  IFX_FileRead* pImageFileRead =
+      FX_CreateMemoryStream((uint8_t*)streamAcc.GetData(), streamAcc.GetSize());
+
+  CFX_DIBitmap* pDibSource = XFA_LoadImageFromBuffer(
+      pImageFileRead, FXCODEC_IMAGE_UNKNOWN, iImageXDpi, iImageYDpi);
+  m_HashToDibDpiMap[dwHash] = {pDibSource, iImageXDpi, iImageYDpi};
+  pImageFileRead->Release();
+  return pDibSource;
 }
 
 CFDE_XMLElement* CXFA_FFDoc::GetPackageData(const CFX_WideStringC& wsPackage) {
   uint32_t packetHash =
       FX_HashCode_String_GetW(wsPackage.c_str(), wsPackage.GetLength());
   CXFA_Node* pNode = ToNode(m_pDocument->GetXFAObject(packetHash));
   if (!pNode) {
     return NULL;
   }
   CFDE_XMLNode* pXMLNode = pNode->GetXMLMappingNode();
@@ skipping 26 matching lines @@
   }
   pExport->Release();
   return bFlags;
 }
 FX_BOOL CXFA_FFDoc::ImportData(IFX_FileRead* pStream, FX_BOOL bXDP) {
   std::unique_ptr<CXFA_DataImporter, ReleaseDeleter<CXFA_DataImporter>>
       importer(new CXFA_DataImporter(m_pDocument));
 
   return importer->ImportData(pStream);
 }