Use unsigned page indexes in CPDF_HintTables.

core/fpdfapi/fpdf_parser/cpdf_hint_tables.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/cpdf_hint_tables.h"
 
 #include "core/fpdfapi/fpdf_parser/include/cpdf_array.h"
 #include "core/fpdfapi/fpdf_parser/include/cpdf_data_avail.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_stream.h"
 #include "core/fpdfapi/fpdf_parser/include/cpdf_stream_acc.h"
 #include "core/fxcrt/include/fx_safe_types.h"
+#include "third_party/base/numerics/safe_conversions.h"
 
 namespace {
 
 bool CanReadFromBitStream(const CFX_BitStream* hStream,
                           const FX_SAFE_UINT32& bits) {
   return bits.IsValid() && hStream->BitsRemaining() >= bits.ValueOrDie();
 }
 
 // Sanity check values from the page table header. The note in the PDF 1.7
 // reference for Table F.3 says the valid range is only 0 through 32. Though 0
 // is not useful either.
 bool IsValidPageOffsetHintTableBitCount(uint32_t bits) {
   return bits > 0 && bits <= 32;
 }
 
 }  // namespace
 
 CPDF_HintTables::CPDF_HintTables(CPDF_DataAvail* pDataAvail,
                                  CPDF_Dictionary* pLinearized)
     : m_pDataAvail(pDataAvail),
       m_pLinearizedDict(pLinearized),
       m_nFirstPageSharedObjs(0),
       m_szFirstPageObjOffset(0) {
   ASSERT(m_pLinearizedDict);
 }
 
 CPDF_HintTables::~CPDF_HintTables() {}
 
 uint32_t CPDF_HintTables::GetItemLength(
-    int index,
+    uint32_t index,
     const std::vector<FX_FILESIZE>& szArray) {
-  if (index < 0 || szArray.size() < 2 ||
-      static_cast<size_t>(index) > szArray.size() - 2 ||
+  if (szArray.size() < 2 || index > szArray.size() - 2 ||
       szArray[index] > szArray[index + 1]) {
     return 0;
   }
   return szArray[index + 1] - szArray[index];
 }
 
 bool CPDF_HintTables::ReadPageHintTable(CFX_BitStream* hStream) {
   if (!hStream || hStream->IsEOF())
     return false;
 
@@ skipping 289 matching lines @@
 
   hStream->ByteAlign();
   if (hStream->BitsRemaining() < dwSharedObjTotal)
     return false;
 
   hStream->SkipBits(dwSharedObjTotal);
   hStream->ByteAlign();
   return true;
 }
 
-bool CPDF_HintTables::GetPagePos(int index,
+bool CPDF_HintTables::GetPagePos(uint32_t index,
                                  FX_FILESIZE* szPageStartPos,
                                  FX_FILESIZE* szPageLength,
                                  uint32_t* dwObjNum) {
-  if (index < 0)
-    return false;
-
   *szPageStartPos = m_szPageOffsetArray[index];
   *szPageLength = GetItemLength(index, m_szPageOffsetArray);
 
   int nFirstPageObjNum = GetFirstPageObjectNumber();
   if (nFirstPageObjNum < 0)
     return false;
 
   int nFirstPageNum = GetFirstPageNumber();
-  if (nFirstPageNum < 0)
+  if (!pdfium::base::IsValueInRangeForNumericType<uint32_t>(nFirstPageNum))
     return false;
 
-  if (index == nFirstPageNum) {
+  uint32_t dwFirstPageNum = static_cast<uint32_t>(nFirstPageNum);
+  if (index == dwFirstPageNum) {
     *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)
+  for (uint32_t i = 0; i < index; ++i) {
+    if (i == dwFirstPageNum)
       continue;
     *dwObjNum += m_dwDeltaNObjsArray[i];
   }
   return true;
 }
 
 CPDF_DataAvail::DocAvailStatus CPDF_HintTables::CheckPage(
-    int index,
+    uint32_t index,
     CPDF_DataAvail::DownloadHints* pHints) {
-  if (!pHints || index < 0)
+  if (!pHints)
     return CPDF_DataAvail::DataError;
 
-  if (index == GetFirstPageNumber())
+  int nFirstPageNum = GetFirstPageNumber();
+  if (!pdfium::base::IsValueInRangeForNumericType<uint32_t>(nFirstPageNum))
+    return CPDF_DataAvail::DataError;
+
+  if (index == static_cast<uint32_t>(nFirstPageNum))
     return CPDF_DataAvail::DataAvailable;
 
   uint32_t dwLength = GetItemLength(index, m_szPageOffsetArray);
   // If two pages have the same offset, it should be treated as an error.
   if (!dwLength)
     return CPDF_DataAvail::DataError;
 
   if (!m_pDataAvail->IsDataAvail(m_szPageOffsetArray[index], dwLength, pHints))
     return CPDF_DataAvail::DataNotAvailable;
 
   // Download data of shared objects in the page.
   uint32_t offset = 0;
-  for (int i = 0; i < index; ++i)
+  for (uint32_t i = 0; i < index; ++i)
     offset += m_dwNSharedObjsArray[i];
 
   int nFirstPageObjNum = GetFirstPageObjectNumber();
   if (nFirstPageObjNum < 0)
     return CPDF_DataAvail::DataError;
 
   uint32_t dwIndex = 0;
   uint32_t dwObjNum = 0;
   for (uint32_t j = 0; j < m_dwNSharedObjsArray[index]; ++j) {
     dwIndex = m_dwIdentifierArray[offset + j];
@@ skipping 85 matching lines @@
 }
 
 int CPDF_HintTables::ReadPrimaryHintStream(int index) const {
   CPDF_Array* pRange = m_pLinearizedDict->GetArrayBy("H");
   if (!pRange)
     return -1;
 
   CPDF_Object* pStreamLen = pRange->GetDirectObjectAt(index);
   return pStreamLen ? pStreamLen->GetInteger() : -1;
 }