Get rid of IPDF_DataAvail.

core/fpdfapi/fpdf_parser/cpdf_data_avail.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 "core/fpdfapi/fpdf_parser/include/ipdf_data_avail.h"
+#include "core/fpdfapi/fpdf_parser/include/cpdf_data_avail.h"
 
-#include "core/fpdfapi/fpdf_parser/cpdf_data_avail.h"
+#include "core/fpdfapi/fpdf_parser/cpdf_hint_tables.h"
 #include "core/fpdfapi/fpdf_parser/fpdf_parser_utility.h"
 #include "core/fpdfapi/fpdf_parser/include/cpdf_array.h"
 #include "core/fpdfapi/fpdf_parser/include/cpdf_dictionary.h"
 #include "core/fpdfapi/fpdf_parser/include/cpdf_document.h"
 #include "core/fpdfapi/fpdf_parser/include/cpdf_name.h"
 #include "core/fpdfapi/fpdf_parser/include/cpdf_number.h"
 #include "core/fpdfapi/fpdf_parser/include/cpdf_reference.h"
 #include "core/fpdfapi/fpdf_parser/include/cpdf_stream.h"
 #include "core/fpdfapi/include/cpdf_modulemgr.h"
 #include "core/fxcrt/include/fx_ext.h"
 #include "core/fxcrt/include/fx_safe_types.h"
 #include "third_party/base/stl_util.h"
 
-IPDF_DataAvail::IPDF_DataAvail(IPDF_DataAvail::FileAvail* pFileAvail,
-                               IFX_FileRead* pFileRead)
-    : m_pFileAvail(pFileAvail), m_pFileRead(pFileRead) {}
+CPDF_DataAvail::FileAvail::~FileAvail() {}
 
-IPDF_DataAvail::~IPDF_DataAvail() {}
-
-IPDF_DataAvail::FileAvail::~FileAvail() {}
-
-IPDF_DataAvail::DownloadHints::~DownloadHints() {}
-
-// static
-IPDF_DataAvail* IPDF_DataAvail::Create(IPDF_DataAvail::FileAvail* pFileAvail,
-                                       IFX_FileRead* pFileRead) {
-  return new CPDF_DataAvail(pFileAvail, pFileRead, TRUE);
-}
+CPDF_DataAvail::DownloadHints::~DownloadHints() {}
 
 // static
 int CPDF_DataAvail::s_CurrentDataAvailRecursionDepth = 0;
 
-CPDF_DataAvail::CPDF_DataAvail(IPDF_DataAvail::FileAvail* pFileAvail,
+CPDF_DataAvail::CPDF_DataAvail(FileAvail* pFileAvail,
                                IFX_FileRead* pFileRead,
                                FX_BOOL bSupportHintTable)
-    : IPDF_DataAvail(pFileAvail, pFileRead) {
+    : m_pFileAvail(pFileAvail), m_pFileRead(pFileRead) {
   m_Pos = 0;
   m_dwFileLen = 0;
   if (m_pFileRead) {
     m_dwFileLen = (uint32_t)m_pFileRead->GetSize();
   }
   m_dwCurrentOffset = 0;
   m_dwXRefOffset = 0;
   m_bufferOffset = 0;
   m_dwFirstPageNo = 0;
   m_bufferSize = 0;
@@ skipping 73 matching lines @@
   if (it == pParser->m_SortedOffset.end() ||
       ++it == pParser->m_SortedOffset.end()) {
     return 0;
   }
   return *it - offset;
 }
 
 FX_BOOL CPDF_DataAvail::IsObjectsAvail(
     CFX_ArrayTemplate<CPDF_Object*>& obj_array,
     FX_BOOL bParsePage,
-    IPDF_DataAvail::DownloadHints* pHints,
+    DownloadHints* pHints,
     CFX_ArrayTemplate<CPDF_Object*>& ret_array) {
   if (!obj_array.GetSize())
     return TRUE;
 
   uint32_t count = 0;
   CFX_ArrayTemplate<CPDF_Object*> new_obj_array;
   for (int i = 0; i < obj_array.GetSize(); i++) {
     CPDF_Object* pObj = obj_array[i];
     if (!pObj)
       continue;
@@ skipping 54 matching lines @@
       }
     }
     return FALSE;
   }
 
   obj_array.RemoveAll();
   obj_array.Append(new_obj_array);
   return IsObjectsAvail(obj_array, FALSE, pHints, ret_array);
 }
 
