Remove FX_DWORD from core/ and delete definition

core/fxcodec/jbig2/JBig2_TrdProc.cpp

 // Copyright 2015 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_TrdProc.h"
 
 #include <memory>
 
 #include "core/fxcodec/jbig2/JBig2_ArithDecoder.h"
 #include "core/fxcodec/jbig2/JBig2_ArithIntDecoder.h"
 #include "core/fxcodec/jbig2/JBig2_GrrdProc.h"
 #include "core/fxcodec/jbig2/JBig2_HuffmanDecoder.h"
 
 CJBig2_Image* CJBig2_TRDProc::decode_Huffman(CJBig2_BitStream* pStream,
                                              JBig2ArithCtx* grContext) {
   std::unique_ptr<CJBig2_HuffmanDecoder> pHuffmanDecoder(
       new CJBig2_HuffmanDecoder(pStream));
   std::unique_ptr<CJBig2_Image> SBREG(new CJBig2_Image(SBW, SBH));
   SBREG->fill(SBDEFPIXEL);
   int32_t STRIPT;
   if (pHuffmanDecoder->decodeAValue(SBHUFFDT, &STRIPT) != 0)
     return nullptr;
 
   STRIPT *= SBSTRIPS;
   STRIPT = -STRIPT;
-  FX_DWORD NINSTANCES = 0;
+  uint32_t NINSTANCES = 0;
   while (NINSTANCES < SBNUMINSTANCES) {
     int32_t DT;
     if (pHuffmanDecoder->decodeAValue(SBHUFFDT, &DT) != 0)
       return nullptr;
 
     DT *= SBSTRIPS;
     STRIPT = STRIPT + DT;
     bool bFirst = true;
     int32_t FIRSTS = 0;
     int32_t CURS = 0;
@@ skipping 12 matching lines @@
         if (nVal == JBIG2_OOB) {
           break;
         } else if (nVal != 0) {
           return nullptr;
         } else {
           CURS = CURS + IDS + SBDSOFFSET;
         }
       }
       uint8_t CURT = 0;
       if (SBSTRIPS != 1) {
-        FX_DWORD nTmp = 1;
-        while ((FX_DWORD)(1 << nTmp) < SBSTRIPS) {
+        uint32_t nTmp = 1;
+        while ((uint32_t)(1 << nTmp) < SBSTRIPS) {
           nTmp++;
         }
         int32_t nVal;
         if (pStream->readNBits(nTmp, &nVal) != 0)
           return nullptr;
 
         CURT = nVal;
       }
       int32_t TI = STRIPT + CURT;
       int32_t nVal = 0;
       int32_t nBits = 0;
-      FX_DWORD IDI;
+      uint32_t IDI;
       for (;;) {
-        FX_DWORD nTmp;
+        uint32_t nTmp;
         if (pStream->read1Bit(&nTmp) != 0)
           return nullptr;
 
         nVal = (nVal << 1) | nTmp;
         nBits++;
         for (IDI = 0; IDI < SBNUMSYMS; IDI++) {
           if ((nBits == SBSYMCODES[IDI].codelen) &&
               (nVal == SBSYMCODES[IDI].code)) {
             break;
           }
@@ skipping 15 matching lines @@
         int32_t RDXI;
         int32_t RDYI;
         if ((pHuffmanDecoder->decodeAValue(SBHUFFRDW, &RDWI) != 0) ||
             (pHuffmanDecoder->decodeAValue(SBHUFFRDH, &RDHI) != 0) ||
             (pHuffmanDecoder->decodeAValue(SBHUFFRDX, &RDXI) != 0) ||
             (pHuffmanDecoder->decodeAValue(SBHUFFRDY, &RDYI) != 0) ||
             (pHuffmanDecoder->decodeAValue(SBHUFFRSIZE, &nVal) != 0)) {
           return nullptr;
         }
         pStream->alignByte();
-        FX_DWORD nTmp = pStream->getOffset();
+        uint32_t nTmp = pStream->getOffset();
         CJBig2_Image* IBOI = SBSYMS[IDI];
         if (!IBOI)
           return nullptr;
 
-        FX_DWORD WOI = IBOI->m_nWidth;
-        FX_DWORD HOI = IBOI->m_nHeight;
+        uint32_t WOI = IBOI->m_nWidth;
+        uint32_t HOI = IBOI->m_nHeight;
         if ((int)(WOI + RDWI) < 0 || (int)(HOI + RDHI) < 0)
           return nullptr;
 
         std::unique_ptr<CJBig2_GRRDProc> pGRRD(new CJBig2_GRRDProc());
         pGRRD->GRW = WOI + RDWI;
         pGRRD->GRH = HOI + RDHI;
         pGRRD->GRTEMPLATE = SBRTEMPLATE;
         pGRRD->GRREFERENCE = IBOI;
         pGRRD->GRREFERENCEDX = (RDWI >> 2) + RDXI;
         pGRRD->GRREFERENCEDY = (RDHI >> 2) + RDYI;
         pGRRD->TPGRON = 0;
         pGRRD->GRAT[0] = SBRAT[0];
         pGRRD->GRAT[1] = SBRAT[1];
         pGRRD->GRAT[2] = SBRAT[2];
         pGRRD->GRAT[3] = SBRAT[3];
 
         {
           std::unique_ptr<CJBig2_ArithDecoder> pArithDecoder(
               new CJBig2_ArithDecoder(pStream));
           IBI = pGRRD->decode(pArithDecoder.get(), grContext);
           if (!IBI)
             return nullptr;
         }
 
         pStream->alignByte();
         pStream->offset(2);
-        if ((FX_DWORD)nVal != (pStream->getOffset() - nTmp)) {
+        if ((uint32_t)nVal != (pStream->getOffset() - nTmp)) {
           delete IBI;
           return nullptr;
         }
       }
       if (!IBI) {
         continue;
       }
-      FX_DWORD WI = IBI->m_nWidth;
-      FX_DWORD HI = IBI->m_nHeight;
+      uint32_t WI = IBI->m_nWidth;
+      uint32_t HI = IBI->m_nHeight;
       if (TRANSPOSED == 0 && ((REFCORNER == JBIG2_CORNER_TOPRIGHT) ||
                               (REFCORNER == JBIG2_CORNER_BOTTOMRIGHT))) {
         CURS = CURS + WI - 1;
       } else if (TRANSPOSED == 1 && ((REFCORNER == JBIG2_CORNER_BOTTOMLEFT) ||
                                      (REFCORNER == JBIG2_CORNER_BOTTOMRIGHT))) {
         CURS = CURS + HI - 1;
       }
       int32_t SI = CURS;
       if (TRANSPOSED == 0) {
         switch (REFCORNER) {
@@ skipping 98 matching lines @@
     pIARDY = IARDY.get();
     pIAID = IAID.get();
   }
   std::unique_ptr<CJBig2_Image> SBREG(new CJBig2_Image(SBW, SBH));
   SBREG->fill(SBDEFPIXEL);
   int32_t STRIPT;
   pIADT->decode(pArithDecoder, &STRIPT);
   STRIPT *= SBSTRIPS;
   STRIPT = -STRIPT;
   int32_t FIRSTS = 0;
-  FX_DWORD NINSTANCES = 0;
+  uint32_t NINSTANCES = 0;
   while (NINSTANCES < SBNUMINSTANCES) {
     int32_t CURS = 0;
     int32_t DT;
     pIADT->decode(pArithDecoder, &DT);
     DT *= SBSTRIPS;
     STRIPT += DT;
     bool bFirst = true;
     for (;;) {
       if (bFirst) {
         int32_t DFS;
         pIAFS->decode(pArithDecoder, &DFS);
         FIRSTS += DFS;
         CURS = FIRSTS;
         bFirst = false;
       } else {
         int32_t IDS;
         if (!pIADS->decode(pArithDecoder, &IDS))
           break;
         CURS += IDS + SBDSOFFSET;
       }
       if (NINSTANCES >= SBNUMINSTANCES) {
         break;
       }
       int CURT = 0;
       if (SBSTRIPS != 1)
         pIAIT->decode(pArithDecoder, &CURT);
 
       int32_t TI = STRIPT + CURT;
-      FX_DWORD IDI;
+      uint32_t IDI;
       pIAID->decode(pArithDecoder, &IDI);
       if (IDI >= SBNUMSYMS)
         return nullptr;
 
       int RI;
       if (SBREFINE == 0)
         RI = 0;
       else
         pIARI->decode(pArithDecoder, &RI);
 
       std::unique_ptr<CJBig2_Image> IBI;
       CJBig2_Image* pIBI;
       if (RI == 0) {
         pIBI = SBSYMS[IDI];
       } else {
         int32_t RDWI;
         int32_t RDHI;
         int32_t RDXI;
         int32_t RDYI;
         pIARDW->decode(pArithDecoder, &RDWI);
         pIARDH->decode(pArithDecoder, &RDHI);
         pIARDX->decode(pArithDecoder, &RDXI);
         pIARDY->decode(pArithDecoder, &RDYI);
         CJBig2_Image* IBOI = SBSYMS[IDI];
-        FX_DWORD WOI = IBOI->m_nWidth;
-        FX_DWORD HOI = IBOI->m_nHeight;
+        uint32_t WOI = IBOI->m_nWidth;
+        uint32_t HOI = IBOI->m_nHeight;
         if ((int)(WOI + RDWI) < 0 || (int)(HOI + RDHI) < 0) {
           return nullptr;
         }
         std::unique_ptr<CJBig2_GRRDProc> pGRRD(new CJBig2_GRRDProc());
         pGRRD->GRW = WOI + RDWI;
         pGRRD->GRH = HOI + RDHI;
         pGRRD->GRTEMPLATE = SBRTEMPLATE;
         pGRRD->GRREFERENCE = IBOI;
         pGRRD->GRREFERENCEDX = (RDWI >> 1) + RDXI;
         pGRRD->GRREFERENCEDY = (RDHI >> 1) + RDYI;
         pGRRD->TPGRON = 0;
         pGRRD->GRAT[0] = SBRAT[0];
         pGRRD->GRAT[1] = SBRAT[1];
         pGRRD->GRAT[2] = SBRAT[2];
         pGRRD->GRAT[3] = SBRAT[3];
         IBI.reset(pGRRD->decode(pArithDecoder, grContext));
         pIBI = IBI.get();
       }
       if (!pIBI)
         return nullptr;
 
-      FX_DWORD WI = pIBI->m_nWidth;
-      FX_DWORD HI = pIBI->m_nHeight;
+      uint32_t WI = pIBI->m_nWidth;
+      uint32_t HI = pIBI->m_nHeight;
       if (TRANSPOSED == 0 && ((REFCORNER == JBIG2_CORNER_TOPRIGHT) ||
                               (REFCORNER == JBIG2_CORNER_BOTTOMRIGHT))) {
         CURS += WI - 1;
       } else if (TRANSPOSED == 1 && ((REFCORNER == JBIG2_CORNER_BOTTOMLEFT) ||
                                      (REFCORNER == JBIG2_CORNER_BOTTOMRIGHT))) {
         CURS += HI - 1;
       }
       int32_t SI = CURS;
       if (TRANSPOSED == 0) {
         switch (REFCORNER) {
@@ skipping 31 matching lines @@
         CURS += WI - 1;
       } else if (TRANSPOSED == 1 && ((REFCORNER == JBIG2_CORNER_TOPLEFT) ||
                                      (REFCORNER == JBIG2_CORNER_TOPRIGHT))) {
         CURS += HI - 1;
       }
       ++NINSTANCES;
     }
   }
   return SBREG.release();
 }