Revert of Unify some code

core/fpdfapi/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/parser/cpdf_data_avail.h"
 
 #include <algorithm>
 #include <memory>
 #include <utility>
 
 #include "core/fpdfapi/cpdf_modulemgr.h"
 #include "core/fpdfapi/parser/cpdf_array.h"
 #include "core/fpdfapi/parser/cpdf_dictionary.h"
 #include "core/fpdfapi/parser/cpdf_document.h"
 #include "core/fpdfapi/parser/cpdf_hint_tables.h"
-#include "core/fpdfapi/parser/cpdf_linearized.h"
 #include "core/fpdfapi/parser/cpdf_name.h"
 #include "core/fpdfapi/parser/cpdf_number.h"
 #include "core/fpdfapi/parser/cpdf_reference.h"
 #include "core/fpdfapi/parser/cpdf_stream.h"
 #include "core/fpdfapi/parser/fpdf_parser_utility.h"
 #include "core/fxcrt/fx_ext.h"
 #include "core/fxcrt/fx_safe_types.h"
 #include "third_party/base/stl_util.h"
 
 CPDF_DataAvail::FileAvail::~FileAvail() {}
 
 CPDF_DataAvail::DownloadHints::~DownloadHints() {}
 
 // static
 int CPDF_DataAvail::s_CurrentDataAvailRecursionDepth = 0;
 
 CPDF_DataAvail::CPDF_DataAvail(FileAvail* pFileAvail,
                                IFX_SeekableReadStream* pFileRead,
                                bool bSupportHintTable)
     : 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;
   m_PagesObjNum = 0;
   m_dwCurrentXRefSteam = 0;
   m_dwAcroFormObjNum = 0;
   m_dwInfoObjNum = 0;
   m_pDocument = 0;
   m_dwEncryptObjNum = 0;
   m_dwPrevXRefOffset = 0;
   m_dwLastXRefOffset = 0;
   m_bDocAvail = false;
   m_bMainXRefLoadTried = false;
   m_bDocAvail = false;
+  m_bLinearized = false;
   m_bPagesLoad = false;
   m_bPagesTreeLoad = false;
   m_bMainXRefLoadedOK = false;
   m_bAnnotsLoad = false;
   m_bHaveAcroForm = false;
   m_bAcroFormLoad = false;
   m_bPageLoadedOK = false;
   m_bNeedDownLoadResource = false;
   m_bLinearizedFormParamLoad = false;
