Rename FX_SAFE_DWORD to FX_SAFE_UINT32

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/cpdf_data_avail.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_stream.h"
 #include "core/fpdfapi/fpdf_parser/include/cpdf_stream_acc.h"
 #include "core/fxcrt/include/fx_safe_types.h"
 
 namespace {
 
 bool CanReadFromBitStream(const CFX_BitStream* hStream,
-                          const FX_SAFE_DWORD& num_bits) {
+                          const FX_SAFE_UINT32& num_bits) {
   return num_bits.IsValid() &&
          hStream->BitsRemaining() >= num_bits.ValueOrDie();
 }
 
 }  // namespace
 
 CPDF_HintTables::~CPDF_HintTables() {
   m_dwDeltaNObjsArray.RemoveAll();
   m_dwNSharedObjsArray.RemoveAll();
   m_dwSharedObjNumArray.RemoveAll();
@@ skipping 23 matching lines @@
   const uint32_t kHeaderSize = 288;
   if (hStream->BitsRemaining() < kHeaderSize)
     return FALSE;
 
   // Item 1: The least number of objects in a page.
   uint32_t dwObjLeastNum = hStream->GetBits(32);
 
   // Item 2: The location of the first page's page object.
   uint32_t dwFirstObjLoc = hStream->GetBits(32);
   if (dwFirstObjLoc > static_cast<uint32_t>(nStreamOffset)) {
-    FX_SAFE_DWORD safeLoc = pdfium::base::checked_cast<uint32_t>(nStreamLen);
+    FX_SAFE_UINT32 safeLoc = pdfium::base::checked_cast<uint32_t>(nStreamLen);
     safeLoc += dwFirstObjLoc;
     if (!safeLoc.IsValid())
       return FALSE;
     m_szFirstPageObjOffset =
         pdfium::base::checked_cast<FX_FILESIZE>(safeLoc.ValueOrDie());
   } else {
     m_szFirstPageObjOffset =
         pdfium::base::checked_cast<FX_FILESIZE>(dwFirstObjLoc);
   }
 
@@ skipping 26 matching lines @@
   uint32_t dwSharedNumeratorBits = hStream->GetBits(16);
 
   // Item 13: Skip Item 13 which has 16 bits.
   hStream->SkipBits(16);
 
   CPDF_Object* pPageNum = m_pLinearizedDict->GetDirectObjectBy("N");
   int nPages = pPageNum ? pPageNum->GetInteger() : 0;
   if (nPages < 1)
     return FALSE;
 
-  FX_SAFE_DWORD required_bits = dwDeltaObjectsBits;
+  FX_SAFE_UINT32 required_bits = dwDeltaObjectsBits;
   required_bits *= pdfium::base::checked_cast<uint32_t>(nPages);
   if (!CanReadFromBitStream(hStream, required_bits))
     return FALSE;
 
   for (int i = 0; i < nPages; ++i) {
-    FX_SAFE_DWORD safeDeltaObj = hStream->GetBits(dwDeltaObjectsBits);
+    FX_SAFE_UINT32 safeDeltaObj = hStream->GetBits(dwDeltaObjectsBits);
     safeDeltaObj += dwObjLeastNum;
     if (!safeDeltaObj.IsValid())
       return FALSE;
     m_dwDeltaNObjsArray.Add(safeDeltaObj.ValueOrDie());
   }
   hStream->ByteAlign();
 
   required_bits = dwDeltaPageLenBits;
   required_bits *= pdfium::base::checked_cast<uint32_t>(nPages);
   if (!CanReadFromBitStream(hStream, required_bits))
     return FALSE;
 
   CFX_ArrayTemplate<uint32_t> dwPageLenArray;
   for (int i = 0; i < nPages; ++i) {
-    FX_SAFE_DWORD safePageLen = hStream->GetBits(dwDeltaPageLenBits);
+    FX_SAFE_UINT32 safePageLen = hStream->GetBits(dwDeltaPageLenBits);
     safePageLen += dwPageLeastLen;
     if (!safePageLen.IsValid())
       return FALSE;
     dwPageLenArray.Add(safePageLen.ValueOrDie());
   }
 
   CPDF_Object* pOffsetE = m_pLinearizedDict->GetDirectObjectBy("E");
   int nOffsetE = pOffsetE ? pOffsetE->GetInteger() : -1;
   if (nOffsetE < 0)
     return FALSE;
@@ skipping 42 matching lines @@
     required_bits *= m_dwNSharedObjsArray[i];
     if (!CanReadFromBitStream(hStream, required_bits))
       return FALSE;
 
     for (uint32_t j = 0; j < m_dwNSharedObjsArray[i]; j++)
       m_dwIdentifierArray.Add(hStream->GetBits(dwSharedIdBits));
   }
   hStream->ByteAlign();
 
   for (int i = 0; i < nPages; i++) {
-    FX_SAFE_DWORD safeSize = m_dwNSharedObjsArray[i];
+    FX_SAFE_UINT32 safeSize = m_dwNSharedObjsArray[i];
     safeSize *= dwSharedNumeratorBits;
     if (!CanReadFromBitStream(hStream, safeSize))
       return FALSE;
 
     hStream->SkipBits(safeSize.ValueOrDie());
   }
   hStream->ByteAlign();
 
