Support linearized loading

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>
 
 #include "../../../include/fpdfapi/fpdf_module.h"
 #include "../../../include/fpdfapi/fpdf_page.h"
 #include "../../../include/fpdfapi/fpdf_parser.h"
 #include "../../../include/fxcrt/fx_safe_types.h"
 #include "../fpdf_page/pageint.h"
+#include "./parser_int.h"

[Tom Sepez, 2015/09/22 00:05:38]

nit: no ./

[jun_fang, 2015/09/22 12:42:31]

Acknowledged.

 
 FX_BOOL IsSignatureDict(const CPDF_Dictionary* pDict) {
   CPDF_Object* pType = pDict->GetElementValue(FX_BSTRC("Type"));
   if (!pType) {
     pType = pDict->GetElementValue(FX_BSTRC("FT"));
     if (!pType) {
       return FALSE;
     }
   }
   if (pType->GetString() == FX_BSTRC("Sig")) {
@@ skipping 2777 matching lines @@
     }
     buffer[offset++] = ch;
     if (offset == size) {
       break;
     }
   }
 }
 
 class CPDF_DataAvail final : public IPDF_DataAvail {
  public:
-  CPDF_DataAvail(IFX_FileAvail* pFileAvail, IFX_FileRead* pFileRead);
+  CPDF_DataAvail(IFX_FileAvail* pFileAvail,
+                 IFX_FileRead* pFileRead,
+                 FX_BOOL bSupportHintTable = FALSE);
   ~CPDF_DataAvail() override;
 
   virtual FX_BOOL IsDocAvail(IFX_DownloadHints* pHints) override;
 
   virtual void SetDocument(CPDF_Document* pDoc) override;
 
   virtual FX_BOOL IsPageAvail(int iPage, IFX_DownloadHints* pHints) override;
 
   virtual int32_t IsFormAvail(IFX_DownloadHints* pHints) override;
 
   virtual int32_t IsLinearizedPDF() override;
 
   virtual FX_BOOL IsLinearized() override { return m_bLinearized; }
 
   virtual void GetLinearizedMainXRefInfo(FX_FILESIZE* pPos,
                                          FX_DWORD* pSize) override;
+  int GetPageCount() const;
+  CPDF_Dictionary* GetPage(int index);
 
  protected:
   static const int kMaxDataAvailRecursionDepth = 64;
   static int s_CurrentDataAvailRecursionDepth;
 
   FX_DWORD GetObjectSize(FX_DWORD objnum, FX_FILESIZE& offset);
   FX_BOOL IsObjectsAvail(CFX_PtrArray& obj_array,
                          FX_BOOL bParsePage,
                          IFX_DownloadHints* pHints,
                          CFX_PtrArray& ret_array);
   FX_BOOL CheckDocStatus(IFX_DownloadHints* pHints);
   FX_BOOL CheckHeader(IFX_DownloadHints* pHints);
   FX_BOOL CheckFirstPage(IFX_DownloadHints* pHints);
+  FX_BOOL CheckHintTables(IFX_DownloadHints* pHints);
   FX_BOOL CheckEnd(IFX_DownloadHints* pHints);
   FX_BOOL CheckCrossRef(IFX_DownloadHints* pHints);
   FX_BOOL CheckCrossRefItem(IFX_DownloadHints* pHints);
   FX_BOOL CheckTrailer(IFX_DownloadHints* pHints);
   FX_BOOL CheckRoot(IFX_DownloadHints* pHints);
   FX_BOOL CheckInfo(IFX_DownloadHints* pHints);
   FX_BOOL CheckPages(IFX_DownloadHints* pHints);
   FX_BOOL CheckPage(IFX_DownloadHints* pHints);
   FX_BOOL CheckResources(IFX_DownloadHints* pHints);
   FX_BOOL CheckAnnots(IFX_DownloadHints* pHints);
   FX_BOOL CheckAcroForm(IFX_DownloadHints* pHints);
   FX_BOOL CheckAcroFormSubObject(IFX_DownloadHints* pHints);
   FX_BOOL CheckTrailerAppend(IFX_DownloadHints* pHints);
   FX_BOOL CheckPageStatus(IFX_DownloadHints* pHints);
   FX_BOOL CheckAllCrossRefStream(IFX_DownloadHints* pHints);
 
   int32_t CheckCrossRefStream(IFX_DownloadHints* pHints,
                               FX_FILESIZE& xref_offset);
   FX_BOOL IsLinearizedFile(uint8_t* pData, FX_DWORD dwLen);
   void SetStartOffset(FX_FILESIZE dwOffset);
   FX_BOOL GetNextToken(CFX_ByteString& token);
   FX_BOOL GetNextChar(uint8_t& ch);
-  CPDF_Object* ParseIndirectObjectAt(FX_FILESIZE pos, FX_DWORD objnum);
+  CPDF_Object* ParseIndirectObjectAt(FX_FILESIZE pos,
+                                     FX_DWORD objnum,
+                                     CPDF_IndirectObjects* pObjList = NULL);
   CPDF_Object* GetObject(FX_DWORD objnum,
                          IFX_DownloadHints* pHints,
                          FX_BOOL* pExistInFile);
   FX_BOOL GetPageKids(CPDF_Parser* pParser, CPDF_Object* pPages);
   FX_BOOL PreparePageItem();
   FX_BOOL LoadPages(IFX_DownloadHints* pHints);
   FX_BOOL LoadAllXref(IFX_DownloadHints* pHints);
   FX_BOOL LoadAllFile(IFX_DownloadHints* pHints);
   FX_BOOL CheckLinearizedData(IFX_DownloadHints* pHints);
   FX_BOOL CheckFileResources(IFX_DownloadHints* pHints);
@@ skipping 10 matching lines @@
                         IFX_DownloadHints* pHints);
   FX_BOOL CheckUnkownPageNode(FX_DWORD dwPageNo,
                               CPDF_PageNode* pPageNode,
                               IFX_DownloadHints* pHints);
   FX_BOOL CheckArrayPageNode(FX_DWORD dwPageNo,
                              CPDF_PageNode* pPageNode,
                              IFX_DownloadHints* pHints);
   FX_BOOL CheckPageCount(IFX_DownloadHints* pHints);
   FX_BOOL IsFirstCheck(int iPage);
   void ResetFirstCheck(int iPage);
