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,
                                FX_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();
-  if (m_pLinearized)
-    m_pLinearized->Release();
 
   if (m_pRoot)
     m_pRoot->Release();
 
   if (m_pTrailer)
     m_pTrailer->Release();
 
   for (CPDF_Object* pObject : m_arrayAcroforms)
     pObject->Release();
 }
@@ skipping 516 matching lines @@
       m_docStatus = PDF_DATAAVAIL_END;
     }
     return TRUE;
   }
 
   pHints->AddSegment(0, kReqSize);
   return FALSE;
 }
 
 FX_BOOL CPDF_DataAvail::CheckFirstPage(DownloadHints* pHints) {
-  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) {
+  if (!m_pLinearized->GetFirstPageEndOffset() ||
+      !m_pLinearized->GetFileSize() || !m_pLinearized->GetLastXRefOffset()) {
     m_docStatus = PDF_DATAAVAIL_ERROR;
     return FALSE;
   }
 
   FX_BOOL bNeedDownLoad = FALSE;
-  if (pEndOffSet->IsNumber()) {
-    uint32_t dwEnd = pEndOffSet->GetInteger();
-    dwEnd += 512;
-    if ((FX_FILESIZE)dwEnd > m_dwFileLen)
-      dwEnd = (uint32_t)m_dwFileLen;
+  uint32_t dwEnd = m_pLinearized->GetFirstPageEndOffset();
+  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 = 0;
-  FX_FILESIZE dwFileLen = 0;
-  if (pXRefOffset->IsNumber())
-    m_dwLastXRefOffset = pXRefOffset->GetInteger();
-
-  if (pFileLen->IsNumber())
-    dwFileLen = pFileLen->GetInteger();
-
+  m_dwLastXRefOffset = m_pLinearized->GetLastXRefOffset();
+  FX_FILESIZE dwFileLen = m_pLinearized->GetFileSize();
   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;
 }
 
 FX_BOOL CPDF_DataAvail::CheckHintTables(DownloadHints* pHints) {
-  CPDF_Dictionary* pDict = m_pLinearized->GetDict();
-  if (!pDict) {
+  if (m_pLinearized->GetPageCount() <= 1) {
+    m_docStatus = PDF_DATAAVAIL_DONE;
+    return TRUE;
+  }
+  if (!m_pLinearized->HasHintTable()) {
     m_docStatus = PDF_DATAAVAIL_ERROR;
     return FALSE;
   }
 
-  // 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;
-  }
+  FX_FILESIZE szHintStart = m_pLinearized->GetHintStart();
+  FX_FILESIZE szHintLength = m_pLinearized->GetHintLength();
 
   if (!IsDataAvail(szHintStart, szHintLength, pHints))
     return FALSE;
 
   m_syntaxParser.InitParser(m_pFileRead, m_dwHeaderOffset);
 
   std::unique_ptr<CPDF_HintTables> pHintTables(
-      new CPDF_HintTables(this, pDict));
+      new CPDF_HintTables(this, m_pLinearized.get()));
   std::unique_ptr<CPDF_Object, ReleaseDeleter<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;
 }
 
 FX_BOOL CPDF_DataAvail::IsLinearized() {
-  return m_bLinearized;
+  return !!m_pLinearized;
 }
 
 FX_BOOL CPDF_DataAvail::IsLinearizedFile(uint8_t* pData, uint32_t dwLen) {
   if (m_pLinearized)
-    return m_bLinearized;
+    return TRUE;
 
   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 =
-      ParseIndirectObjectAt(m_syntaxParser.m_HeaderOffset + 9, objnum);
-  if (!m_pLinearized)
+  m_pLinearized = CPDF_Linearized::CreateForObject(UniqueObject(
+      ParseIndirectObjectAt(m_syntaxParser.m_HeaderOffset + 9, objnum)));
+  if (!m_pLinearized || !m_pLinearized->GetFileSize() ||
+      m_pLinearized->GetFileSize() != m_pFileRead->GetSize()) {
+    m_pLinearized.reset();
     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;

[Lei Zhang, 2016/11/02 21:34:22]

Is this variable still needed at all? This is the only place in the original
code that sets it to true, but you have removed this code, and many other
references to it.

[snake, 2016/11/02 22:04:28]

Done.

-
-  if (CPDF_Number* pNo = ToNumber(pDict->GetObjectFor("P")))
-    m_dwFirstPageNo = pNo->GetInteger();
-
+  }
   return TRUE;
 }
 
 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);
@@ skipping 716 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_bLinearized) {
-    if (dwPage == m_dwFirstPageNo) {
+  if (m_pLinearized) {
+    if (dwPage == m_pLinearized->GetFirstPageNo()) {
       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) {
-    CPDF_Dictionary* pDict = m_pLinearized->GetDict();
-    CPDF_Object* pObj = pDict ? pDict->GetDirectObjectFor("N") : nullptr;
-    return pObj ? pObj->GetInteger() : 0;
-  }
+  if (m_pLinearized)
+    return m_pLinearized->GetPageCount();
   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;
 
-  CPDF_Dictionary* pDict = m_pLinearized->GetDict();
-  CPDF_Object* pObj = pDict ? pDict->GetDirectObjectFor("P") : nullptr;
-  int firstPageNum = pObj ? pObj->GetInteger() : 0;
-  if (index == firstPageNum)
+  if (index == static_cast<int>(m_pLinearized->GetFirstPageNo()))
     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 44 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();
 }