+  m_pLinearized = nullptr;
   m_pRoot = nullptr;
   m_pTrailer = nullptr;
   m_pCurrentParser = nullptr;
   m_pAcroForm = nullptr;
   m_pPageDict = nullptr;
   m_pPageResource = nullptr;
   m_docStatus = PDF_DATAAVAIL_HEADER;
   m_parser.m_bOwnFileRead = false;
   m_bTotalLoadPageTree = false;
   m_bCurPageDictLoadOK = false;
   m_bLinearedDataOK = false;
   m_bSupportHintTable = bSupportHintTable;
 }
 
 CPDF_DataAvail::~CPDF_DataAvail() {
   m_pHintTables.reset();
+  delete m_pLinearized;
+  delete m_pRoot;
+  delete m_pTrailer;
 
   for (CPDF_Object* pObject : m_arrayAcroforms)
     delete pObject;
 }
 
 void CPDF_DataAvail::SetDocument(CPDF_Document* pDoc) {
   m_pDocument = pDoc;
 }
 
 uint32_t CPDF_DataAvail::GetObjectSize(uint32_t objnum, FX_FILESIZE& offset) {
@@ skipping 507 matching lines @@
       m_docStatus = PDF_DATAAVAIL_END;
     }
     return true;
   }
 
   pHints->AddSegment(0, kReqSize);
   return false;
 }
 
 bool CPDF_DataAvail::CheckFirstPage(DownloadHints* pHints) {
-  if (!m_pLinearized->GetFirstPageEndOffset() ||
-      !m_pLinearized->GetFileSize() || !m_pLinearized->GetLastXRefOffset()) {
+  CPDF_Dictionary* pDict = m_pLinearized->GetDict();
+  CPDF_Object* pEndOffSet = pDict ? pDict->GetObjectFor("E") : nullptr;
+  if (!pEndOffSet) {
+    m_docStatus = PDF_DATAAVAIL_ERROR;
+    return false;
+  }
+
+  CPDF_Object* pXRefOffset = pDict ? pDict->GetObjectFor("T") : nullptr;
+  if (!pXRefOffset) {
+    m_docStatus = PDF_DATAAVAIL_ERROR;
+    return false;
+  }
+
+  CPDF_Object* pFileLen = pDict ? pDict->GetObjectFor("L") : nullptr;
+  if (!pFileLen) {
     m_docStatus = PDF_DATAAVAIL_ERROR;
     return false;
   }
 
   bool bNeedDownLoad = false;
-  uint32_t dwEnd = m_pLinearized->GetFirstPageEndOffset();
-  dwEnd += 512;
-  if ((FX_FILESIZE)dwEnd > m_dwFileLen)
-    dwEnd = (uint32_t)m_dwFileLen;
+  if (pEndOffSet->IsNumber()) {
+    uint32_t dwEnd = pEndOffSet->GetInteger();
+    dwEnd += 512;
+    if ((FX_FILESIZE)dwEnd > m_dwFileLen)
+      dwEnd = (uint32_t)m_dwFileLen;
 
-  int32_t iStartPos = (int32_t)(m_dwFileLen > 1024 ? 1024 : m_dwFileLen);
-  int32_t iSize = dwEnd > 1024 ? dwEnd - 1024 : 0;
-  if (!m_pFileAvail->IsDataAvail(iStartPos, iSize)) {
-    pHints->AddSegment(iStartPos, iSize);
-    bNeedDownLoad = true;
+    int32_t iStartPos = (int32_t)(m_dwFileLen > 1024 ? 1024 : m_dwFileLen);
+    int32_t iSize = dwEnd > 1024 ? dwEnd - 1024 : 0;
+    if (!m_pFileAvail->IsDataAvail(iStartPos, iSize)) {
+      pHints->AddSegment(iStartPos, iSize);
+      bNeedDownLoad = true;
+    }
   }
 
-  m_dwLastXRefOffset = m_pLinearized->GetLastXRefOffset();
-  FX_FILESIZE dwFileLen = m_pLinearized->GetFileSize();
+  m_dwLastXRefOffset = 0;
+  FX_FILESIZE dwFileLen = 0;
+  if (pXRefOffset->IsNumber())
+    m_dwLastXRefOffset = pXRefOffset->GetInteger();
+
+  if (pFileLen->IsNumber())
+    dwFileLen = pFileLen->GetInteger();
+
   if (!m_pFileAvail->IsDataAvail(m_dwLastXRefOffset,
                                  (uint32_t)(dwFileLen - m_dwLastXRefOffset))) {
     if (m_docStatus == PDF_DATAAVAIL_FIRSTPAGE) {
       uint32_t dwSize = (uint32_t)(dwFileLen - m_dwLastXRefOffset);
       FX_FILESIZE offset = m_dwLastXRefOffset;
       if (dwSize < 512 && dwFileLen > 512) {
         dwSize = 512;
         offset = dwFileLen - 512;
       }
       pHints->AddSegment(offset, dwSize);
@@ skipping 27 matching lines @@
     size += 512;
 
   if (!m_pFileAvail->IsDataAvail(offset, size)) {
     pHints->AddSegment(offset, size);
     return false;
   }
   return true;
 }
 
 bool CPDF_DataAvail::CheckHintTables(DownloadHints* pHints) {
-  if (m_pLinearized->GetPageCount() <= 1) {
-    m_docStatus = PDF_DATAAVAIL_DONE;
-    return true;
-  }
-  if (!m_pLinearized->HasHintTable()) {
+  CPDF_Dictionary* pDict = m_pLinearized->GetDict();
+  if (!pDict) {
     m_docStatus = PDF_DATAAVAIL_ERROR;
     return false;
   }
 
-  FX_FILESIZE szHintStart = m_pLinearized->GetHintStart();
-  FX_FILESIZE szHintLength = m_pLinearized->GetHintLength();
+  // The actual value is not required here, but validate its existence and type.
+  CPDF_Number* pFirstPage = ToNumber(pDict->GetDirectObjectFor("O"));
+  if (!pFirstPage || !pFirstPage->IsInteger()) {
+    m_docStatus = PDF_DATAAVAIL_ERROR;
+    return false;
+  }
+
+  CPDF_Number* pPageCount = ToNumber(pDict->GetDirectObjectFor("N"));
+  if (!pPageCount || !pPageCount->IsInteger()) {
+    m_docStatus = PDF_DATAAVAIL_ERROR;
+    return false;
+  }
+
+  int nPageCount = pPageCount->GetInteger();
+  if (nPageCount <= 1) {
+    m_docStatus = PDF_DATAAVAIL_DONE;
+    return true;
+  }
+
+  CPDF_Array* pHintStreamRange = pDict->GetArrayFor("H");
+  size_t nHintStreamSize = pHintStreamRange ? pHintStreamRange->GetCount() : 0;
+  if (nHintStreamSize != 2 && nHintStreamSize != 4) {
+    m_docStatus = PDF_DATAAVAIL_ERROR;
+    return false;
+  }
+
+  for (const CPDF_Object* pArrayObject : *pHintStreamRange) {
+    const CPDF_Number* pNumber = ToNumber(pArrayObject->GetDirect());
+    if (!pNumber || !pNumber->IsInteger()) {
+      m_docStatus = PDF_DATAAVAIL_ERROR;
+      return false;
+    }
+  }
+
+  FX_FILESIZE szHintStart = pHintStreamRange->GetIntegerAt(0);
+  FX_FILESIZE szHintLength = pHintStreamRange->GetIntegerAt(1);
+  if (szHintStart < 0 || szHintLength <= 0) {
+    m_docStatus = PDF_DATAAVAIL_ERROR;
+    return false;
+  }
 
   if (!IsDataAvail(szHintStart, szHintLength, pHints))
     return false;
 
   m_syntaxParser.InitParser(m_pFileRead, m_dwHeaderOffset);
 
   std::unique_ptr<CPDF_HintTables> pHintTables(
-      new CPDF_HintTables(this, m_pLinearized.get()));
+      new CPDF_HintTables(this, pDict));
   std::unique_ptr<CPDF_Object> pHintStream(
       ParseIndirectObjectAt(szHintStart, 0));
   CPDF_Stream* pStream = ToStream(pHintStream.get());
   if (pStream && pHintTables->LoadHintStream(pStream))
     m_pHintTables = std::move(pHintTables);
 
   m_docStatus = PDF_DATAAVAIL_DONE;
   return true;
 }
 
@@ skipping 43 matching lines @@
 
   uint8_t buffer[1024];
   m_pFileRead->ReadBlock(buffer, 0, kReqSize);
   if (IsLinearizedFile(buffer, kReqSize))
     return Linearized;
 
   return NotLinearized;
 }
 
 bool CPDF_DataAvail::IsLinearized() {
-  return !!m_pLinearized;
+  return m_bLinearized;
 }
 
 bool CPDF_DataAvail::IsLinearizedFile(uint8_t* pData, uint32_t dwLen) {
   if (m_pLinearized)
-    return true;
+    return m_bLinearized;
 
   ScopedFileStream file(FX_CreateMemoryStream(pData, (size_t)dwLen, false));
 
   int32_t offset = GetHeaderOffset(file.get());
   if (offset == -1) {
     m_docStatus = PDF_DATAAVAIL_ERROR;
     return false;
   }
 
   m_dwHeaderOffset = offset;
   m_syntaxParser.InitParser(file.get(), offset);
   m_syntaxParser.RestorePos(m_syntaxParser.m_HeaderOffset + 9);
 
   bool bNumber;
   CFX_ByteString wordObjNum = m_syntaxParser.GetNextWord(&bNumber);
   if (!bNumber)
     return false;
 
   uint32_t objnum = FXSYS_atoui(wordObjNum.c_str());
-  m_pLinearized = CPDF_Linearized::CreateForObject(pdfium::WrapUnique(
-      ParseIndirectObjectAt(m_syntaxParser.m_HeaderOffset + 9, objnum)));
-  if (!m_pLinearized ||
-      m_pLinearized->GetFileSize() != m_pFileRead->GetSize()) {
-    m_pLinearized.reset();
+  m_pLinearized =
+      ParseIndirectObjectAt(m_syntaxParser.m_HeaderOffset + 9, objnum);
+  if (!m_pLinearized)
     return false;
-  }
+
+  CPDF_Dictionary* pDict = m_pLinearized->GetDict();
+  if (!pDict || !pDict->GetObjectFor("Linearized"))
+    return false;
+
+  CPDF_Object* pLen = pDict->GetObjectFor("L");
+  if (!pLen)
+    return false;
+
+  if ((FX_FILESIZE)pLen->GetInteger() != m_pFileRead->GetSize())
+    return false;
+
+  m_bLinearized = true;
+
+  if (CPDF_Number* pNo = ToNumber(pDict->GetObjectFor("P")))
+    m_dwFirstPageNo = pNo->GetInteger();
+
   return true;
 }
 
 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);
@@ skipping 715 matching lines @@
     m_bPageLoadedOK = false;
     m_bAnnotsLoad = false;
     m_bNeedDownLoadResource = false;
     m_objs_array.clear();
     m_ObjectSet.clear();
   }
 
   if (pdfium::ContainsKey(m_pagesLoadState, dwPage))
     return DataAvailable;
 
-  if (m_pLinearized) {
-    if (dwPage == m_pLinearized->GetFirstPageNo()) {
+  if (m_bLinearized) {
+    if (dwPage == m_dwFirstPageNo) {
       DocAvailStatus nRet = CheckLinearizedFirstPage(dwPage, pHints);
       if (nRet == DataAvailable)
         m_pagesLoadState.insert(dwPage);
       return nRet;
     }
 
     DocAvailStatus nResult = CheckLinearizedData(pHints);
     if (nResult != DataAvailable)
       return nResult;
 
@@ skipping 109 matching lines @@
 
 void CPDF_DataAvail::GetLinearizedMainXRefInfo(FX_FILESIZE* pPos,
                                                uint32_t* pSize) {
   if (pPos)
     *pPos = m_dwLastXRefOffset;
   if (pSize)
     *pSize = (uint32_t)(m_dwFileLen - m_dwLastXRefOffset);
 }
 
 int CPDF_DataAvail::GetPageCount() const {
-  if (m_pLinearized)
-    return m_pLinearized->GetPageCount();
+  if (m_pLinearized) {
+    CPDF_Dictionary* pDict = m_pLinearized->GetDict();
+    CPDF_Object* pObj = pDict ? pDict->GetDirectObjectFor("N") : nullptr;
+    return pObj ? pObj->GetInteger() : 0;
+  }
   return m_pDocument ? m_pDocument->GetPageCount() : 0;
 }
 
 CPDF_Dictionary* CPDF_DataAvail::GetPage(int index) {
   if (!m_pDocument || index < 0 || index >= GetPageCount())
     return nullptr;
   CPDF_Dictionary* page = m_pDocument->GetPage(index);
   if (page)
     return page;
   if (!m_pLinearized || !m_pHintTables)
     return nullptr;
 
-  if (index == static_cast<int>(m_pLinearized->GetFirstPageNo()))
+  CPDF_Dictionary* pDict = m_pLinearized->GetDict();
+  CPDF_Object* pObj = pDict ? pDict->GetDirectObjectFor("P") : nullptr;
+  int firstPageNum = pObj ? pObj->GetInteger() : 0;
+  if (index == firstPageNum)
     return nullptr;
   FX_FILESIZE szPageStartPos = 0;
   FX_FILESIZE szPageLength = 0;
   uint32_t dwObjNum = 0;
   const bool bPagePosGot = m_pHintTables->GetPagePos(index, &szPageStartPos,
                                                      &szPageLength, &dwObjNum);
   if (!bPagePosGot || !dwObjNum)
     return nullptr;
   // We should say to the document, which object is the page.
   m_pDocument->SetPageObjNum(index, dwObjNum);
@@ skipping 42 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();
 }