Revert "Add type cast definitions for CPDF_Reference."

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 240 matching lines @@
     if (RootObjNum == 0) {
       return PDFPARSE_ERROR_FORMAT;
     }
     dwRet = SetEncryptHandler();
     if (dwRet != PDFPARSE_ERROR_SUCCESS) {
       return dwRet;
     }
   }
   if (m_pSecurityHandler && !m_pSecurityHandler->IsMetadataEncrypted()) {
     CPDF_Reference* pMetadata =
-        ToReference(m_pDocument->GetRoot()->GetElement(FX_BSTRC("Metadata")));
-    if (pMetadata)
+        (CPDF_Reference*)m_pDocument->GetRoot()->GetElement(
+            FX_BSTRC("Metadata"));
+    if (pMetadata && pMetadata->GetType() == PDFOBJ_REFERENCE) {
       m_Syntax.m_MetadataObjnum = pMetadata->GetRefObjNum();
+    }
   }
   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 (CPDF_Dictionary* pEncryptDict = pEncryptObj->AsDictionary()) {
       SetEncryptDictionary(pEncryptDict);
-    } else if (CPDF_Reference* pRef = pEncryptObj->AsReference()) {
-      pEncryptObj = m_pDocument->GetIndirectObject(pRef->GetRefObjNum());
-      if (pEncryptObj)
+    } 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;
     if (!m_pSecurityHandler) {
       return PDFPARSE_ERROR_HANDLER;
     }
     if (!m_pSecurityHandler->OnInit(this, m_pEncryptDict)) {
       return err;
     }