-IPDF_DataAvail::DocAvailStatus CPDF_DataAvail::IsDocAvail(
-    IPDF_DataAvail::DownloadHints* pHints) {
+CPDF_DataAvail::DocAvailStatus CPDF_DataAvail::IsDocAvail(
+    DownloadHints* pHints) {
   if (!m_dwFileLen && m_pFileRead) {
     m_dwFileLen = (uint32_t)m_pFileRead->GetSize();
     if (!m_dwFileLen)
       return DataError;
   }
 
   while (!m_bDocAvail) {
     if (!CheckDocStatus(pHints))
       return DataNotAvailable;
   }
 
   return DataAvailable;
 }
 
-FX_BOOL CPDF_DataAvail::CheckAcroFormSubObject(
-    IPDF_DataAvail::DownloadHints* pHints) {
+FX_BOOL CPDF_DataAvail::CheckAcroFormSubObject(DownloadHints* pHints) {
   if (!m_objs_array.GetSize()) {
     m_objs_array.RemoveAll();
     m_ObjectSet.clear();
     CFX_ArrayTemplate<CPDF_Object*> obj_array;
     obj_array.Append(m_arrayAcroforms);
     FX_BOOL bRet = IsObjectsAvail(obj_array, FALSE, pHints, m_objs_array);
     if (bRet)
       m_objs_array.RemoveAll();
     return bRet;
   }
 
   CFX_ArrayTemplate<CPDF_Object*> new_objs_array;
   FX_BOOL bRet = IsObjectsAvail(m_objs_array, FALSE, pHints, new_objs_array);
   if (bRet) {
     int32_t iSize = m_arrayAcroforms.GetSize();
     for (int32_t i = 0; i < iSize; ++i) {
       m_arrayAcroforms.GetAt(i)->Release();
     }
     m_arrayAcroforms.RemoveAll();
   } else {
     m_objs_array.RemoveAll();
     m_objs_array.Append(new_objs_array);
   }
   return bRet;
 }
 
-FX_BOOL CPDF_DataAvail::CheckAcroForm(IPDF_DataAvail::DownloadHints* pHints) {
+FX_BOOL CPDF_DataAvail::CheckAcroForm(DownloadHints* pHints) {
   FX_BOOL bExist = FALSE;
   m_pAcroForm = GetObject(m_dwAcroFormObjNum, pHints, &bExist);
   if (!bExist) {
     m_docStatus = PDF_DATAAVAIL_PAGETREE;
     return TRUE;
   }
 
   if (!m_pAcroForm) {
     if (m_docStatus == PDF_DATAAVAIL_ERROR) {
       m_docStatus = PDF_DATAAVAIL_LOADALLFILE;
       return TRUE;
     }
     return FALSE;
   }
 
   m_arrayAcroforms.Add(m_pAcroForm);
   m_docStatus = PDF_DATAAVAIL_PAGETREE;
   return TRUE;
 }
 
-FX_BOOL CPDF_DataAvail::CheckDocStatus(IPDF_DataAvail::DownloadHints* pHints) {
+FX_BOOL CPDF_DataAvail::CheckDocStatus(DownloadHints* pHints) {
   switch (m_docStatus) {
     case PDF_DATAAVAIL_HEADER:
       return CheckHeader(pHints);
     case PDF_DATAAVAIL_FIRSTPAGE:
     case PDF_DATAAVAIL_FIRSTPAGE_PREPARE:
       return CheckFirstPage(pHints);
     case PDF_DATAAVAIL_HINTTABLE:
       return CheckHintTables(pHints);
     case PDF_DATAAVAIL_END:
       return CheckEnd(pHints);
@@ skipping 29 matching lines @@
     case PDF_DATAAVAIL_ERROR:
       return LoadAllFile(pHints);
     case PDF_DATAAVAIL_PAGE_LATERLOAD:
       m_docStatus = PDF_DATAAVAIL_PAGE;
     default:
       m_bDocAvail = TRUE;
       return TRUE;
   }
 }
 
-FX_BOOL CPDF_DataAvail::CheckPageStatus(IPDF_DataAvail::DownloadHints* pHints) {
+FX_BOOL CPDF_DataAvail::CheckPageStatus(DownloadHints* pHints) {
   switch (m_docStatus) {
     case PDF_DATAAVAIL_PAGETREE:
       return CheckPages(pHints);
     case PDF_DATAAVAIL_PAGE:
       return CheckPage(pHints);
     case PDF_DATAAVAIL_ERROR:
       return LoadAllFile(pHints);
     default:
       m_bPagesTreeLoad = TRUE;
       m_bPagesLoad = TRUE;
       return TRUE;
   }
 }
 
-FX_BOOL CPDF_DataAvail::LoadAllFile(IPDF_DataAvail::DownloadHints* pHints) {
+FX_BOOL CPDF_DataAvail::LoadAllFile(DownloadHints* pHints) {
   if (m_pFileAvail->IsDataAvail(0, (uint32_t)m_dwFileLen)) {
     m_docStatus = PDF_DATAAVAIL_DONE;
     return TRUE;
   }
 
   pHints->AddSegment(0, (uint32_t)m_dwFileLen);
   return FALSE;
 }
 
-FX_BOOL CPDF_DataAvail::LoadAllXref(IPDF_DataAvail::DownloadHints* pHints) {
+FX_BOOL CPDF_DataAvail::LoadAllXref(DownloadHints* pHints) {
   m_parser.m_pSyntax->InitParser(m_pFileRead, (uint32_t)m_dwHeaderOffset);
   m_parser.m_bOwnFileRead = false;
   if (!m_parser.LoadAllCrossRefV4(m_dwLastXRefOffset) &&
       !m_parser.LoadAllCrossRefV5(m_dwLastXRefOffset)) {
     m_docStatus = PDF_DATAAVAIL_LOADALLFILE;
     return FALSE;
   }
 
   m_dwRootObjNum = m_parser.GetRootObjNum();
   m_dwInfoObjNum = m_parser.GetInfoObjNum();
   m_pCurrentParser = &m_parser;
   m_docStatus = PDF_DATAAVAIL_ROOT;
   return TRUE;
 }
 
 CPDF_Object* CPDF_DataAvail::GetObject(uint32_t objnum,
-                                       IPDF_DataAvail::DownloadHints* pHints,
+                                       DownloadHints* pHints,
                                        FX_BOOL* pExistInFile) {
   CPDF_Object* pRet = nullptr;
   uint32_t size = 0;
   FX_FILESIZE offset = 0;
   CPDF_Parser* pParser = nullptr;
 
   if (pExistInFile)
     *pExistInFile = TRUE;
 
   if (m_pDocument) {
@@ skipping 10 matching lines @@
 
   if (pParser)
     pRet = pParser->ParseIndirectObject(nullptr, objnum);
 
   if (!pRet && pExistInFile)
     *pExistInFile = FALSE;
 
   return pRet;
 }
 
-FX_BOOL CPDF_DataAvail::CheckInfo(IPDF_DataAvail::DownloadHints* pHints) {
+FX_BOOL CPDF_DataAvail::CheckInfo(DownloadHints* pHints) {
   FX_BOOL bExist = FALSE;
   CPDF_Object* pInfo = GetObject(m_dwInfoObjNum, pHints, &bExist);
   if (!bExist) {
     m_docStatus =
         (m_bHaveAcroForm ? PDF_DATAAVAIL_ACROFORM : PDF_DATAAVAIL_PAGETREE);
     return TRUE;
   }
 
   if (!pInfo) {
     if (m_docStatus == PDF_DATAAVAIL_ERROR) {
       m_docStatus = PDF_DATAAVAIL_LOADALLFILE;
       return TRUE;
     }
 
     if (m_Pos == m_dwFileLen)
       m_docStatus = PDF_DATAAVAIL_ERROR;
     return FALSE;
   }
 
   if (pInfo)
     pInfo->Release();
 
   m_docStatus =
       (m_bHaveAcroForm ? PDF_DATAAVAIL_ACROFORM : PDF_DATAAVAIL_PAGETREE);
 
   return TRUE;
 }
 
-FX_BOOL CPDF_DataAvail::CheckRoot(IPDF_DataAvail::DownloadHints* pHints) {
+FX_BOOL CPDF_DataAvail::CheckRoot(DownloadHints* pHints) {
   FX_BOOL bExist = FALSE;
   m_pRoot = GetObject(m_dwRootObjNum, pHints, &bExist);
   if (!bExist) {
     m_docStatus = PDF_DATAAVAIL_LOADALLFILE;
     return TRUE;
   }
 
   if (!m_pRoot) {
     if (m_docStatus == PDF_DATAAVAIL_ERROR) {
       m_docStatus = PDF_DATAAVAIL_LOADALLFILE;
@@ skipping 47 matching lines @@
 }
 
 bool CPDF_DataAvail::IsFirstCheck(int iPage) {
   return m_pageMapCheckState.insert(iPage).second;
 }
 
 void CPDF_DataAvail::ResetFirstCheck(int iPage) {
   m_pageMapCheckState.erase(iPage);
 }
 
-FX_BOOL CPDF_DataAvail::CheckPage(IPDF_DataAvail::DownloadHints* pHints) {
+FX_BOOL CPDF_DataAvail::CheckPage(DownloadHints* pHints) {
   uint32_t iPageObjs = m_PageObjList.GetSize();
   CFX_ArrayTemplate<uint32_t> UnavailObjList;
   for (uint32_t i = 0; i < iPageObjs; ++i) {
     uint32_t dwPageObjNum = m_PageObjList.GetAt(i);
     FX_BOOL bExist = FALSE;
     CPDF_Object* pObj = GetObject(dwPageObjNum, pHints, &bExist);
     if (!pObj) {
       if (bExist)
         UnavailObjList.Add(dwPageObjNum);
       continue;
@@ skipping 74 matching lines @@
           m_PageObjList.Add(pRef->GetRefObjNum());
       }
     } break;
     default:
       m_docStatus = PDF_DATAAVAIL_ERROR;
       return FALSE;
   }
   return TRUE;
 }
 
-FX_BOOL CPDF_DataAvail::CheckPages(IPDF_DataAvail::DownloadHints* pHints) {
+FX_BOOL CPDF_DataAvail::CheckPages(DownloadHints* pHints) {
   FX_BOOL bExist = FALSE;
   CPDF_Object* pPages = GetObject(m_PagesObjNum, pHints, &bExist);
   if (!bExist) {
     m_docStatus = PDF_DATAAVAIL_LOADALLFILE;
     return TRUE;
   }
 
   if (!pPages) {
     if (m_docStatus == PDF_DATAAVAIL_ERROR) {
       m_docStatus = PDF_DATAAVAIL_LOADALLFILE;
       return TRUE;
     }
     return FALSE;
   }
 
   if (!GetPageKids(m_pCurrentParser, pPages)) {
     pPages->Release();
     m_docStatus = PDF_DATAAVAIL_ERROR;
     return FALSE;
   }
 
   pPages->Release();
   m_docStatus = PDF_DATAAVAIL_PAGE;
   return TRUE;
 }
 
-FX_BOOL CPDF_DataAvail::CheckHeader(IPDF_DataAvail::DownloadHints* pHints) {
+FX_BOOL CPDF_DataAvail::CheckHeader(DownloadHints* pHints) {
   ASSERT(m_dwFileLen >= 0);
   const uint32_t kReqSize = std::min(static_cast<uint32_t>(m_dwFileLen), 1024U);
 
   if (m_pFileAvail->IsDataAvail(0, kReqSize)) {
     uint8_t buffer[1024];
     m_pFileRead->ReadBlock(buffer, 0, kReqSize);
 
     if (IsLinearizedFile(buffer, kReqSize)) {
       m_docStatus = PDF_DATAAVAIL_FIRSTPAGE;
     } else {
       if (m_docStatus == PDF_DATAAVAIL_ERROR)
         return FALSE;
       m_docStatus = PDF_DATAAVAIL_END;
     }
     return TRUE;
   }
 
   pHints->AddSegment(0, kReqSize);
   return FALSE;
 }
 
-FX_BOOL CPDF_DataAvail::CheckFirstPage(IPDF_DataAvail::DownloadHints* pHints) {
+FX_BOOL CPDF_DataAvail::CheckFirstPage(DownloadHints* pHints) {
   CPDF_Dictionary* pDict = m_pLinearized->GetDict();
   CPDF_Object* pEndOffSet = pDict ? pDict->GetObjectBy("E") : nullptr;
   if (!pEndOffSet) {
     m_docStatus = PDF_DATAAVAIL_ERROR;
     return FALSE;
   }
 
   CPDF_Object* pXRefOffset = pDict ? pDict->GetObjectBy("T") : nullptr;
   if (!pXRefOffset) {
     m_docStatus = PDF_DATAAVAIL_ERROR;
@@ skipping 49 matching lines @@
     return FALSE;
   }
 
   m_docStatus =
       m_bSupportHintTable ? PDF_DATAAVAIL_HINTTABLE : PDF_DATAAVAIL_DONE;
   return TRUE;
 }
 
 FX_BOOL CPDF_DataAvail::IsDataAvail(FX_FILESIZE offset,
                                     uint32_t size,
-                                    IPDF_DataAvail::DownloadHints* pHints) {
+                                    DownloadHints* pHints) {
   if (offset < 0 || offset > m_dwFileLen)
     return TRUE;
 
   FX_SAFE_FILESIZE safeSize = offset;
   safeSize += size;
   safeSize += 512;
   if (!safeSize.IsValid() || safeSize.ValueOrDie() > m_dwFileLen)
     size = m_dwFileLen - offset;
   else
     size += 512;
 
   if (!m_pFileAvail->IsDataAvail(offset, size)) {
     pHints->AddSegment(offset, size);
     return FALSE;
   }
   return TRUE;
 }
 
-FX_BOOL CPDF_DataAvail::CheckHintTables(IPDF_DataAvail::DownloadHints* pHints) {
+FX_BOOL CPDF_DataAvail::CheckHintTables(DownloadHints* pHints) {
   CPDF_Dictionary* pDict = m_pLinearized->GetDict();
   if (!pDict) {
     m_docStatus = PDF_DATAAVAIL_ERROR;
     return FALSE;
   }
 
   if (!pDict->KeyExist("H") || !pDict->KeyExist("O") || !pDict->KeyExist("N")) {
     m_docStatus = PDF_DATAAVAIL_ERROR;
     return FALSE;
   }
@@ skipping 65 matching lines @@
     m_syntaxParser.RestorePos(SavedPos);
     return nullptr;
   }
 
   CPDF_Object* pObj =
       m_syntaxParser.GetObject(pObjList, parser_objnum, gennum, true);
   m_syntaxParser.RestorePos(SavedPos);
   return pObj;
 }
 
-IPDF_DataAvail::DocLinearizationStatus CPDF_DataAvail::IsLinearizedPDF() {
+CPDF_DataAvail::DocLinearizationStatus CPDF_DataAvail::IsLinearizedPDF() {
   const uint32_t kReqSize = 1024;
   if (!m_pFileAvail->IsDataAvail(0, kReqSize))
     return LinearizationUnknown;
 
   if (!m_pFileRead)
     return NotLinearized;
 
   FX_FILESIZE dwSize = m_pFileRead->GetSize();
   if (dwSize < (FX_FILESIZE)kReqSize)
     return LinearizationUnknown;
@@ skipping 49 matching lines @@
     return FALSE;
 
   m_bLinearized = TRUE;
 
   if (CPDF_Number* pNo = ToNumber(pDict->GetObjectBy("P")))
     m_dwFirstPageNo = pNo->GetInteger();
 
   return TRUE;
 }
 
-FX_BOOL CPDF_DataAvail::CheckEnd(IPDF_DataAvail::DownloadHints* pHints) {
+FX_BOOL CPDF_DataAvail::CheckEnd(DownloadHints* pHints) {
   uint32_t req_pos = (uint32_t)(m_dwFileLen > 1024 ? m_dwFileLen - 1024 : 0);
   uint32_t dwSize = (uint32_t)(m_dwFileLen - req_pos);
 
   if (m_pFileAvail->IsDataAvail(req_pos, dwSize)) {
     uint8_t buffer[1024];
     m_pFileRead->ReadBlock(buffer, req_pos, dwSize);
 
     ScopedFileStream file(FX_CreateMemoryStream(buffer, (size_t)dwSize, FALSE));
     m_syntaxParser.InitParser(file.get(), 0);
     m_syntaxParser.RestorePos(dwSize - 1);
@@ skipping 21 matching lines @@
     }
 
     m_docStatus = PDF_DATAAVAIL_LOADALLFILE;
     return TRUE;
   }
 
   pHints->AddSegment(req_pos, dwSize);
   return FALSE;
 }
 
-int32_t CPDF_DataAvail::CheckCrossRefStream(
-    IPDF_DataAvail::DownloadHints* pHints,
-    FX_FILESIZE& xref_offset) {
+int32_t CPDF_DataAvail::CheckCrossRefStream(DownloadHints* pHints,
+                                            FX_FILESIZE& xref_offset) {
   xref_offset = 0;
   uint32_t req_size =
       (uint32_t)(m_Pos + 512 > m_dwFileLen ? m_dwFileLen - m_Pos : 512);
 
   if (m_pFileAvail->IsDataAvail(m_Pos, req_size)) {
     int32_t iSize = (int32_t)(m_Pos + req_size - m_dwCurrentXRefSteam);
     CFX_BinaryBuf buf(iSize);
     uint8_t* pBuf = buf.GetBuffer();
 
     m_pFileRead->ReadBlock(pBuf, m_dwCurrentXRefSteam, iSize);
@@ skipping 134 matching lines @@
       return FALSE;
 
     m_bufferOffset = read_pos;
     m_bufferSize = read_size;
   }
   ch = m_bufferData[pos - m_bufferOffset];
   m_Pos++;
   return TRUE;
 }
 
-FX_BOOL CPDF_DataAvail::CheckCrossRefItem(
-    IPDF_DataAvail::DownloadHints* pHints) {
+FX_BOOL CPDF_DataAvail::CheckCrossRefItem(DownloadHints* pHints) {
   int32_t iSize = 0;
   CFX_ByteString token;
   while (1) {
     if (!GetNextToken(token)) {
       iSize = (int32_t)(m_Pos + 512 > m_dwFileLen ? m_dwFileLen - m_Pos : 512);
       pHints->AddSegment(m_Pos, iSize);
       return FALSE;
     }
 
     if (token == "trailer") {
       m_dwTrailerOffset = m_Pos;
       m_docStatus = PDF_DATAAVAIL_TRAILER;
       return TRUE;
     }
   }
 }
 
-FX_BOOL CPDF_DataAvail::CheckAllCrossRefStream(
-    IPDF_DataAvail::DownloadHints* pHints) {
+FX_BOOL CPDF_DataAvail::CheckAllCrossRefStream(DownloadHints* pHints) {
   FX_FILESIZE xref_offset = 0;
 
   int32_t nRet = CheckCrossRefStream(pHints, xref_offset);
   if (nRet == 1) {
     if (!xref_offset) {
       m_docStatus = PDF_DATAAVAIL_LOADALLCROSSREF;
     } else {
       m_dwCurrentXRefSteam = xref_offset;
       m_Pos = xref_offset;
     }
     return TRUE;
   }
 
   if (nRet == -1)
     m_docStatus = PDF_DATAAVAIL_ERROR;
   return FALSE;
 }
 
-FX_BOOL CPDF_DataAvail::CheckCrossRef(IPDF_DataAvail::DownloadHints* pHints) {
+FX_BOOL CPDF_DataAvail::CheckCrossRef(DownloadHints* pHints) {
   int32_t iSize = 0;
   CFX_ByteString token;
   if (!GetNextToken(token)) {
     iSize = (int32_t)(m_Pos + 512 > m_dwFileLen ? m_dwFileLen - m_Pos : 512);
     pHints->AddSegment(m_Pos, iSize);
     return FALSE;
   }
 
   if (token == "xref") {
     while (1) {
@@ skipping 11 matching lines @@
         return TRUE;
       }
     }
   } else {
     m_docStatus = PDF_DATAAVAIL_LOADALLFILE;
     return TRUE;
   }
   return FALSE;
 }
 
-FX_BOOL CPDF_DataAvail::CheckTrailerAppend(
-    IPDF_DataAvail::DownloadHints* pHints) {
+FX_BOOL CPDF_DataAvail::CheckTrailerAppend(DownloadHints* pHints) {
   if (m_Pos < m_dwFileLen) {
     FX_FILESIZE dwAppendPos = m_Pos + m_syntaxParser.SavePos();
     int32_t iSize = (int32_t)(
         dwAppendPos + 512 > m_dwFileLen ? m_dwFileLen - dwAppendPos : 512);
 
     if (!m_pFileAvail->IsDataAvail(dwAppendPos, iSize)) {
       pHints->AddSegment(dwAppendPos, iSize);
       return FALSE;
     }
   }
 
   if (m_dwPrevXRefOffset) {
     SetStartOffset(m_dwPrevXRefOffset);
     m_docStatus = PDF_DATAAVAIL_CROSSREF;
   } else {
     m_docStatus = PDF_DATAAVAIL_LOADALLCROSSREF;
   }
   return TRUE;
 }
 
-FX_BOOL CPDF_DataAvail::CheckTrailer(IPDF_DataAvail::DownloadHints* pHints) {
+FX_BOOL CPDF_DataAvail::CheckTrailer(DownloadHints* pHints) {
   int32_t iTrailerSize =
       (int32_t)(m_Pos + 512 > m_dwFileLen ? m_dwFileLen - m_Pos : 512);
   if (m_pFileAvail->IsDataAvail(m_Pos, iTrailerSize)) {
     int32_t iSize = (int32_t)(m_Pos + iTrailerSize - m_dwTrailerOffset);
     CFX_BinaryBuf buf(iSize);
     uint8_t* pBuf = buf.GetBuffer();
     if (!pBuf) {
       m_docStatus = PDF_DATAAVAIL_ERROR;
       return FALSE;
     }
@@ skipping 39 matching lines @@
       return TRUE;
     }
     m_dwPrevXRefOffset = 0;
     m_docStatus = PDF_DATAAVAIL_TRAILER_APPEND;
     return TRUE;
   }
   pHints->AddSegment(m_Pos, iTrailerSize);
   return FALSE;
 }
 
-FX_BOOL CPDF_DataAvail::CheckPage(int32_t iPage,
-                                  IPDF_DataAvail::DownloadHints* pHints) {
+FX_BOOL CPDF_DataAvail::CheckPage(int32_t iPage, DownloadHints* pHints) {
   while (TRUE) {
     switch (m_docStatus) {
       case PDF_DATAAVAIL_PAGETREE:
         if (!LoadDocPages(pHints))
           return FALSE;
         break;
       case PDF_DATAAVAIL_PAGE:
         if (!LoadDocPage(iPage, pHints))
           return FALSE;
         break;
       case PDF_DATAAVAIL_ERROR:
         return LoadAllFile(pHints);
       default:
         m_bPagesTreeLoad = TRUE;
         m_bPagesLoad = TRUE;
         m_bCurPageDictLoadOK = TRUE;
         m_docStatus = PDF_DATAAVAIL_PAGE;
         return TRUE;
     }
   }
 }
 
-FX_BOOL CPDF_DataAvail::CheckArrayPageNode(
-    uint32_t dwPageNo,
-    CPDF_DataAvail::PageNode* pPageNode,
-    IPDF_DataAvail::DownloadHints* pHints) {
+FX_BOOL CPDF_DataAvail::CheckArrayPageNode(uint32_t dwPageNo,
+                                           PageNode* pPageNode,
+                                           DownloadHints* pHints) {
   FX_BOOL bExist = FALSE;
   CPDF_Object* pPages = GetObject(dwPageNo, pHints, &bExist);
   if (!bExist) {
     m_docStatus = PDF_DATAAVAIL_ERROR;
     return FALSE;
   }
 
   if (!pPages) {
     if (m_docStatus == PDF_DATAAVAIL_ERROR) {
       m_docStatus = PDF_DATAAVAIL_ERROR;
@@ skipping 16 matching lines @@
       continue;
 
     PageNode* pNode = new PageNode();
     pPageNode->m_childNode.Add(pNode);
     pNode->m_dwPageNo = pKid->GetRefObjNum();
   }
   pPages->Release();
   return TRUE;
 }
 
-FX_BOOL CPDF_DataAvail::CheckUnkownPageNode(
-    uint32_t dwPageNo,
-    CPDF_DataAvail::PageNode* pPageNode,
-    IPDF_DataAvail::DownloadHints* pHints) {
+FX_BOOL CPDF_DataAvail::CheckUnkownPageNode(uint32_t dwPageNo,
+                                            PageNode* pPageNode,
+                                            DownloadHints* pHints) {
   FX_BOOL bExist = FALSE;
   CPDF_Object* pPage = GetObject(dwPageNo, pHints, &bExist);
   if (!bExist) {
     m_docStatus = PDF_DATAAVAIL_ERROR;
     return FALSE;
   }
 
   if (!pPage) {
     if (m_docStatus == PDF_DATAAVAIL_ERROR)
       m_docStatus = PDF_DATAAVAIL_ERROR;
@@ skipping 53 matching lines @@
     m_docStatus = PDF_DATAAVAIL_ERROR;
     return FALSE;
   }
   pPage->Release();
   return TRUE;
 }
 
 FX_BOOL CPDF_DataAvail::CheckPageNode(CPDF_DataAvail::PageNode& pageNodes,
                                       int32_t iPage,
                                       int32_t& iCount,
-                                      IPDF_DataAvail::DownloadHints* pHints,
+                                      DownloadHints* pHints,
                                       int level) {
   if (level >= kMaxPageRecursionDepth)
     return FALSE;
 
   int32_t iSize = pageNodes.m_childNode.GetSize();
   if (iSize <= 0 || iPage >= iSize) {
     m_docStatus = PDF_DATAAVAIL_ERROR;
     return FALSE;
   }
 
@@ skipping 26 matching lines @@
     }
 
     if (iPage == iCount) {
       m_docStatus = PDF_DATAAVAIL_DONE;
       return TRUE;
     }
   }
   return TRUE;
 }
 
-FX_BOOL CPDF_DataAvail::LoadDocPage(int32_t iPage,
-                                    IPDF_DataAvail::DownloadHints* pHints) {
+FX_BOOL CPDF_DataAvail::LoadDocPage(int32_t iPage, DownloadHints* pHints) {
   if (m_pDocument->GetPageCount() <= iPage ||
       m_pDocument->m_PageList.GetAt(iPage)) {
     m_docStatus = PDF_DATAAVAIL_DONE;
     return TRUE;
   }
 
   if (m_pageNodes.m_type == PDF_PAGENODE_PAGE) {
     if (iPage == 0) {
       m_docStatus = PDF_DATAAVAIL_DONE;
       return TRUE;
     }
     m_docStatus = PDF_DATAAVAIL_ERROR;
     return TRUE;
   }
   int32_t iCount = -1;
   return CheckPageNode(m_pageNodes, iPage, iCount, pHints, 0);
 }
 
-FX_BOOL CPDF_DataAvail::CheckPageCount(IPDF_DataAvail::DownloadHints* pHints) {
+FX_BOOL CPDF_DataAvail::CheckPageCount(DownloadHints* pHints) {
   FX_BOOL bExist = FALSE;
   CPDF_Object* pPages = GetObject(m_PagesObjNum, pHints, &bExist);
   if (!bExist) {
     m_docStatus = PDF_DATAAVAIL_ERROR;
     return FALSE;
   }
 
   if (!pPages)
     return FALSE;
 
@@ skipping 12 matching lines @@
   int count = pPagesDict->GetIntegerBy("Count");
   if (count > 0) {
     pPages->Release();
     return TRUE;
   }
 
   pPages->Release();
   return FALSE;
 }
 
-FX_BOOL CPDF_DataAvail::LoadDocPages(IPDF_DataAvail::DownloadHints* pHints) {
+FX_BOOL CPDF_DataAvail::LoadDocPages(DownloadHints* pHints) {
   if (!CheckUnkownPageNode(m_PagesObjNum, &m_pageNodes, pHints))
     return FALSE;
 
   if (CheckPageCount(pHints)) {
     m_docStatus = PDF_DATAAVAIL_PAGE;
     return TRUE;
   }
 
   m_bTotalLoadPageTree = TRUE;
   return FALSE;
 }
 
-FX_BOOL CPDF_DataAvail::LoadPages(IPDF_DataAvail::DownloadHints* pHints) {
+FX_BOOL CPDF_DataAvail::LoadPages(DownloadHints* pHints) {
   while (!m_bPagesTreeLoad) {
     if (!CheckPageStatus(pHints))
       return FALSE;
   }
 
   if (m_bPagesLoad)
     return TRUE;
 
   m_pDocument->LoadPages();
   return FALSE;
 }
 
-IPDF_DataAvail::DocAvailStatus CPDF_DataAvail::CheckLinearizedData(
-    IPDF_DataAvail::DownloadHints* pHints) {
+CPDF_DataAvail::DocAvailStatus CPDF_DataAvail::CheckLinearizedData(
+    DownloadHints* pHints) {
   if (m_bLinearedDataOK)
     return DataAvailable;
 
   if (!m_bMainXRefLoadTried) {
     FX_SAFE_UINT32 data_size = m_dwFileLen;
     data_size -= m_dwLastXRefOffset;
     if (!data_size.IsValid())
       return DataError;
 
     if (!m_pFileAvail->IsDataAvail(m_dwLastXRefOffset,
@@ skipping 11 matching lines @@
     if (!PreparePageItem())
       return DataNotAvailable;
 
     m_bMainXRefLoadedOK = TRUE;
     m_bLinearedDataOK = TRUE;
   }
 
   return m_bLinearedDataOK ? DataAvailable : DataNotAvailable;
 }
 
-FX_BOOL CPDF_DataAvail::CheckPageAnnots(int32_t iPage,
-                                        IPDF_DataAvail::DownloadHints* pHints) {
+FX_BOOL CPDF_DataAvail::CheckPageAnnots(int32_t iPage, DownloadHints* pHints) {
   if (!m_objs_array.GetSize()) {
     m_objs_array.RemoveAll();
     m_ObjectSet.clear();
 
     CPDF_Dictionary* pPageDict = m_pDocument->GetPage(iPage);
     if (!pPageDict)
       return TRUE;
 
     CPDF_Object* pAnnots = pPageDict->GetObjectBy("Annots");
     if (!pAnnots)
@@ skipping 11 matching lines @@
 
   CFX_ArrayTemplate<CPDF_Object*> new_objs_array;
   FX_BOOL bRet = IsObjectsAvail(m_objs_array, FALSE, pHints, new_objs_array);
   m_objs_array.RemoveAll();
   if (!bRet)
     m_objs_array.Append(new_objs_array);
 
   return bRet;
 }
 
-IPDF_DataAvail::DocAvailStatus CPDF_DataAvail::CheckLinearizedFirstPage(
+CPDF_DataAvail::DocAvailStatus CPDF_DataAvail::CheckLinearizedFirstPage(
     int32_t iPage,
-    IPDF_DataAvail::DownloadHints* pHints) {
+    DownloadHints* pHints) {
   if (!m_bAnnotsLoad) {
     if (!CheckPageAnnots(iPage, pHints))
       return DataNotAvailable;
     m_bAnnotsLoad = TRUE;
   }
 
   DocAvailStatus nRet = CheckLinearizedData(pHints);
   if (nRet == DataAvailable)
     m_bPageLoadedOK = FALSE;
   return nRet;
@@ skipping 14 matching lines @@
 
   CPDF_Object* pRet = pParentDict->GetObjectBy("Resources");
   if (pRet) {
     m_pPageResource = pRet;
     return TRUE;
   }
 
   return HaveResourceAncestor(pParentDict);
 }
 
-IPDF_DataAvail::DocAvailStatus CPDF_DataAvail::IsPageAvail(
+CPDF_DataAvail::DocAvailStatus CPDF_DataAvail::IsPageAvail(
     int32_t iPage,
-    IPDF_DataAvail::DownloadHints* pHints) {
+    DownloadHints* pHints) {
   if (!m_pDocument)
     return DataError;
 
   if (IsFirstCheck(iPage)) {
     m_bCurPageDictLoadOK = FALSE;
     m_bPageLoadedOK = FALSE;
     m_bAnnotsLoad = FALSE;
     m_bNeedDownLoadResource = FALSE;
     m_objs_array.RemoveAll();
     m_ObjectSet.clear();
@@ skipping 105 matching lines @@
 
   m_bPageLoadedOK = FALSE;
   m_bAnnotsLoad = FALSE;
   m_bCurPageDictLoadOK = FALSE;
 
   ResetFirstCheck(iPage);
   m_pagesLoadState.insert(iPage);
   return DataAvailable;
 }
 
-FX_BOOL CPDF_DataAvail::CheckResources(IPDF_DataAvail::DownloadHints* pHints) {
+FX_BOOL CPDF_DataAvail::CheckResources(DownloadHints* pHints) {
   if (!m_objs_array.GetSize()) {
     m_objs_array.RemoveAll();
     CFX_ArrayTemplate<CPDF_Object*> obj_array;
     obj_array.Add(m_pPageResource);
 
     FX_BOOL bRet = IsObjectsAvail(obj_array, TRUE, pHints, m_objs_array);
     if (bRet)
       m_objs_array.RemoveAll();
     return bRet;
   }
@@ skipping 47 matching lines @@
         return nullptr;
 
       if (!m_pDocument->InsertIndirectObject(dwObjNum, pPageDict))
         return nullptr;
       return pPageDict->GetDict();
     }
   }
   return m_pDocument->GetPage(index);
 }
 
-IPDF_DataAvail::DocFormStatus CPDF_DataAvail::IsFormAvail(
-    IPDF_DataAvail::DownloadHints* pHints) {
+CPDF_DataAvail::DocFormStatus CPDF_DataAvail::IsFormAvail(
+    DownloadHints* pHints) {
   if (!m_pDocument)
     return FormAvailable;
 
   if (!m_bLinearizedFormParamLoad) {
     CPDF_Dictionary* pRoot = m_pDocument->GetRoot();
     if (!pRoot)
       return FormAvailable;
 
     CPDF_Object* pAcroForm = pRoot->GetObjectBy("AcroForm");
     if (!pAcroForm)
@@ skipping 20 matching lines @@
   return FormAvailable;
 }
 
 CPDF_DataAvail::PageNode::PageNode() : m_type(PDF_PAGENODE_UNKNOWN) {}
 
 CPDF_DataAvail::PageNode::~PageNode() {
   for (int32_t i = 0; i < m_childNode.GetSize(); ++i)
     delete m_childNode[i];
   m_childNode.RemoveAll();
 }