+  FX_BOOL IsDataAvail(FX_FILESIZE offset,
+                      FX_DWORD size,
+                      IFX_DownloadHints* pHints);
 
   CPDF_Parser m_parser;
 
   CPDF_SyntaxParser m_syntaxParser;
 
   CPDF_Object* m_pRoot;
 
   FX_DWORD m_dwRootObjNum;
 
   FX_DWORD m_dwInfoObjNum;
@@ skipping 93 matching lines @@
   FX_FILESIZE m_dwPrevXRefOffset;
 
   FX_BOOL m_bTotalLoadPageTree;
 
   FX_BOOL m_bCurPageDictLoadOK;
 
   CPDF_PageNode m_pageNodes;
 
   std::set<FX_DWORD> m_pageMapCheckState;
   std::set<FX_DWORD> m_pagesLoadState;
+
+  CPDF_HintTables* m_pHintTables;
+  FX_BOOL m_bSupportHintTable;
+
+ public:
+  friend class CPDF_HintTables;

[Tom Sepez, 2015/09/22 00:05:38]

nit: we'd be happier if you added the corresponding accessor methods for the
fields you want to manipulate by this friending.

 };
 
 IPDF_DataAvail::IPDF_DataAvail(IFX_FileAvail* pFileAvail,
                                IFX_FileRead* pFileRead)
-    : m_pFileAvail(pFileAvail), m_pFileRead(pFileRead) {}
+    : m_pFileAvail(pFileAvail), m_pFileRead(pFileRead) {
+}
 
 // static
 IPDF_DataAvail* IPDF_DataAvail::Create(IFX_FileAvail* pFileAvail,
                                        IFX_FileRead* pFileRead) {
   return new CPDF_DataAvail(pFileAvail, pFileRead);
 }
 
 // static
 int CPDF_DataAvail::s_CurrentDataAvailRecursionDepth = 0;
 
 CPDF_DataAvail::CPDF_DataAvail(IFX_FileAvail* pFileAvail,
-                               IFX_FileRead* pFileRead)
+                               IFX_FileRead* pFileRead,
+                               FX_BOOL bSupportHintTable)
     : IPDF_DataAvail(pFileAvail, pFileRead) {
   m_Pos = 0;
   m_dwFileLen = 0;
   if (m_pFileRead) {
     m_dwFileLen = (FX_DWORD)m_pFileRead->GetSize();
   }
   m_dwCurrentOffset = 0;
   m_WordSize = 0;
   m_dwXRefOffset = 0;
   m_bufferOffset = 0;
@@ skipping 25 matching lines @@
   m_pTrailer = NULL;
   m_pCurrentParser = NULL;
   m_pAcroForm = NULL;
   m_pPageDict = NULL;
   m_pPageResource = NULL;
   m_docStatus = PDF_DATAAVAIL_HEADER;
   m_parser.m_bOwnFileRead = FALSE;
   m_bTotalLoadPageTree = FALSE;
   m_bCurPageDictLoadOK = FALSE;
   m_bLinearedDataOK = FALSE;
+  m_pHintTables = NULL;
+  m_bSupportHintTable = bSupportHintTable;
 }
 CPDF_DataAvail::~CPDF_DataAvail() {
   if (m_pLinearized) {
     m_pLinearized->Release();
   }
   if (m_pRoot) {
     m_pRoot->Release();
   }
   if (m_pTrailer) {
     m_pTrailer->Release();
   }
+  if (m_pHintTables) {

[Tom Sepez, 2015/09/22 00:05:38]

nit: just delete m_pHintables.  There's no need to check for nullness, C++
handles that for you.

[jun_fang, 2015/09/22 12:42:32]

Acknowledged.

+    delete m_pHintTables;

[Tom Sepez, 2015/09/22 00:05:39]

if CPDF_DataAvail owns these hint tables, then use nonstd::unique_ptr<> and
deletion becomes automatic.

+  }
   int32_t i = 0;
   int32_t iSize = m_arrayAcroforms.GetSize();
   for (i = 0; i < iSize; ++i) {
     ((CPDF_Object*)m_arrayAcroforms.GetAt(i))->Release();
   }
 }
 void CPDF_DataAvail::SetDocument(CPDF_Document* pDoc) {
   m_pDocument = pDoc;
 }
 FX_DWORD CPDF_DataAvail::GetObjectSize(FX_DWORD objnum, FX_FILESIZE& offset) {
@@ skipping 64 matching lines @@
           value = pDict->GetNextElement(pos, key);
           if (key != "Parent") {
             new_obj_array.Add(value);
           }
         }
       } break;
       case PDFOBJ_REFERENCE: {
         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) {
+        FX_DWORD size = GetObjectSize(dwNum, offset);
+        if (size == 0 || offset < 0 || offset >= m_dwFileLen) {
           break;
         }
-
-        size += offset;
-        size += 512;
-        if (!size.IsValid()) {
-          break;
-        }
-        if (size.ValueOrDie() > m_dwFileLen) {
-          size = m_dwFileLen - offset;
-        } else {
-          size = original_size + 512;
-        }
-        if (!size.IsValid()) {
-          break;
-        }
-        if (!m_pFileAvail->IsDataAvail(offset, size.ValueOrDie())) {
-          pHints->AddSegment(offset, size.ValueOrDie());
+        if (!IsDataAvail(offset, size, pHints)) {
           ret_array.Add(pObj);
           count++;
         } else if (!m_objnum_array.Find(dwNum)) {
           m_objnum_array.AddObjNum(dwNum);
           CPDF_Object* pReferred =
               m_pDocument->GetIndirectObject(pRef->GetRefObjNum(), NULL);
           if (pReferred) {
             new_obj_array.Add(pReferred);
           }
         }
@@ skipping 79 matching lines @@
   m_docStatus = PDF_DATAAVAIL_PAGETREE;
   return TRUE;
 }
 FX_BOOL CPDF_DataAvail::CheckDocStatus(IFX_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);
     case PDF_DATAAVAIL_CROSSREF:
       return CheckCrossRef(pHints);
     case PDF_DATAAVAIL_CROSSREF_ITEM:
       return CheckCrossRefItem(pHints);
     case PDF_DATAAVAIL_CROSSREF_STREAM:
       return CheckAllCrossRefStream(pHints);
     case PDF_DATAAVAIL_TRAILER:
       return CheckTrailer(pHints);
@@ skipping 64 matching lines @@
               _CompareFileSize);
   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(FX_DWORD objnum,
                                        IFX_DownloadHints* pHints,
                                        FX_BOOL* pExistInFile) {
-  CPDF_Object* pRet = NULL;
-  FX_DWORD original_size = 0;
+  CPDF_Object* pRet = nullptr;
+  FX_DWORD size = 0;
   FX_FILESIZE offset = 0;
-  CPDF_Parser* pParser = NULL;
-
-  if (pExistInFile) {
+  CPDF_Parser* pParser = nullptr;
+  if (pExistInFile)
     *pExistInFile = TRUE;
-  }
 
   if (m_pDocument == NULL) {
-    original_size = (FX_DWORD)m_parser.GetObjectSize(objnum);
+    size = (FX_DWORD)m_parser.GetObjectSize(objnum);
     offset = m_parser.GetObjectOffset(objnum);
     pParser = &m_parser;
   } else {
-    original_size = GetObjectSize(objnum, offset);
+    size = GetObjectSize(objnum, offset);
     pParser = (CPDF_Parser*)(m_pDocument->GetParser());
   }
-
-  pdfium::base::CheckedNumeric<FX_DWORD> size = original_size;
-  if (size.ValueOrDefault(0) == 0 || offset < 0 || offset >= m_dwFileLen) {
-    if (pExistInFile)
-      *pExistInFile = FALSE;
-
-    return NULL;
-  }
-
-  size += offset;
-  size += 512;
-  if (!size.IsValid()) {
-    return NULL;
-  }
-
-  if (size.ValueOrDie() > m_dwFileLen) {
-    size = m_dwFileLen - offset;
-  } else {
-    size = original_size + 512;
-  }
-
-  if (!size.IsValid()) {
-    return NULL;
-  }
-
-  if (!m_pFileAvail->IsDataAvail(offset, size.ValueOrDie())) {
-    pHints->AddSegment(offset, size.ValueOrDie());
-    return NULL;
-  }
-
+  if (!IsDataAvail(offset, size, pHints)) {
+    return nullptr;
+  }
   if (pParser) {
     pRet = pParser->ParseIndirectObject(NULL, objnum, NULL);
   }
-
   if (!pRet && pExistInFile) {
     *pExistInFile = FALSE;
   }
-
   return pRet;
 }