@@ skipping 538 matching lines @@
               if (pObj) {
                 if (!pObj->IsDictionary() && !pObj->AsStream()) {
                   pObj->Release();
                 } else {
                   CPDF_Stream* pStream = pObj->AsStream();
                   if (CPDF_Dictionary* pTrailer =
                           pStream ? pStream->GetDict() : pObj->AsDictionary()) {
                     if (m_pTrailer) {
                       CPDF_Object* pRoot =
                           pTrailer->GetElement(FX_BSTRC("Root"));
-                      CPDF_Reference* pRef = ToReference(pRoot);
-                      if (!pRoot ||
-                          (pRef &&
+                      if (pRoot == NULL ||
+                          (pRoot->GetType() == PDFOBJ_REFERENCE &&
                            (FX_DWORD)m_CrossRef.GetSize() >
-                               pRef->GetRefObjNum() &&
-                           m_CrossRef.GetAt(pRef->GetRefObjNum()) != 0)) {
+                               ((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();
@@ skipping 263 matching lines @@
     segindex += count;
   }
   pStream->Release();
   return TRUE;
 }
 CPDF_Array* CPDF_Parser::GetIDArray() {
   CPDF_Object* pID = m_pTrailer ? m_pTrailer->GetElement(FX_BSTRC("ID")) : NULL;
   if (!pID)
     return nullptr;
 
-  if (CPDF_Reference* pRef = pID->AsReference()) {
-    pID = ParseIndirectObject(nullptr, pRef->GetRefObjNum());
+  if (pID->GetType() == PDFOBJ_REFERENCE) {
+    pID = ParseIndirectObject(NULL, ((CPDF_Reference*)pID)->GetRefObjNum());
     m_pTrailer->SetAt(FX_BSTRC("ID"), pID);
   }
   return ToArray(pID);
 }
 FX_DWORD CPDF_Parser::GetRootObjNum() {
-  CPDF_Reference* pRef = ToReference(
-      m_pTrailer ? m_pTrailer->GetElement(FX_BSTRC("Root")) : nullptr);
-  return pRef ? pRef->GetRefObjNum() : 0;
+  CPDF_Object* pRef =
+      m_pTrailer ? m_pTrailer->GetElement(FX_BSTRC("Root")) : NULL;
+  if (pRef == NULL || pRef->GetType() != PDFOBJ_REFERENCE) {
+    return 0;
+  }
+  return ((CPDF_Reference*)pRef)->GetRefObjNum();
 }
 FX_DWORD CPDF_Parser::GetInfoObjNum() {
-  CPDF_Reference* pRef = ToReference(
-      m_pTrailer ? m_pTrailer->GetElement(FX_BSTRC("Info")) : nullptr);
-  return pRef ? pRef->GetRefObjNum() : 0;
+  CPDF_Object* pRef =
+      m_pTrailer ? m_pTrailer->GetElement(FX_BSTRC("Info")) : NULL;
+  if (pRef == NULL || pRef->GetType() != PDFOBJ_REFERENCE) {
+    return 0;
+  }
+  return ((CPDF_Reference*)pRef)->GetRefObjNum();
 }
 FX_BOOL CPDF_Parser::IsFormStream(FX_DWORD objnum, FX_BOOL& bForm) {
   bForm = FALSE;
   if (objnum >= (FX_DWORD)m_CrossRef.GetSize()) {
     return TRUE;
   }
   if (m_V5Type[objnum] == 0) {
     return TRUE;
   }
   if (m_V5Type[objnum] == 2) {
@@ skipping 447 matching lines @@
     RootObjNum = GetRootObjNum();
     if (RootObjNum == 0) {
       return PDFPARSE_ERROR_FORMAT;
     }
     dwRet = SetEncryptHandler();
     if (dwRet != PDFPARSE_ERROR_SUCCESS) {
       return dwRet;
     }
   }
   if (m_pSecurityHandler && m_pSecurityHandler->IsMetadataEncrypted()) {
-    if (CPDF_Reference* pMetadata = ToReference(
-            m_pDocument->GetRoot()->GetElement(FX_BSTRC("Metadata"))))
-      m_Syntax.m_MetadataObjnum = pMetadata->GetRefObjNum();
+    CPDF_Object* pMetadata =
+        m_pDocument->GetRoot()->GetElement(FX_BSTRC("Metadata"));
+    if (pMetadata && pMetadata->GetType() == PDFOBJ_REFERENCE) {
+      m_Syntax.m_MetadataObjnum = ((CPDF_Reference*)pMetadata)->GetRefObjNum();
+    }
   }
   return PDFPARSE_ERROR_SUCCESS;
 }
 FX_BOOL CPDF_Parser::LoadLinearizedAllCrossRefV5(FX_FILESIZE xrefpos) {
   if (!LoadCrossRefV5(xrefpos, xrefpos, FALSE)) {
     return FALSE;
   }
   while (xrefpos)
     if (!LoadCrossRefV5(xrefpos, xrefpos, FALSE)) {
       return FALSE;
@@ skipping 732 matching lines @@
     markers = 1;
   }
   return markers;
 }
 CPDF_Stream* CPDF_SyntaxParser::ReadStream(CPDF_Dictionary* pDict,
                                            PARSE_CONTEXT* pContext,
                                            FX_DWORD objnum,
                                            FX_DWORD gennum) {
   CPDF_Object* pLenObj = pDict->GetElement(FX_BSTRC("Length"));
   FX_FILESIZE len = -1;
-  CPDF_Reference* pLenObjRef = ToReference(pLenObj);
-
-  bool differingObjNum = pLenObjRef && pLenObjRef->GetObjList() &&
-                         pLenObjRef->GetRefObjNum() != objnum;
-  if (pLenObj && differingObjNum)
+  if (pLenObj && ((pLenObj->GetType() != PDFOBJ_REFERENCE) ||
+                  ((((CPDF_Reference*)pLenObj)->GetObjList()) &&
+                   ((CPDF_Reference*)pLenObj)->GetRefObjNum() != objnum))) {
     len = pLenObj->GetInteger();
-
+  }
   // Locate the start of stream.
   ToNextLine();
   FX_FILESIZE streamStartPos = m_Pos;
   if (pContext) {
     pContext->m_DataStart = streamStartPos;
   }
   const unsigned int ENDSTREAM_LEN = sizeof("endstream") - 1;
   const unsigned int ENDOBJ_LEN = sizeof("endobj") - 1;
   CPDF_CryptoHandler* pCryptoHandler =
       objnum == (FX_DWORD)m_MetadataObjnum ? nullptr : m_pCryptoHandler.get();
@@ skipping 665 matching lines @@
         while (pos) {
           CPDF_Object* value;
           CFX_ByteString key;
           value = pDict->GetNextElement(pos, key);
           if (key != "Parent") {
             new_obj_array.Add(value);
           }
         }
       } break;
       case PDFOBJ_REFERENCE: {
-        CPDF_Reference* pRef = pObj->AsReference();
+        CPDF_Reference* pRef = (CPDF_Reference*)pObj;
         FX_DWORD dwNum = pRef->GetRefObjNum();
         FX_FILESIZE offset;
         FX_DWORD original_size = GetObjectSize(dwNum, offset);
         pdfium::base::CheckedNumeric<FX_DWORD> size = original_size;
         if (size.ValueOrDefault(0) == 0 || offset < 0 ||
             offset >= m_dwFileLen) {
           break;
         }
 
         size += offset;
@@ skipping 21 matching lines @@
             new_obj_array.Add(pReferred);
           }
         }
       } break;
     }
   }
   if (count > 0) {
     int32_t iSize = new_obj_array.GetSize();
     for (i = 0; i < iSize; ++i) {
       CPDF_Object* pObj = (CPDF_Object*)new_obj_array[i];
-      if (CPDF_Reference* pRef = pObj->AsReference()) {
+      int32_t type = pObj->GetType();
+      if (type == PDFOBJ_REFERENCE) {
+        CPDF_Reference* pRef = (CPDF_Reference*)pObj;
         FX_DWORD dwNum = pRef->GetRefObjNum();
-        if (!m_objnum_array.Find(dwNum))
+        if (!m_objnum_array.Find(dwNum)) {
           ret_array.Add(pObj);
+        }
       } else {
         ret_array.Add(pObj);
       }
     }
     return FALSE;
   }
   obj_array.RemoveAll();
   obj_array.Append(new_obj_array);
   return IsObjectsAvail(obj_array, FALSE, pHints, ret_array);
 }
@@ skipping 247 matching lines @@
       m_docStatus = PDF_DATAAVAIL_LOADALLFILE;
       return TRUE;
     }
     return FALSE;
   }
   CPDF_Dictionary* pDict = m_pRoot->GetDict();
   if (!pDict) {
     m_docStatus = PDF_DATAAVAIL_ERROR;
     return FALSE;
   }
-  CPDF_Reference* pRef = ToReference(pDict->GetElement(FX_BSTRC("Pages")));
-  if (!pRef) {
+  CPDF_Reference* pRef = (CPDF_Reference*)pDict->GetElement(FX_BSTRC("Pages"));
+  if (pRef == NULL || pRef->GetType() != PDFOBJ_REFERENCE) {
     m_docStatus = PDF_DATAAVAIL_ERROR;
     return FALSE;
   }
-
   m_PagesObjNum = pRef->GetRefObjNum();
   CPDF_Reference* pAcroFormRef =
-      ToReference(m_pRoot->GetDict()->GetElement(FX_BSTRC("AcroForm")));
-  if (pAcroFormRef) {
+      (CPDF_Reference*)m_pRoot->GetDict()->GetElement(FX_BSTRC("AcroForm"));
+  if (pAcroFormRef && pAcroFormRef->GetType() == PDFOBJ_REFERENCE) {
     m_bHaveAcroForm = TRUE;
     m_dwAcroFormObjNum = pAcroFormRef->GetRefObjNum();
   }
-
   if (m_dwInfoObjNum) {
     m_docStatus = PDF_DATAAVAIL_INFO;
   } else {
-    m_docStatus =
-        m_bHaveAcroForm ? PDF_DATAAVAIL_ACROFORM : PDF_DATAAVAIL_PAGETREE;
+    if (m_bHaveAcroForm) {
+      m_docStatus = PDF_DATAAVAIL_ACROFORM;
+    } else {
+      m_docStatus = PDF_DATAAVAIL_PAGETREE;
+    }
   }
   return TRUE;
 }
 FX_BOOL CPDF_DataAvail::PreparePageItem() {
   CPDF_Dictionary* pRoot = m_pDocument->GetRoot();
   CPDF_Reference* pRef =
-      ToReference(pRoot ? pRoot->GetElement(FX_BSTRC("Pages")) : nullptr);
-  if (!pRef) {
+      pRoot ? (CPDF_Reference*)pRoot->GetElement(FX_BSTRC("Pages")) : NULL;
+  if (pRef == NULL || pRef->GetType() != PDFOBJ_REFERENCE) {
     m_docStatus = PDF_DATAAVAIL_ERROR;
     return FALSE;
   }
-
   m_PagesObjNum = pRef->GetRefObjNum();
   m_pCurrentParser = (CPDF_Parser*)m_pDocument->GetParser();
   m_docStatus = PDF_DATAAVAIL_PAGETREE;
   return TRUE;
 }
 FX_BOOL CPDF_DataAvail::IsFirstCheck(int iPage) {
   if (m_pageMapCheckState.find(iPage) != m_pageMapCheckState.end())
     return FALSE;
 
   m_pageMapCheckState.insert(iPage);
@@ skipping 12 matching lines @@
     if (!pObj) {
       if (bExist) {
         UnavailObjList.Add(dwPageObjNum);
       }
       continue;
     }
     if (pObj->IsArray()) {
       CPDF_Array* pArray = pObj->GetArray();
       if (pArray) {
         int32_t iSize = pArray->GetCount();
+        CPDF_Object* pItem = NULL;
         for (int32_t j = 0; j < iSize; ++j) {
-          if (CPDF_Reference* pRef = ToReference(pArray->GetElement(j)))
-            UnavailObjList.Add(pRef->GetRefObjNum());
+          pItem = pArray->GetElement(j);
+          if (pItem && pItem->GetType() == PDFOBJ_REFERENCE) {
+            UnavailObjList.Add(((CPDF_Reference*)pItem)->GetRefObjNum());
+          }
         }
       }
     }
     if (!pObj->IsDictionary()) {
       pObj->Release();
       continue;
     }
     CFX_ByteString type = pObj->GetDict()->GetString(FX_BSTRC("Type"));
     if (type == FX_BSTRC("Pages")) {
       m_PagesArray.Add(pObj);
@@ skipping 34 matching lines @@
   if (!pParser) {
     m_docStatus = PDF_DATAAVAIL_ERROR;
     return FALSE;
   }
   CPDF_Dictionary* pDict = pPages->GetDict();
   CPDF_Object* pKids = pDict ? pDict->GetElement(FX_BSTRC("Kids")) : NULL;
   if (!pKids) {
     return TRUE;
   }
   switch (pKids->GetType()) {
-    case PDFOBJ_REFERENCE:
-      m_PageObjList.Add(pKids->AsReference()->GetRefObjNum());
-      break;
+    case PDFOBJ_REFERENCE: {
+      CPDF_Reference* pKid = (CPDF_Reference*)pKids;
+      m_PageObjList.Add(pKid->GetRefObjNum());
+    } break;
     case PDFOBJ_ARRAY: {
       CPDF_Array* pKidsArray = pKids->AsArray();
       for (FX_DWORD i = 0; i < pKidsArray->GetCount(); ++i) {
-        if (CPDF_Reference* pRef = ToReference(pKidsArray->GetElement(i)))
-          m_PageObjList.Add(pRef->GetRefObjNum());
+        CPDF_Object* pKid = (CPDF_Object*)pKidsArray->GetElement(i);
+        if (pKid && pKid->GetType() == PDFOBJ_REFERENCE) {
+          m_PageObjList.Add(((CPDF_Reference*)pKid)->GetRefObjNum());
+        }
       }
     } break;
     default:
       m_docStatus = PDF_DATAAVAIL_ERROR;
       return FALSE;
   }
   return TRUE;
 }
 FX_BOOL CPDF_DataAvail::CheckPages(IFX_DownloadHints* pHints) {
   FX_BOOL bExist = FALSE;
@@ skipping 478 matching lines @@
     if (!pTrailer) {
       m_Pos += m_syntaxParser.SavePos();
       pHints->AddSegment(m_Pos, iTrailerSize);
       return FALSE;
     }
     if (!pTrailer->IsDictionary())
       return FALSE;
 
     CPDF_Dictionary* pTrailerDict = pTrailer->GetDict();
     CPDF_Object* pEncrypt = pTrailerDict->GetElement("Encrypt");
-    if (ToReference(pEncrypt)) {
+    if (pEncrypt && pEncrypt->GetType() == PDFOBJ_REFERENCE) {
       m_docStatus = PDF_DATAAVAIL_LOADALLFILE;
       return TRUE;
     }
 
     FX_DWORD xrefpos = GetDirectInteger(pTrailerDict, FX_BSTRC("Prev"));
     if (xrefpos) {
       m_dwPrevXRefOffset = GetDirectInteger(pTrailerDict, FX_BSTRC("XRefStm"));
       if (m_dwPrevXRefOffset) {
         m_docStatus = PDF_DATAAVAIL_LOADALLFILE;
       } else {
@@ skipping 58 matching lines @@
 
   CPDF_Array* pArray = pPages->AsArray();
   if (!pArray) {
     pPages->Release();
     m_docStatus = PDF_DATAAVAIL_ERROR;
     return FALSE;
   }
 
   pPageNode->m_type = PDF_PAGENODE_PAGES;
   for (FX_DWORD i = 0; i < pArray->GetCount(); ++i) {
-    CPDF_Reference* pKid = ToReference(pArray->GetElement(i));
-    if (!pKid)
+    CPDF_Object* pKid = (CPDF_Object*)pArray->GetElement(i);
+    if (!pKid || pKid->GetType() != PDFOBJ_REFERENCE) {
       continue;
-
+    }
     CPDF_PageNode* pNode = new CPDF_PageNode();
     pPageNode->m_childNode.Add(pNode);
-    pNode->m_dwPageNo = pKid->GetRefObjNum();
+    pNode->m_dwPageNo = ((CPDF_Reference*)pKid)->GetRefObjNum();
   }
   pPages->Release();
   return TRUE;
 }
 FX_BOOL CPDF_DataAvail::CheckUnkownPageNode(FX_DWORD dwPageNo,
                                             CPDF_PageNode* pPageNode,
                                             IFX_DownloadHints* pHints) {
   FX_BOOL bExist = FALSE;
   CPDF_Object* pPage = GetObject(dwPageNo, pHints, &bExist);
   if (!bExist) {
@@ skipping 23 matching lines @@
   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"));
     if (!pKids) {
       m_docStatus = PDF_DATAAVAIL_PAGE;
       return TRUE;
     }
     switch (pKids->GetType()) {
       case PDFOBJ_REFERENCE: {
-        CPDF_Reference* pKid = pKids->AsReference();
+        CPDF_Reference* pKid = (CPDF_Reference*)pKids;
         CPDF_PageNode* pNode = new CPDF_PageNode();
         pPageNode->m_childNode.Add(pNode);
         pNode->m_dwPageNo = pKid->GetRefObjNum();
       } break;
       case PDFOBJ_ARRAY: {
         CPDF_Array* pKidsArray = pKids->AsArray();
         for (FX_DWORD i = 0; i < pKidsArray->GetCount(); ++i) {
-          CPDF_Reference* pKid = ToReference(pKidsArray->GetElement(i));
-          if (!pKid)
+          CPDF_Object* pKid = (CPDF_Object*)pKidsArray->GetElement(i);
+          if (!pKid || pKid->GetType() != PDFOBJ_REFERENCE) {
             continue;
-
+          }
           CPDF_PageNode* pNode = new CPDF_PageNode();
           pPageNode->m_childNode.Add(pNode);
-          pNode->m_dwPageNo = pKid->GetRefObjNum();
+          pNode->m_dwPageNo = ((CPDF_Reference*)pKid)->GetRefObjNum();
         }
       } break;
       default:
         break;
     }
   } else if (type == FX_BSTRC("Page")) {
     pPageNode->m_type = PDF_PAGENODE_PAGE;
   } else {
     pPage->Release();
     m_docStatus = PDF_DATAAVAIL_ERROR;
@@ skipping 418 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();
 }