Remove FX_DWORD from core/ and delete definition

core/fxcodec/jbig2/JBig2_Context.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 "core/fxcodec/jbig2/JBig2_Context.h"
 
 #include <algorithm>
 #include <list>
@@ skipping 212 matching lines @@
     return JBIG2_SUCCESS;
   }
   if (nRet == JBIG2_SUCCESS) {
     m_ProcessingStatus = FXCODEC_STATUS_DECODE_FINISH;
   } else {
     m_ProcessingStatus = FXCODEC_STATUS_ERROR;
   }
   return nRet;
 }
 
-CJBig2_Segment* CJBig2_Context::findSegmentByNumber(FX_DWORD dwNumber) {
+CJBig2_Segment* CJBig2_Context::findSegmentByNumber(uint32_t dwNumber) {
   if (m_pGlobalContext) {
     CJBig2_Segment* pSeg = m_pGlobalContext->findSegmentByNumber(dwNumber);
     if (pSeg) {
       return pSeg;
     }
   }
   for (size_t i = 0; i < m_SegmentList.size(); ++i) {
     CJBig2_Segment* pSeg = m_SegmentList.get(i);
     if (pSeg->m_dwNumber == dwNumber) {
       return pSeg;
@@ skipping 16 matching lines @@
     }
   }
   return NULL;
 }
 int32_t CJBig2_Context::parseSegmentHeader(CJBig2_Segment* pSegment) {
   if (m_pStream->readInteger(&pSegment->m_dwNumber) != 0 ||
       m_pStream->read1Byte(&pSegment->m_cFlags.c) != 0) {
     return JBIG2_ERROR_TOO_SHORT;
   }
 
-  FX_DWORD dwTemp;
+  uint32_t dwTemp;
   uint8_t cTemp = m_pStream->getCurByte();
   if ((cTemp >> 5) == 7) {
     if (m_pStream->readInteger(
-            (FX_DWORD*)&pSegment->m_nReferred_to_segment_count) != 0) {
+            (uint32_t*)&pSegment->m_nReferred_to_segment_count) != 0) {
       return JBIG2_ERROR_TOO_SHORT;
     }
     pSegment->m_nReferred_to_segment_count &= 0x1fffffff;
     if (pSegment->m_nReferred_to_segment_count >
         JBIG2_MAX_REFERRED_SEGMENT_COUNT) {
       return JBIG2_ERROR_LIMIT;
     }
     dwTemp = 5 + 4 + (pSegment->m_nReferred_to_segment_count + 1) / 8;
   } else {
     if (m_pStream->read1Byte(&cTemp) != 0)
       return JBIG2_ERROR_TOO_SHORT;
 
     pSegment->m_nReferred_to_segment_count = cTemp >> 5;
     dwTemp = 5 + 1;
   }
   uint8_t cSSize =
       pSegment->m_dwNumber > 65536 ? 4 : pSegment->m_dwNumber > 256 ? 2 : 1;
   uint8_t cPSize = pSegment->m_cFlags.s.page_association_size ? 4 : 1;
   if (pSegment->m_nReferred_to_segment_count) {
     pSegment->m_pReferred_to_segment_numbers =
-        FX_Alloc(FX_DWORD, pSegment->m_nReferred_to_segment_count);
+        FX_Alloc(uint32_t, pSegment->m_nReferred_to_segment_count);
     for (int32_t i = 0; i < pSegment->m_nReferred_to_segment_count; ++i) {
       switch (cSSize) {
         case 1:
           if (m_pStream->read1Byte(&cTemp) != 0)
             return JBIG2_ERROR_TOO_SHORT;
 
           pSegment->m_pReferred_to_segment_numbers[i] = cTemp;
           break;
         case 2:
           uint16_t wTemp;
@@ skipping 83 matching lines @@
           m_pStream->readShortInteger(&wTemp) != 0) {
         return JBIG2_ERROR_TOO_SHORT;
       }
       pPageInfo->m_bIsStriped = !!(wTemp & 0x8000);
       pPageInfo->m_wMaxStripeSize = wTemp & 0x7fff;
       bool bMaxHeight = (pPageInfo->m_dwHeight == 0xffffffff);
       if (bMaxHeight && pPageInfo->m_bIsStriped != TRUE)
         pPageInfo->m_bIsStriped = TRUE;
 
       if (!m_bBufSpecified) {
-        FX_DWORD height =
+        uint32_t height =
             bMaxHeight ? pPageInfo->m_wMaxStripeSize : pPageInfo->m_dwHeight;
         m_pPage.reset(new CJBig2_Image(pPageInfo->m_dwWidth, height));
       }
 
       if (!m_pPage->m_pData) {
         m_ProcessingStatus = FXCODEC_STATUS_ERROR;
         return JBIG2_ERROR_TOO_SHORT;
       }
 
       m_pPage->fill((pPageInfo->m_cFlags & 4) ? 1 : 0);
@@ skipping 32 matching lines @@
   std::unique_ptr<CJBig2_SDDProc> pSymbolDictDecoder(new CJBig2_SDDProc);
   pSymbolDictDecoder->SDHUFF = wFlags & 0x0001;
   pSymbolDictDecoder->SDREFAGG = (wFlags >> 1) & 0x0001;
   pSymbolDictDecoder->SDTEMPLATE = (wFlags >> 10) & 0x0003;
   pSymbolDictDecoder->SDRTEMPLATE = (wFlags >> 12) & 0x0003;
   uint8_t cSDHUFFDH = (wFlags >> 2) & 0x0003;
   uint8_t cSDHUFFDW = (wFlags >> 4) & 0x0003;
   uint8_t cSDHUFFBMSIZE = (wFlags >> 6) & 0x0001;
   uint8_t cSDHUFFAGGINST = (wFlags >> 7) & 0x0001;
   if (pSymbolDictDecoder->SDHUFF == 0) {
-    const FX_DWORD dwTemp = (pSymbolDictDecoder->SDTEMPLATE == 0) ? 8 : 2;
-    for (FX_DWORD i = 0; i < dwTemp; ++i) {
+    const uint32_t dwTemp = (pSymbolDictDecoder->SDTEMPLATE == 0) ? 8 : 2;
+    for (uint32_t i = 0; i < dwTemp; ++i) {
       if (m_pStream->read1Byte((uint8_t*)&pSymbolDictDecoder->SDAT[i]) != 0)
         return JBIG2_ERROR_TOO_SHORT;
     }
   }
   if (pSymbolDictDecoder->SDREFAGG == 1 &&
       pSymbolDictDecoder->SDRTEMPLATE == 0) {
     for (int32_t i = 0; i < 4; ++i) {
       if (m_pStream->read1Byte((uint8_t*)&pSymbolDictDecoder->SDRAT[i]) != 0)
         return JBIG2_ERROR_TOO_SHORT;
     }
@@ skipping 17 matching lines @@
         findSegmentByNumber(pSegment->m_pReferred_to_segment_numbers[i]);
     if (pSeg->m_cFlags.s.type == 0) {
       pSymbolDictDecoder->SDNUMINSYMS += pSeg->m_Result.sd->NumImages();
       pLRSeg = pSeg;
     }
   }
 
   std::unique_ptr<CJBig2_Image*, FxFreeDeleter> SDINSYMS;
   if (pSymbolDictDecoder->SDNUMINSYMS != 0) {
     SDINSYMS.reset(FX_Alloc(CJBig2_Image*, pSymbolDictDecoder->SDNUMINSYMS));
-    FX_DWORD dwTemp = 0;
+    uint32_t dwTemp = 0;
     for (int32_t i = 0; i < pSegment->m_nReferred_to_segment_count; ++i) {
       CJBig2_Segment* pSeg =
           findSegmentByNumber(pSegment->m_pReferred_to_segment_numbers[i]);
       if (pSeg->m_cFlags.s.type == 0) {
         const CJBig2_SymbolDict& dict = *pSeg->m_Result.sd;
         for (size_t j = 0; j < dict.NumImages(); ++j)
           SDINSYMS.get()[dwTemp + j] = dict.GetImage(j);
         dwTemp += dict.NumImages();
       }
     }
@@ skipping 156 matching lines @@
   if (parseRegionInfo(&ri) != JBIG2_SUCCESS ||
       m_pStream->readShortInteger(&wFlags) != 0) {
     return JBIG2_ERROR_TOO_SHORT;
   }
 
   std::unique_ptr<CJBig2_TRDProc> pTRD(new CJBig2_TRDProc);
   pTRD->SBW = ri.width;
   pTRD->SBH = ri.height;
   pTRD->SBHUFF = wFlags & 0x0001;
   pTRD->SBREFINE = (wFlags >> 1) & 0x0001;
-  FX_DWORD dwTemp = (wFlags >> 2) & 0x0003;
+  uint32_t dwTemp = (wFlags >> 2) & 0x0003;
   pTRD->SBSTRIPS = 1 << dwTemp;
   pTRD->REFCORNER = (JBig2Corner)((wFlags >> 4) & 0x0003);
   pTRD->TRANSPOSED = (wFlags >> 6) & 0x0001;
   pTRD->SBCOMBOP = (JBig2ComposeOp)((wFlags >> 7) & 0x0003);
   pTRD->SBDEFPIXEL = (wFlags >> 9) & 0x0001;
   pTRD->SBDSOFFSET = (wFlags >> 10) & 0x001f;
   if (pTRD->SBDSOFFSET >= 0x0010) {
     pTRD->SBDSOFFSET = pTRD->SBDSOFFSET - 0x0020;
   }
   pTRD->SBRTEMPLATE = (wFlags >> 15) & 0x0001;
@@ skipping 65 matching lines @@
   if (pTRD->SBHUFF == 1) {
     SBSYMCODES.reset(
         decodeSymbolIDHuffmanTable(m_pStream.get(), pTRD->SBNUMSYMS));
     if (!SBSYMCODES)
       return JBIG2_ERROR_FATAL;
 
     m_pStream->alignByte();
     pTRD->SBSYMCODES = SBSYMCODES.get();
   } else {
     dwTemp = 0;
-    while ((FX_DWORD)(1 << dwTemp) < pTRD->SBNUMSYMS) {
+    while ((uint32_t)(1 << dwTemp) < pTRD->SBNUMSYMS) {
       ++dwTemp;
     }
     pTRD->SBSYMCODELEN = (uint8_t)dwTemp;
   }
 
   std::unique_ptr<CJBig2_HuffmanTable> Table_B1;
   std::unique_ptr<CJBig2_HuffmanTable> Table_B6;
   std::unique_ptr<CJBig2_HuffmanTable> Table_B7;
   std::unique_ptr<CJBig2_HuffmanTable> Table_B8;
   std::unique_ptr<CJBig2_HuffmanTable> Table_B9;
@@ skipping 227 matching lines @@
 
 int32_t CJBig2_Context::parseHalftoneRegion(CJBig2_Segment* pSegment,
                                             IFX_Pause* pPause) {
   uint8_t cFlags;
   JBig2RegionInfo ri;
   std::unique_ptr<CJBig2_HTRDProc> pHRD(new CJBig2_HTRDProc);
   if (parseRegionInfo(&ri) != JBIG2_SUCCESS ||
       m_pStream->read1Byte(&cFlags) != 0 ||
       m_pStream->readInteger(&pHRD->HGW) != 0 ||
       m_pStream->readInteger(&pHRD->HGH) != 0 ||
-      m_pStream->readInteger((FX_DWORD*)&pHRD->HGX) != 0 ||
-      m_pStream->readInteger((FX_DWORD*)&pHRD->HGY) != 0 ||
+      m_pStream->readInteger((uint32_t*)&pHRD->HGX) != 0 ||
+      m_pStream->readInteger((uint32_t*)&pHRD->HGY) != 0 ||
       m_pStream->readShortInteger(&pHRD->HRX) != 0 ||
       m_pStream->readShortInteger(&pHRD->HRY) != 0) {
     return JBIG2_ERROR_TOO_SHORT;
   }
 
   if (pHRD->HGW == 0 || pHRD->HGH == 0)
     return JBIG2_ERROR_FATAL;
 
   pHRD->HBW = ri.width;
   pHRD->HBH = ri.height;
@@ skipping 240 matching lines @@
       new CJBig2_HuffmanTable(m_pStream.get()));
   if (!pHuff->IsOK())
     return JBIG2_ERROR_FATAL;
 
   pSegment->m_Result.ht = pHuff.release();
   m_pStream->alignByte();
   return JBIG2_SUCCESS;
 }
 
 int32_t CJBig2_Context::parseRegionInfo(JBig2RegionInfo* pRI) {
-  if (m_pStream->readInteger((FX_DWORD*)&pRI->width) != 0 ||
-      m_pStream->readInteger((FX_DWORD*)&pRI->height) != 0 ||
-      m_pStream->readInteger((FX_DWORD*)&pRI->x) != 0 ||
-      m_pStream->readInteger((FX_DWORD*)&pRI->y) != 0 ||
+  if (m_pStream->readInteger((uint32_t*)&pRI->width) != 0 ||
+      m_pStream->readInteger((uint32_t*)&pRI->height) != 0 ||
+      m_pStream->readInteger((uint32_t*)&pRI->x) != 0 ||
+      m_pStream->readInteger((uint32_t*)&pRI->y) != 0 ||
       m_pStream->read1Byte(&pRI->flags) != 0) {
     return JBIG2_ERROR_TOO_SHORT;
   }
   return JBIG2_SUCCESS;
 }
 
 JBig2HuffmanCode* CJBig2_Context::decodeSymbolIDHuffmanTable(
     CJBig2_BitStream* pStream,
-    FX_DWORD SBNUMSYMS) {
+    uint32_t SBNUMSYMS) {
   const size_t kRunCodesSize = 35;
   int32_t runcodes[kRunCodesSize];
   int32_t runcodes_len[kRunCodesSize];
   for (int32_t i = 0; i < kRunCodesSize; ++i) {
     if (pStream->readNBits(4, &runcodes_len[i]) != 0)
       return nullptr;
   }
   huffman_assign_code(runcodes, runcodes_len, kRunCodesSize);
 
   std::unique_ptr<JBig2HuffmanCode, FxFreeDeleter> SBSYMCODES(
       FX_Alloc(JBig2HuffmanCode, SBNUMSYMS));
   int32_t run;
   int32_t i = 0;
   while (i < (int)SBNUMSYMS) {
     int32_t j;
     int32_t nVal = 0;
     int32_t nBits = 0;
-    FX_DWORD nTemp;
+    uint32_t nTemp;
     while (true) {
       if (pStream->read1Bit(&nTemp) != 0)
         return nullptr;
 
       nVal = (nVal << 1) | nTemp;
       ++nBits;
       for (j = 0; j < kRunCodesSize; ++j) {
         if (nBits == runcodes_len[j] && nVal == runcodes[j]) {
           break;
         }
@@ skipping 103 matching lines @@
         SBSYMCODES[CURTEMP].code = CURCODE;
         CURCODE = CURCODE + 1;
       }
       CURTEMP = CURTEMP + 1;
     }
     CURLEN = CURLEN + 1;
   }
   FX_Free(LENCOUNT);
   FX_Free(FIRSTCODE);
 }