-
 FX_BOOL CPDF_DataAvail::CheckInfo(IFX_DownloadHints* pHints) {
   FX_BOOL bExist = FALSE;
   CPDF_Object* pInfo = GetObject(m_dwInfoObjNum, pHints, &bExist);
   if (!bExist) {
     if (m_bHaveAcroForm) {
       m_docStatus = PDF_DATAAVAIL_ACROFORM;
     } else {
       m_docStatus = PDF_DATAAVAIL_PAGETREE;
     }
     return TRUE;
@@ skipping 269 matching lines @@
       FX_FILESIZE offset = m_dwLastXRefOffset;
       if (dwSize < 512 && dwFileLen > 512) {
         dwSize = 512;
         offset = dwFileLen - 512;
       }
       pHints->AddSegment(offset, dwSize);
     }
   } else {
     m_docStatus = PDF_DATAAVAIL_FIRSTPAGE_PREPARE;
   }
-  if (!bNeedDownLoad && m_docStatus == PDF_DATAAVAIL_FIRSTPAGE_PREPARE) {
+  if (bNeedDownLoad || m_docStatus != PDF_DATAAVAIL_FIRSTPAGE_PREPARE) {
+    m_docStatus = PDF_DATAAVAIL_FIRSTPAGE_PREPARE;
+    return FALSE;
+  }
+  m_docStatus =
+      m_bSupportHintTable ? PDF_DATAAVAIL_HINTTABLE : PDF_DATAAVAIL_DONE;
+  return TRUE;
+}
+FX_BOOL CPDF_DataAvail::IsDataAvail(FX_FILESIZE offset,
+                                    FX_DWORD size,
+                                    IFX_DownloadHints* pHints) {
+  if (!pHints || offset > m_dwFileLen) {
+    return TRUE;
+  }
+  FX_SAFE_DWORD safeSize = pdfium::base::checked_cast<FX_DWORD>(offset);
+  safeSize += size;
+  safeSize += 512;
+  if (!safeSize.IsValid()) {
+    return TRUE;
+  }
+  if (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(IFX_DownloadHints* pHints) {
+  CPDF_Dictionary* pDict = m_pLinearized->GetDict();
+  if (!pDict || !pHints) {
+    return TRUE;
+  }
+  if (!pDict->KeyExist(FX_BSTRC("H")) || !pDict->KeyExist(FX_BSTRC("O")) ||
+      !pDict->KeyExist(FX_BSTRC("N"))) {
     m_docStatus = PDF_DATAAVAIL_DONE;
     return TRUE;
   }
-  m_docStatus = PDF_DATAAVAIL_FIRSTPAGE_PREPARE;
-  return FALSE;
-}
-CPDF_Object* CPDF_DataAvail::ParseIndirectObjectAt(FX_FILESIZE pos,
-                                                   FX_DWORD objnum) {
+  int nPageCount = pDict->GetElementValue(FX_BSTRC("N"))->GetInteger();
+  if (nPageCount <= 1) {
+    m_docStatus = PDF_DATAAVAIL_DONE;
+    return TRUE;
+  }
+  CPDF_Array* pHintStreamRange = pDict->GetArray(FX_BSTRC("H"));
+  FX_FILESIZE szHSStart, szHSLength;

[Tom Sepez, 2015/09/22 00:05:39]

nit: one per line, combine declaration and initialization below.

[jun_fang, 2015/09/22 12:42:32]

Acknowledged.

+  szHSStart = pHintStreamRange->GetElementValue(0)
+                  ? pHintStreamRange->GetElementValue(0)->GetInteger()
+                  : 0;
+  szHSLength = pHintStreamRange->GetElementValue(1)
+                   ? pHintStreamRange->GetElementValue(1)->GetInteger()
+                   : 0;
+  if (szHSStart < 0 || szHSLength <= 0) {
+    m_docStatus = PDF_DATAAVAIL_DONE;
+    return TRUE;
+  }
+  if (!IsDataAvail(szHSStart, szHSLength, pHints)) {
+    return FALSE;
+  }
+  m_syntaxParser.InitParser(m_pFileRead, m_dwHeaderOffset);
+  CPDF_HintTables* pHintTables = new CPDF_HintTables(this, pDict);

[Tom Sepez, 2015/09/22 00:05:39]

nit: unique_ptr<> might help here, as well.

[jun_fang, 2015/09/22 12:42:32]

If we define pHintTables and m_pHintTables like below:
nonstd::unique_ptr<CPDF_HintTables> pHintTables;
nonstd::unique_ptr<CPDF_HintTables> m_pHintTables;

There is no way to assign pHintTables to m_pHintTables.

[Tom Sepez, 2015/09/22 15:16:43]

See nonstd::move() (recently added) (a websearch on std::move() will give some
background).

+  CPDF_Stream* pHintStream = (CPDF_Stream*)ParseIndirectObjectAt(szHSStart, 0);
+  if (!pHintStream || pHintStream->GetType() != PDFOBJ_STREAM) {
+    delete pHintTables;
+    pHintTables = NULL;
+  }
+  if (pHintTables && !pHintTables->LoadHintStream(pHintStream)) {
+    delete pHintTables;
+    pHintTables = NULL;
+  }
+  m_pHintTables = pHintTables;
+  m_docStatus = PDF_DATAAVAIL_DONE;
+  return TRUE;
+}
+CPDF_Object* CPDF_DataAvail::ParseIndirectObjectAt(
+    FX_FILESIZE pos,
+    FX_DWORD objnum,
+    CPDF_IndirectObjects* pObjList) {
   FX_FILESIZE SavedPos = m_syntaxParser.SavePos();
   m_syntaxParser.RestorePos(pos);
   FX_BOOL bIsNumber;
   CFX_ByteString word = m_syntaxParser.GetNextWord(bIsNumber);
   if (!bIsNumber) {
     return NULL;
   }
   FX_DWORD parser_objnum = FXSYS_atoi(word);
   if (objnum && parser_objnum != objnum) {
     return NULL;
   }
   word = m_syntaxParser.GetNextWord(bIsNumber);
   if (!bIsNumber) {
     return NULL;
   }
   FX_DWORD gennum = FXSYS_atoi(word);
   if (m_syntaxParser.GetKeyword() != FX_BSTRC("obj")) {
     m_syntaxParser.RestorePos(SavedPos);
     return NULL;
   }
-  CPDF_Object* pObj = m_syntaxParser.GetObject(NULL, objnum, gennum, 0);
+  CPDF_Object* pObj =
+      m_syntaxParser.GetObject(pObjList, parser_objnum, gennum, 0);
   m_syntaxParser.RestorePos(SavedPos);
   return pObj;
 }
 int32_t CPDF_DataAvail::IsLinearizedPDF() {
   FX_DWORD req_size = 1024;
   if (!m_pFileAvail->IsDataAvail(0, req_size)) {
     return PDF_UNKNOW_LINEARIZED;
   }
   if (!m_pFileRead) {
     return PDF_NOT_LINEARIZED;
@@ skipping 737 matching lines @@
     return TRUE;
   }
   if (m_bLinearized) {
     if ((FX_DWORD)iPage == m_dwFirstPageNo) {
       m_pagesLoadState.insert(iPage);
       return TRUE;
     }
     if (!CheckLinearizedData(pHints)) {
       return FALSE;
     }
-    if (m_bMainXRefLoadedOK) {
-      if (m_bTotalLoadPageTree) {
-        if (!LoadPages(pHints)) {
+    if (m_pHintTables) {
+      if (!m_pHintTables->CheckPage(iPage, pHints)) {

[Tom Sepez, 2015/09/22 00:05:38]

nit: just return m_pHintTabls->CheckPage(...);

[jun_fang, 2015/09/22 12:42:32]

Acknowledged.

+        return FALSE;
+      }
+      return TRUE;
+    } else {

[Tom Sepez, 2015/09/22 00:05:39]

nit: else after return not needed.

[jun_fang, 2015/09/22 12:42:32]

Acknowledged.

+      if (m_bMainXRefLoadedOK) {
+        if (m_bTotalLoadPageTree) {
+          if (!LoadPages(pHints)) {
+            return FALSE;
+          }
+        } else {
+          if (!m_bCurPageDictLoadOK && !CheckPage(iPage, pHints)) {
+            return FALSE;
+          }
+        }
+      } else {
+        if (!LoadAllFile(pHints)) {
           return FALSE;
         }
-      } else {
-        if (!m_bCurPageDictLoadOK && !CheckPage(iPage, pHints)) {
-          return FALSE;
-        }
-      }
-    } else {
-      if (!LoadAllFile(pHints)) {
-        return FALSE;
-      }
-      ((CPDF_Parser*)m_pDocument->GetParser())->RebuildCrossRef();
-      ResetFirstCheck(iPage);
-      return TRUE;
+        ((CPDF_Parser*)m_pDocument->GetParser())->RebuildCrossRef();
+        ResetFirstCheck(iPage);
+        return TRUE;
+      }
     }
   } else {
     if (!m_bTotalLoadPageTree) {
       if (!m_bCurPageDictLoadOK && !CheckPage(iPage, pHints)) {
         return FALSE;
       }
     }
   }
   if (m_bHaveAcroForm && !m_bAcroFormLoad) {
     if (!CheckAcroFormSubObject(pHints)) {
@@ skipping 83 matching lines @@
 }
 void CPDF_DataAvail::GetLinearizedMainXRefInfo(FX_FILESIZE* pPos,
                                                FX_DWORD* pSize) {
   if (pPos) {
     *pPos = m_dwLastXRefOffset;
   }
   if (pSize) {
     *pSize = (FX_DWORD)(m_dwFileLen - m_dwLastXRefOffset);
   }
 }
+int CPDF_DataAvail::GetPageCount() const {
+  if (!m_pDocument && !m_pLinearized) {
+    return 0;
+  }
+  if (m_pLinearized) {
+    CPDF_Dictionary* pDict = m_pLinearized->GetDict();
+    CPDF_Object* pObj = pDict ? pDict->GetElementValue(FX_BSTRC("N")) : nullptr;
+    return pObj ? pObj->GetInteger() : 0;
+  }
+  return m_pDocument->GetPageCount();
+}
+CPDF_Dictionary* CPDF_DataAvail::GetPage(int index) {
+  if (!m_pDocument || index < 0 || index >= this->GetPageCount()) {
+    return nullptr;
+  }
+  if (m_pLinearized) {
+    CPDF_Dictionary* pDict = m_pLinearized->GetDict();
+    CPDF_Object* pObj = pDict ? pDict->GetElementValue(FX_BSTRC("P")) : nullptr;
+    int pageNum = pObj ? pObj->GetInteger() : 0;
+    if (m_pHintTables && index != pageNum) {
+      FX_FILESIZE szPageStartPos = 0;
+      FX_FILESIZE szPageLength = 0;
+      FX_DWORD dwObjNum = 0;
+      FX_BOOL bPagePosGot = m_pHintTables->GetPagePos(index, szPageStartPos,
+                                                      szPageLength, dwObjNum);
+      if (!bPagePosGot) {
+        return nullptr;
+      }
+      m_syntaxParser.InitParser(m_pFileRead, (FX_DWORD)szPageStartPos);
+      CPDF_Object* pPageDict = ParseIndirectObjectAt(0, dwObjNum, m_pDocument);
+      if (!pPageDict) {
+        return nullptr;
+      }
+      m_pDocument->InsertIndirectObject(dwObjNum, pPageDict);
+      return pPageDict->GetDict();
+    }
+  }
+  return m_pDocument->GetPage(index);
+}
 int32_t CPDF_DataAvail::IsFormAvail(IFX_DownloadHints* pHints) {
   if (!m_pDocument) {
     return PDFFORM_AVAIL;
   }
   if (!m_bLinearizedFormParamLoad) {
     CPDF_Dictionary* pRoot = m_pDocument->GetRoot();
     if (!pRoot) {
       return PDFFORM_AVAIL;
     }
     CPDF_Object* pAcroForm = pRoot->GetElement(FX_BSTRC("AcroForm"));
@@ skipping 47 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();
 }
+CPDF_HintTables::~CPDF_HintTables() {
+  m_nFirstPageSharedObjs = 0;
+  m_szFirstPageObjOffset = 0;
+  m_dwDeltaNObjsArray.RemoveAll();
+  m_dwNSharedObjsArray.RemoveAll();
+  m_dwSharedObjNumArray.RemoveAll();
+  m_dwIdentifierArray.RemoveAll();
+  m_szPageOffsetArray.RemoveAll();
+  m_szSharedObjOffsetArray.RemoveAll();
+}
+FX_DWORD CPDF_HintTables::GetItemLength(int index, CFX_FileSizeArray& szArray) {

[Tom Sepez, 2015/09/22 00:05:38]

nit: const CFX_FileSizeArray&

[jun_fang, 2015/09/22 12:42:32]

Acknowledged.

+  if (index < 0 || index > szArray.GetSize() - 2) {
+    return 0;
+  }
+  return (szArray[index + 1] - szArray[index]);

[Tom Sepez, 2015/09/22 00:05:39]

nit: unnecessary ()

[jun_fang, 2015/09/22 12:42:32]

Acknowledged.

+}
+FX_BOOL CPDF_HintTables::ReadPageHintTable(CFX_BitStream& h) {
+  if (!m_pLinearizedDict) {
+    return FALSE;
+  }
+  CPDF_Array* pRange = m_pLinearizedDict->GetArray(FX_BSTRC("H"));
+  CPDF_Object* pStreamOffset = pRange ? pRange->GetElementValue(0) : nullptr;
+  CPDF_Object* pStreamLen = pRange ? pRange->GetElementValue(1) : nullptr;

[Tom Sepez, 2015/09/22 00:05:39]

nit: prefer early return here rather than duplicating the same test in several ?
operators.

[jun_fang, 2015/09/22 12:42:32]

Acknowledged.

+  int nStreamOffset = pStreamOffset ? pStreamOffset->GetInteger() : -1;
+  int nStreanLen = pStreamLen ? pStreamLen->GetInteger() : 0;

[Tom Sepez, 2015/09/22 00:05:39]

nit: typo: stream vs. strean

[jun_fang, 2015/09/22 12:42:32]

Acknowledged.

+  if (nStreamOffset < 0 || nStreanLen < 1) {
+    return FALSE;
+  }
+  // Item 1: The least number of objects in a page.
+  FX_DWORD dwObjLeastNum = h.GetBits(32);
+  // Item 2: The location of the first page¡¯s page object.

[Tom Sepez, 2015/09/22 00:05:38]

nit: typo.

[jun_fang, 2015/09/22 12:42:32]

Acknowledged.

+  FX_DWORD dwFirstObjLoc = h.GetBits(32);
+  if (dwFirstObjLoc > nStreamOffset) {
+    m_szFirstPageObjOffset = dwFirstObjLoc + nStreanLen;

[Tom Sepez, 2015/09/22 00:05:38]

how do we know this doesn't overflow?

[jun_fang, 2015/09/22 12:42:32]

Acknowledged.

+  } else {
+    m_szFirstPageObjOffset = dwFirstObjLoc;
+  }
+  // Item 3: The number of bits needed to represent the difference
+  // between the greatest and least number of objects in a page.
+  FX_DWORD dwDeltaObjectsBits = h.GetBits(16);
+  // Item 4: The least length of a page in bytes.
+  FX_DWORD dwPageLeastLen = h.GetBits(32);
+  // Item 5: The number of bits needed to represent the difference
+  // between the greatest and least length of a page, in bytes.
+  FX_DWORD dwDeltaPageLenBits = h.GetBits(16);
+  // Skip Item 6, 7, 8, 9 total 96 bits.
+  h.SkipBits(96);
+  // Item 10: The number of bits needed to represent the greatest
+  // number of shared object references.
+  FX_DWORD dwSharedObjBits = h.GetBits(16);
+  // Item 11: The number of bits needed to represent the numerically
+  // greatest shared object identifier used by the pages.
+  FX_DWORD dwSharedIdBits = h.GetBits(16);
+  // Item 12: The number of bits needed to represent the numerator of
+  // the fractional position for each shared object reference. For each
+  // shared object referenced from a page, there is an indication of
+  // where in the page¡¯s content stream the object is first referenced.

[Tom Sepez, 2015/09/22 00:05:39]

nit: typo

[jun_fang, 2015/09/22 12:42:32]

Acknowledged.

+  FX_DWORD dwSharedNumeratorBits = h.GetBits(16);
+  // Item 13: The denominator of the fractional position for each shared
+  // object reference. It's useless.
+  FX_DWORD dwSharedDenominator = h.GetBits(16);

[Tom Sepez, 2015/09/22 00:05:39]

nit: just skipbits for item 13 like above.

[jun_fang, 2015/09/22 12:42:32]

Acknowledged.

+  CPDF_Object* pPageNum = m_pLinearizedDict->GetElementValue(FX_BSTRC("N"));
+  int nPages = pPageNum ? pPageNum->GetInteger() : 0;
+  if (nPages < 1) {
+    return FALSE;
+  }
+  for (int i = 0; i < nPages; ++i) {
+    m_dwDeltaNObjsArray.Add(h.GetBits(dwDeltaObjectsBits) + dwObjLeastNum);

[Tom Sepez, 2015/09/22 00:05:38]

overflow on addition?

[jun_fang, 2015/09/22 12:42:32]

Acknowledged.

+  }
+  h.ByteAlign();
+  CFX_DWordArray dwPageLenArray;
+  for (int i = 0; i < nPages; ++i) {
+    dwPageLenArray.Add(h.GetBits(dwDeltaPageLenBits) + dwPageLeastLen);
+  }
+  CPDF_Object* pOffsetE = m_pLinearizedDict->GetElementValue(FX_BSTRC("E"));
+  int nOffsetE = pOffsetE ? pOffsetE->GetInteger() : -1;
+  if (nOffsetE < 0) {
+    return FALSE;
+  }
+  CPDF_Object* pFirstPageNum =
+      m_pLinearizedDict->GetElementValue(FX_BSTRC("P"));
+  int nFirstPageNum = pFirstPageNum ? pFirstPageNum->GetInteger() : 0;
+  for (int i = 0; i < nPages; ++i) {
+    if (i == nFirstPageNum) {
+      m_szPageOffsetArray.Add(m_szFirstPageObjOffset);
+    } else if (i == nFirstPageNum + 1) {
+      if (i == 1) {
+        m_szPageOffsetArray.Add(nOffsetE);
+      } else {
+        m_szPageOffsetArray.Add(m_szPageOffsetArray[i - 2] +
+                                dwPageLenArray[i - 2]);
+      }
+    } else {
+      if (i == 0) {
+        m_szPageOffsetArray.Add(nOffsetE);
+      } else {
+        m_szPageOffsetArray.Add(m_szPageOffsetArray[i - 1] +
+                                dwPageLenArray[i - 1]);
+      }
+    }
+  }
+  if (nPages > 0) {
+    m_szPageOffsetArray.Add(m_szPageOffsetArray[nPages - 1] +
+                            dwPageLenArray[nPages - 1]);
+  } else {
+    m_szPageOffsetArray.Add(m_szFirstPageObjOffset);

[Tom Sepez, 2015/09/22 00:05:38]

I don't think this can be reached since we returned at 4850 otherwise?

[jun_fang, 2015/09/22 12:42:32]

Acknowledged.

+    m_szPageOffsetArray.Add(nOffsetE);
+  }
+  h.ByteAlign();
+  /** The number of shared objects. */

[Tom Sepez, 2015/09/22 00:05:39]

nit: prefer c++ // style.

[jun_fang, 2015/09/22 12:42:32]

Acknowledged.

+  for (int i = 0; i < nPages; i++) {
+    m_dwNSharedObjsArray.Add(h.GetBits(dwSharedObjBits));
+  }
+  h.ByteAlign();
+  // array of identifier, sizes = nshared_objects
+  for (int i = 0; i < nPages; i++) {
+    for (int j = 0; j < m_dwNSharedObjsArray[i]; j++) {
+      m_dwIdentifierArray.Add(h.GetBits(dwSharedIdBits));
+    }
+  }
+  h.ByteAlign();
+  for (int i = 0; i < nPages; i++) {
+    h.SkipBits(m_dwNSharedObjsArray[i] * dwSharedNumeratorBits);

[Tom Sepez, 2015/09/22 00:05:38]

again, overflow? 

+  }
+  h.ByteAlign();
+  h.SkipBits(dwDeltaPageLenBits * nPages);

[Tom Sepez, 2015/09/22 00:05:39]

overflow?

[jun_fang, 2015/09/22 12:42:32]

Acknowledged.

+  h.ByteAlign();
+  return TRUE;
+}
+FX_BOOL CPDF_HintTables::ReadSharedObjHintTable(CFX_BitStream& h) {
+  if (!m_pLinearizedDict) {
+    return FALSE;
+  }
+  CPDF_Array* pRange = m_pLinearizedDict->GetArray(FX_BSTRC("H"));

[Tom Sepez, 2015/09/22 00:05:39]

nit: same as above. Let's make a helper function and consolidate.

[jun_fang, 2015/09/22 12:42:32]

Acknowledged.

+  CPDF_Object* pStreamOffset = pRange ? pRange->GetElementValue(0) : nullptr;
+  CPDF_Object* pStreamLen = pRange ? pRange->GetElementValue(1) : nullptr;
+  int nStreamOffset = pStreamOffset ? pStreamOffset->GetInteger() : -1;
+  int nStreanLen = pStreamLen ? pStreamLen->GetInteger() : 0;

[Tom Sepez, 2015/09/22 00:05:39]

nit: typo: stream vs. strean

[jun_fang, 2015/09/22 12:42:32]

Acknowledged.

+  if (nStreamOffset < 0 || nStreanLen < 1) {
+    return FALSE;
+  }
+  // Item 1: The object number of the first object in the shared objects
+  // section.
+  FX_DWORD dwFirstSharedObjNum = h.GetBits(32);
+  // Item 2: The location of the first object in the shared objects section.
+  FX_DWORD dwFirstSharedObjLoc = h.GetBits(32);
+  if (dwFirstSharedObjLoc > nStreamOffset) {
+    dwFirstSharedObjLoc += nStreanLen;
+  }
+  // Item 3: The number of shared object entries for the first page.
+  m_nFirstPageSharedObjs = h.GetBits(32);
+  // Item 4: The number of shared object entries for the shared objects
+  // section, including the number of shared object entries for the first page.
+  FX_DWORD dwSharedObjTotal = h.GetBits(32);
+  // Item 5: The number of bits needed to represent the greatest number of
+  // objects in a shared object group. Skipped.
+  h.SkipBits(16);
+  // Item 6: The least length of a shared object group in bytes.
+  FX_DWORD dwGroupLeastLen = h.GetBits(32);
+  // Item 7: The number of bits needed to represent the difference between the
+  // greatest and least length of a shared object group, in bytes.
+  FX_DWORD dwDeltaGroupLen = h.GetBits(16);
+  CPDF_Object* pFirstPageObj =
+      m_pLinearizedDict->GetElementValue(FX_BSTRC("O"));
+  int nFirstPageObjNum = pFirstPageObj ? pFirstPageObj->GetInteger() : -1;
+  if (nFirstPageObjNum < 0) {
+    return FALSE;
+  }
+  FX_DWORD dwSharedObjLen = 0;
+  FX_DWORD dwSharedObjsLen = 0;
+  for (int i = 0; i < dwSharedObjTotal; ++i) {
+    dwSharedObjLen = dwSharedObjsLen;
+    dwSharedObjsLen = h.GetBits(dwDeltaGroupLen) + dwGroupLeastLen;

[Tom Sepez, 2015/09/22 00:05:39]

nit: overflow.

+    if (i < m_nFirstPageSharedObjs) {
+      m_dwSharedObjNumArray.Add(nFirstPageObjNum + i);
+      if (i == 0) {
+        m_szSharedObjOffsetArray.Add(m_szFirstPageObjOffset);
+      } else {
+        m_szSharedObjOffsetArray.Add(m_szSharedObjOffsetArray[i - 1] +
+                                     dwSharedObjLen);
+      }
+    } else {
+      m_dwSharedObjNumArray.Add(dwSharedObjTotal + i - m_nFirstPageSharedObjs);
+      if (i == m_nFirstPageSharedObjs) {
+        m_szSharedObjOffsetArray.Add(dwSharedObjTotal);
+      } else {
+        m_szSharedObjOffsetArray.Add(m_szSharedObjOffsetArray[i - 1] +
+                                     dwSharedObjLen);
+      }
+    }
+  }
+  if (dwSharedObjTotal > 0) {
+    m_szSharedObjOffsetArray.Add(
+        m_szSharedObjOffsetArray[dwSharedObjTotal - 1] + dwSharedObjsLen);
+  }
+  h.ByteAlign();
+  h.SkipBits(dwSharedObjTotal);
+  h.ByteAlign();
+  return TRUE;
+}
+FX_BOOL CPDF_HintTables::GetPagePos(int index,
+                                    FX_FILESIZE& szPageStartPos,
+                                    FX_FILESIZE& szPageLength,
+                                    FX_DWORD& dwObjNum) {
+  if (!m_pLinearizedDict) {
+    return FALSE;
+  }
+  szPageStartPos = m_szPageOffsetArray[index];
+  szPageLength = GetItemLength(index, m_szPageOffsetArray);
+  CPDF_Object* pFirstPageNum =
+      m_pLinearizedDict->GetElementValue(FX_BSTRC("P"));
+  int nFirstPageNum = pFirstPageNum ? pFirstPageNum->GetInteger() : 0;
+  CPDF_Object* pFirstPageObjNum =
+      m_pLinearizedDict->GetElementValue(FX_BSTRC("O"));
+  if (!pFirstPageObjNum) {
+    return FALSE;
+  }
+  int nFirstPageObjNum = pFirstPageObjNum->GetInteger();
+  if (index == nFirstPageNum) {
+    dwObjNum = nFirstPageObjNum;
+    return TRUE;
+  }
+  // The object number of remaining pages starts from 1.
+  dwObjNum = 1;
+  for (int i = 0; i < index; ++i) {
+    if (i == nFirstPageNum) {
+      continue;
+    }
+    dwObjNum += m_dwDeltaNObjsArray[i];
+  }
+  return TRUE;
+}
+FX_BOOL CPDF_HintTables::CheckPage(int index, IFX_DownloadHints* pHints) {
+  if (!m_pLinearizedDict) {
+    return FALSE;
+  }
+  CPDF_Object* pFirstAvailPage =
+      m_pLinearizedDict->GetElementValue(FX_BSTRC("P"));
+  int nFirstAvailPage = pFirstAvailPage ? pFirstAvailPage->GetInteger() : 0;
+  if (index == nFirstAvailPage) {
+    return TRUE;
+  }
+  FX_DWORD dwLength = GetItemLength(index, m_szPageOffsetArray);
+  if (!dwLength ||
+      !m_pDataAvail->IsDataAvail(m_szPageOffsetArray[index], dwLength,
+                                 pHints)) {
+    return FALSE;
+  }
+  // Download data of shared objects in the page.
+  FX_DWORD offset = 0;
+  for (int i = 0; i < index; ++i) {
+    offset += m_dwNSharedObjsArray[i];
+  }
+  CPDF_Object* pFirstPageObj =
+      m_pLinearizedDict->GetElementValue(FX_BSTRC("O"));
+  int nFirstPageObjNum = pFirstPageObj ? pFirstPageObj->GetInteger() : -1;
+  if (nFirstPageObjNum < 0) {
+    return FALSE;
+  }
+  FX_DWORD dwIndex = 0;
+  FX_DWORD dwObjNum = 0;
+  for (int j = 0; j < m_dwNSharedObjsArray[index]; ++j) {
+    dwIndex = m_dwIdentifierArray[offset + j];

[Tom Sepez, 2015/09/22 00:05:38]

how do we know that the bounds are trustworthy here?

+    dwObjNum = m_dwSharedObjNumArray[dwIndex];
+    if (dwObjNum >= nFirstPageObjNum &&
+        dwObjNum < nFirstPageObjNum + m_nFirstPageSharedObjs) {
+      continue;
+    }
+    dwLength = GetItemLength(dwIndex, m_szSharedObjOffsetArray);
+    if (!dwLength ||
+        !m_pDataAvail->IsDataAvail(m_szSharedObjOffsetArray[dwIndex], dwLength,
+                                   pHints)) {
+      return FALSE;
+    }
+  }
+  return TRUE;
+}
+FX_BOOL CPDF_HintTables::LoadHintStream(CPDF_Stream* pHintStream) {
+  if (!pHintStream || !m_pLinearizedDict) {
+    return FALSE;
+  }
+  CPDF_Dictionary* pDict = pHintStream->GetDict();
+  CPDF_Object* pOffset = pDict ? pDict->GetElement(FX_BSTRC("S")) : nullptr;
+  if (!pOffset || pOffset->GetType() != PDFOBJ_NUMBER) {
+    return FALSE;
+  }
+  CPDF_StreamAcc acc;
+  acc.LoadAllData(pHintStream);
+  FX_DWORD size = acc.GetSize();
+  // The header section of page offset hint table is 36 bytes.
+  // The header section of shared object hint table is 24 bytes.
+  // Hint table has at least 60 bytes.
+  const FX_DWORD MIN_STREAM_LEN = 60;
+  if (size < MIN_STREAM_LEN || size < pOffset->GetInteger() ||
+      !pOffset->GetInteger()) {
+    return FALSE;
+  }
+  const uint8_t* pData = acc.GetData();

[Tom Sepez, 2015/09/22 00:05:39]

nit: don't ned a local here, just bs.Init(acc.GetData()...) below.

[jun_fang, 2015/09/22 12:42:32]

Acknowledged.

+  CFX_BitStream bs;
+  bs.Init(pData, size);
+  if (!ReadPageHintTable(bs) || !ReadSharedObjHintTable(bs)) {

[Tom Sepez, 2015/09/22 00:05:39]

nit: or just 

  return ReadPageHintTable(bs) && readSharedObjHintTable(bs);

[jun_fang, 2015/09/22 12:42:32]

Acknowledged.

+    return FALSE;
+  }
+  return TRUE;
+}