-  FX_SAFE_DWORD safeTotalPageLen = pdfium::base::checked_cast<uint32_t>(nPages);
+  FX_SAFE_UINT32 safeTotalPageLen =
+      pdfium::base::checked_cast<uint32_t>(nPages);
   safeTotalPageLen *= dwDeltaPageLenBits;
   if (!CanReadFromBitStream(hStream, safeTotalPageLen))
     return FALSE;
 
   hStream->SkipBits(safeTotalPageLen.ValueOrDie());
   hStream->ByteAlign();
   return TRUE;
 }
 
 FX_BOOL CPDF_HintTables::ReadSharedObjHintTable(CFX_BitStream* hStream,
                                                 uint32_t offset) {
   if (!hStream || hStream->IsEOF())
     return FALSE;
 
   int nStreamOffset = ReadPrimaryHintStreamOffset();
   int nStreamLen = ReadPrimaryHintStreamLength();
   if (nStreamOffset < 0 || nStreamLen < 1)
     return FALSE;
 
-  FX_SAFE_DWORD bit_offset = offset;
+  FX_SAFE_UINT32 bit_offset = offset;
   bit_offset *= 8;
   if (!bit_offset.IsValid() || hStream->GetPos() > bit_offset.ValueOrDie())
     return FALSE;
   hStream->SkipBits(bit_offset.ValueOrDie() - hStream->GetPos());
 
   const uint32_t kHeaderSize = 192;
   if (hStream->BitsRemaining() < kHeaderSize)
     return FALSE;
 
   // Item 1: The object number of the first object in the shared objects
@@ skipping 22 matching lines @@
   // Item 7: The number of bits needed to represent the difference between the
   // greatest and least length of a shared object group, in bytes.
   uint32_t dwDeltaGroupLen = hStream->GetBits(16);
   CPDF_Object* pFirstPageObj = m_pLinearizedDict->GetDirectObjectBy("O");
   int nFirstPageObjNum = pFirstPageObj ? pFirstPageObj->GetInteger() : -1;
   if (nFirstPageObjNum < 0)
     return FALSE;
 
   uint32_t dwPrevObjLen = 0;
   uint32_t dwCurObjLen = 0;
-  FX_SAFE_DWORD required_bits = dwSharedObjTotal;
+  FX_SAFE_UINT32 required_bits = dwSharedObjTotal;
   required_bits *= dwDeltaGroupLen;
   if (!CanReadFromBitStream(hStream, required_bits))
     return FALSE;
 
   for (uint32_t i = 0; i < dwSharedObjTotal; ++i) {
     dwPrevObjLen = dwCurObjLen;
-    FX_SAFE_DWORD safeObjLen = hStream->GetBits(dwDeltaGroupLen);
+    FX_SAFE_UINT32 safeObjLen = hStream->GetBits(dwDeltaGroupLen);
     safeObjLen += dwGroupLeastLen;
     if (!safeObjLen.IsValid())
       return FALSE;
 
     dwCurObjLen = safeObjLen.ValueOrDie();
     if (i < m_nFirstPageSharedObjs) {
       m_dwSharedObjNumArray.Add(nFirstPageObjNum + i);
       if (i == 0)
         m_szSharedObjOffsetArray.push_back(m_szFirstPageObjOffset);
     } else {
-      FX_SAFE_DWORD safeObjNum = dwFirstSharedObjNum;
+      FX_SAFE_UINT32 safeObjNum = dwFirstSharedObjNum;
       safeObjNum += i - m_nFirstPageSharedObjs;
       if (!safeObjNum.IsValid())
         return FALSE;
 
       m_dwSharedObjNumArray.Add(safeObjNum.ValueOrDie());
       if (i == m_nFirstPageSharedObjs) {
         m_szSharedObjOffsetArray.push_back(
             pdfium::base::checked_cast<int32_t>(dwFirstSharedObjLoc));
       }
     }
@@ skipping 167 matching lines @@
   CPDF_Array* pRange = m_pLinearizedDict->GetArrayBy("H");
   if (!pRange)
     return -1;
 
   CPDF_Object* pStreamLen = pRange->GetDirectObjectAt(1);
   if (!pStreamLen)
     return -1;
 
   return pStreamLen->GetInteger();
 }