Revert "Revert "Add type cast definitions for CPDF_Dictionary.""

core/src/fpdfapi/fpdf_parser/fpdf_parser_parser.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 <set>
 #include <utility>
 #include <vector>
 
@@ skipping 259 matching lines @@
   return PDFPARSE_ERROR_SUCCESS;
 }
 FX_DWORD CPDF_Parser::SetEncryptHandler() {
   ReleaseEncryptHandler();
   SetEncryptDictionary(NULL);
   if (m_pTrailer == NULL) {
     return PDFPARSE_ERROR_FORMAT;
   }
   CPDF_Object* pEncryptObj = m_pTrailer->GetElement(FX_BSTRC("Encrypt"));
   if (pEncryptObj) {
-    if (pEncryptObj->GetType() == PDFOBJ_DICTIONARY) {
-      SetEncryptDictionary((CPDF_Dictionary*)pEncryptObj);
+    if (CPDF_Dictionary* pEncryptDict = pEncryptObj->AsDictionary()) {
+      SetEncryptDictionary(pEncryptDict);
     } else if (pEncryptObj->GetType() == PDFOBJ_REFERENCE) {
       pEncryptObj = m_pDocument->GetIndirectObject(
           ((CPDF_Reference*)pEncryptObj)->GetRefObjNum());
       if (pEncryptObj) {
         SetEncryptDictionary(pEncryptObj->GetDict());
       }
     }
   }
   if (m_bForceUseSecurityHandler) {
     FX_DWORD err = PDFPARSE_ERROR_HANDLER;
@@ skipping 505 matching lines @@
                             pDict->GetString(FX_BSTRC("Type"));
                         if (bsValue == FX_BSTRC("XRef") &&
                             pDict->KeyExist(FX_BSTRC("Size"))) {
                           CPDF_Object* pRoot =
                               pDict->GetElement(FX_BSTRC("Root"));
                           if (pRoot && pRoot->GetDict() &&
                               pRoot->GetDict()->GetElement(FX_BSTRC("Pages"))) {
                             if (m_pTrailer) {
                               m_pTrailer->Release();
                             }
-                            m_pTrailer = (CPDF_Dictionary*)pDict->Clone();
+                            m_pTrailer = ToDictionary(pDict->Clone());
                           }
                         }
                       }
                     }
                   }
                 }
                 FX_FILESIZE offset = 0;
                 m_Syntax.RestorePos(obj_pos);
                 offset = m_Syntax.FindTag(FX_BSTRC("obj"), 0);
                 if (offset == -1) {
@@ skipping 32 matching lines @@
               break;
           }
           break;
         case 7:
           if (inside_index == 7) {
             if (PDF_CharType[byte] == 'W' || PDF_CharType[byte] == 'D') {
               last_trailer = pos + i - 7;
               m_Syntax.RestorePos(pos + i - m_Syntax.m_HeaderOffset);
               CPDF_Object* pObj = m_Syntax.GetObject(m_pDocument, 0, 0, 0);
               if (pObj) {
-                if (pObj->GetType() != PDFOBJ_DICTIONARY &&
-                    pObj->GetType() != PDFOBJ_STREAM) {
+                if (!pObj->IsDictionary() && pObj->GetType() != PDFOBJ_STREAM) {
                   pObj->Release();
                 } else {
                   CPDF_Dictionary* pTrailer = NULL;
                   if (pObj->GetType() == PDFOBJ_STREAM) {
                     pTrailer = ((CPDF_Stream*)pObj)->GetDict();
                   } else {
-                    pTrailer = (CPDF_Dictionary*)pObj;
+                    pTrailer = pObj->AsDictionary();
                   }
                   if (pTrailer) {
                     if (m_pTrailer) {
                       CPDF_Object* pRoot =
                           pTrailer->GetElement(FX_BSTRC("Root"));
                       if (pRoot == NULL ||
                           (pRoot->GetType() == PDFOBJ_REFERENCE &&
                            (FX_DWORD)m_CrossRef.GetSize() >
                                ((CPDF_Reference*)pRoot)->GetRefObjNum() &&
                            m_CrossRef.GetAt(((CPDF_Reference*)pRoot)
                                                 ->GetRefObjNum()) != 0)) {
                         FX_POSITION pos = pTrailer->GetStartPos();
                         while (pos) {
                           CFX_ByteString key;
                           CPDF_Object* pObj =
                               pTrailer->GetNextElement(pos, key);
                           m_pTrailer->SetAt(key, pObj->Clone(), m_pDocument);
                         }
                         pObj->Release();
                       } else {
                         pObj->Release();
                       }
                     } else {
                       if (pObj->GetType() == PDFOBJ_STREAM) {
-                        m_pTrailer = (CPDF_Dictionary*)pTrailer->Clone();
+                        m_pTrailer = ToDictionary(pTrailer->Clone());
                         pObj->Release();
                       } else {
                         m_pTrailer = pTrailer;
                       }
                       FX_FILESIZE dwSavePos = m_Syntax.SavePos();
                       CFX_ByteString strWord = m_Syntax.GetKeyword();
                       if (!strWord.Compare(FX_BSTRC("startxref"))) {
                         FX_BOOL bNumber = FALSE;
                         CFX_ByteString bsOffset = m_Syntax.GetNextWord(bNumber);
                         if (bNumber) {
@@ skipping 123 matching lines @@
   if (pStream->GetType() != PDFOBJ_STREAM) {
     return FALSE;
   }
   prev = pStream->GetDict()->GetInteger(FX_BSTRC("Prev"));
   int32_t size = pStream->GetDict()->GetInteger(FX_BSTRC("Size"));
   if (size < 0) {
     pStream->Release();
     return FALSE;
   }
   if (bMainXRef) {
-    m_pTrailer = (CPDF_Dictionary*)pStream->GetDict()->Clone();
+    m_pTrailer = ToDictionary(pStream->GetDict()->Clone());
     m_CrossRef.SetSize(size);
     if (m_V5Type.SetSize(size)) {
       FXSYS_memset(m_V5Type.GetData(), 0, size);
     }
   } else {
-    m_Trailers.Add((CPDF_Dictionary*)pStream->GetDict()->Clone());
+    m_Trailers.Add(ToDictionary(pStream->GetDict()->Clone()));
   }
   std::vector<std::pair<int32_t, int32_t> > arrIndex;
   CPDF_Array* pArray = pStream->GetDict()->GetArray(FX_BSTRC("Index"));
   if (pArray) {
     FX_DWORD nPairSize = pArray->GetCount() / 2;
     for (FX_DWORD i = 0; i < nPairSize; i++) {
       CPDF_Object* pStartNumObj = pArray->GetElement(i * 2);
       CPDF_Object* pCountObj = pArray->GetElement(i * 2 + 1);
       if (pStartNumObj && pStartNumObj->GetType() == PDFOBJ_NUMBER &&
           pCountObj && pCountObj->GetType() == PDFOBJ_NUMBER) {
@@ skipping 429 matching lines @@
   m_Syntax.RestorePos(SavedPos);
   return pObj;
 }
 
 CPDF_Dictionary* CPDF_Parser::LoadTrailerV4() {
   if (m_Syntax.GetKeyword() != FX_BSTRC("trailer"))
     return nullptr;
 
   nonstd::unique_ptr<CPDF_Object, ReleaseDeleter<CPDF_Object>> pObj(
       m_Syntax.GetObject(m_pDocument, 0, 0, 0));
-  if (!pObj || pObj->GetType() != PDFOBJ_DICTIONARY)
+  if (!ToDictionary(pObj.get()))
     return nullptr;
-  return static_cast<CPDF_Dictionary*>(pObj.release());
+  return pObj.release()->AsDictionary();
 }
 
 FX_DWORD CPDF_Parser::GetPermissions(FX_BOOL bCheckRevision) {
   if (m_pSecurityHandler == NULL) {
     return (FX_DWORD)-1;
   }
   FX_DWORD dwPermission = m_pSecurityHandler->GetPermissions();
   if (m_pEncryptDict &&
       m_pEncryptDict->GetString(FX_BSTRC("Filter")) == FX_BSTRC("Standard")) {
     dwPermission &= 0xFFFFFFFC;
@@ skipping 1977 matching lines @@
         int32_t iSize = pArray->GetCount();
         CPDF_Object* pItem = NULL;
         for (int32_t j = 0; j < iSize; ++j) {
           pItem = pArray->GetElement(j);
           if (pItem && pItem->GetType() == PDFOBJ_REFERENCE) {
             UnavailObjList.Add(((CPDF_Reference*)pItem)->GetRefObjNum());
           }
         }
       }
     }
-    if (pObj->GetType() != PDFOBJ_DICTIONARY) {
+    if (!pObj->IsDictionary()) {
       pObj->Release();
       continue;
     }
     CFX_ByteString type = pObj->GetDict()->GetString(FX_BSTRC("Type"));
     if (type == FX_BSTRC("Pages")) {
       m_PagesArray.Add(pObj);
       continue;
     }
     pObj->Release();
   }
@@ skipping 532 matching lines @@
     }
     ScopedFileStream file(FX_CreateMemoryStream(pBuf, (size_t)iSize, FALSE));
     m_syntaxParser.InitParser(file.get(), 0);
     nonstd::unique_ptr<CPDF_Object, ReleaseDeleter<CPDF_Object>> pTrailer(
         m_syntaxParser.GetObject(nullptr, 0, 0));
     if (!pTrailer) {
       m_Pos += m_syntaxParser.SavePos();
       pHints->AddSegment(m_Pos, iTrailerSize);
       return FALSE;
     }
-    if (pTrailer->GetType() != PDFOBJ_DICTIONARY)
+    if (!pTrailer->IsDictionary())
       return FALSE;
 
     CPDF_Dictionary* pTrailerDict = pTrailer->GetDict();
     CPDF_Object* pEncrypt = pTrailerDict->GetElement("Encrypt");
     if (pEncrypt && pEncrypt->GetType() == PDFOBJ_REFERENCE) {
       m_docStatus = PDF_DATAAVAIL_LOADALLFILE;
       return TRUE;
     }
 
     FX_DWORD xrefpos = GetDirectInteger(pTrailerDict, FX_BSTRC("Prev"));
@@ skipping 94 matching lines @@
       return FALSE;
     }
     return FALSE;
   }
   if (pPage->GetType() == PDFOBJ_ARRAY) {
     pPageNode->m_dwPageNo = dwPageNo;
     pPageNode->m_type = PDF_PAGENODE_ARRAY;
     pPage->Release();
     return TRUE;
   }
-  if (pPage->GetType() != PDFOBJ_DICTIONARY) {
+  if (!pPage->IsDictionary()) {
     pPage->Release();
     m_docStatus = PDF_DATAAVAIL_ERROR;
     return FALSE;
   }
   pPageNode->m_dwPageNo = dwPageNo;
   CPDF_Dictionary* pDict = pPage->GetDict();
   CFX_ByteString type = pDict->GetString(FX_BSTRC("Type"));
   if (type == FX_BSTRC("Pages")) {
     pPageNode->m_type = PDF_PAGENODE_PAGES;
     CPDF_Object* pKids = pDict->GetElement(FX_BSTRC("Kids"));
@@ skipping 445 matching lines @@
   return FALSE;
 }
 CPDF_PageNode::~CPDF_PageNode() {
   int32_t iSize = m_childNode.GetSize();
   for (int32_t i = 0; i < iSize; ++i) {
     CPDF_PageNode* pNode = (CPDF_PageNode*)m_childNode[i];
     delete pNode;
   }
   m_childNode.RemoveAll();
 }