Remove FX_DWORD from core/ and delete definition

core/fpdfapi/fpdf_parser/fpdf_parser_decode.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/fpdfapi/fpdf_parser/include/fpdf_parser_decode.h"
 
 #include <limits.h>
 #include <vector>
@@ skipping 32 matching lines @@
     0x00b4, 0x00b5, 0x00b6, 0x00b7, 0x00b8, 0x00b9, 0x00ba, 0x00bb, 0x00bc,
     0x00bd, 0x00be, 0x00bf, 0x00c0, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5,
     0x00c6, 0x00c7, 0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce,
     0x00cf, 0x00d0, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x00d7,
     0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x00dd, 0x00de, 0x00df, 0x00e0,
     0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6, 0x00e7, 0x00e8, 0x00e9,
     0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef, 0x00f0, 0x00f1, 0x00f2,
     0x00f3, 0x00f4, 0x00f5, 0x00f6, 0x00f7, 0x00f8, 0x00f9, 0x00fa, 0x00fb,
     0x00fc, 0x00fd, 0x00fe, 0x00ff};
 
-FX_DWORD A85Decode(const uint8_t* src_buf,
-                   FX_DWORD src_size,
+uint32_t A85Decode(const uint8_t* src_buf,
+                   uint32_t src_size,
                    uint8_t*& dest_buf,
-                   FX_DWORD& dest_size) {
+                   uint32_t& dest_size) {
   dest_size = 0;
   dest_buf = nullptr;
   if (src_size == 0)
     return 0;
 
   // Count legal characters and zeros.
-  FX_DWORD zcount = 0;
-  FX_DWORD pos = 0;
+  uint32_t zcount = 0;
+  uint32_t pos = 0;
   while (pos < src_size) {
     uint8_t ch = src_buf[pos];
     if (ch == 'z') {
       zcount++;
     } else if ((ch < '!' || ch > 'u') && !PDFCharIsLineEnding(ch) &&
                ch != ' ' && ch != '\t') {
       break;
     }
     pos++;
   }
   // No content to decode.
   if (pos == 0)
     return 0;
 
   // Count the space needed to contain non-zero characters. The encoding ratio
   // of Ascii85 is 4:5.
-  FX_DWORD space_for_non_zeroes = (pos - zcount) / 5 * 4 + 4;
+  uint32_t space_for_non_zeroes = (pos - zcount) / 5 * 4 + 4;
   if (zcount > (UINT_MAX - space_for_non_zeroes) / 4) {
-    return (FX_DWORD)-1;
+    return (uint32_t)-1;
   }
   dest_buf = FX_Alloc(uint8_t, zcount * 4 + space_for_non_zeroes);
   size_t state = 0;
   uint32_t res = 0;
   pos = dest_size = 0;
   while (pos < src_size) {
     uint8_t ch = src_buf[pos++];
     if (PDFCharIsLineEnding(ch) || ch == ' ' || ch == '\t')
       continue;
 
@@ skipping 22 matching lines @@
     for (size_t i = state; i < 5; i++)
       res = res * 85 + 84;
     for (size_t i = 0; i < state - 1; i++)
       dest_buf[dest_size++] = (uint8_t)(res >> (3 - i) * 8);
   }
   if (pos < src_size && src_buf[pos] == '>')
     pos++;
   return pos;
 }
 
-FX_DWORD HexDecode(const uint8_t* src_buf,
-                   FX_DWORD src_size,
+uint32_t HexDecode(const uint8_t* src_buf,
+                   uint32_t src_size,
                    uint8_t*& dest_buf,
-                   FX_DWORD& dest_size) {
+                   uint32_t& dest_size) {
   dest_size = 0;
   if (src_size == 0) {
     dest_buf = nullptr;
     return 0;
   }
 
-  FX_DWORD i = 0;
+  uint32_t i = 0;
   // Find the end of data.
   while (i < src_size && src_buf[i] != '>')
     i++;
 
   dest_buf = FX_Alloc(uint8_t, i / 2 + 1);
   bool bFirst = true;
   for (i = 0; i < src_size; i++) {
     uint8_t ch = src_buf[i];
     if (PDFCharIsLineEnding(ch) || ch == ' ' || ch == '\t')
       continue;
@@ skipping 11 matching lines @@
     else
       dest_buf[dest_size++] += digit;
 
     bFirst = !bFirst;
   }
   if (!bFirst)
     dest_size++;
   return i;
 }
 
-FX_DWORD RunLengthDecode(const uint8_t* src_buf,
-                         FX_DWORD src_size,
+uint32_t RunLengthDecode(const uint8_t* src_buf,
+                         uint32_t src_size,
                          uint8_t*& dest_buf,
-                         FX_DWORD& dest_size) {
-  FX_DWORD i = 0;
-  FX_DWORD old;
+                         uint32_t& dest_size) {
+  uint32_t i = 0;
+  uint32_t old;
   dest_size = 0;
   while (i < src_size) {
     if (src_buf[i] < 128) {
       old = dest_size;
       dest_size += src_buf[i] + 1;
       if (dest_size < old) {
-        return static_cast<FX_DWORD>(-1);
+        return static_cast<uint32_t>(-1);
       }
       i += src_buf[i] + 2;
     } else if (src_buf[i] > 128) {
       old = dest_size;
       dest_size += 257 - src_buf[i];
       if (dest_size < old) {
-        return static_cast<FX_DWORD>(-1);
+        return static_cast<uint32_t>(-1);
       }
       i += 2;
     } else {
       break;
     }
   }
   if (dest_size >= _STREAM_MAX_SIZE_) {
-    return static_cast<FX_DWORD>(-1);
+    return static_cast<uint32_t>(-1);
   }
   dest_buf = FX_Alloc(uint8_t, dest_size);
   i = 0;
   int dest_count = 0;
   while (i < src_size) {
     if (src_buf[i] < 128) {
-      FX_DWORD copy_len = src_buf[i] + 1;
-      FX_DWORD buf_left = src_size - i - 1;
+      uint32_t copy_len = src_buf[i] + 1;
+      uint32_t buf_left = src_size - i - 1;
       if (buf_left < copy_len) {
-        FX_DWORD delta = copy_len - buf_left;
+        uint32_t delta = copy_len - buf_left;
         copy_len = buf_left;
         FXSYS_memset(dest_buf + dest_count + copy_len, '\0', delta);
       }
       FXSYS_memcpy(dest_buf + dest_count, src_buf + i + 1, copy_len);
       dest_count += src_buf[i] + 1;
       i += src_buf[i] + 2;
     } else if (src_buf[i] > 128) {
       int fill = 0;
       if (i < src_size - 1) {
         fill = src_buf[i + 1];
       }
       FXSYS_memset(dest_buf + dest_count, fill, 257 - src_buf[i]);
       dest_count += 257 - src_buf[i];
       i += 2;
     } else {
       break;
     }
   }
-  FX_DWORD ret = i + 1;
+  uint32_t ret = i + 1;
   if (ret > src_size) {
     ret = src_size;
   }
   return ret;
 }
 
 ICodec_ScanlineDecoder* FPDFAPI_CreateFaxDecoder(
     const uint8_t* src_buf,
-    FX_DWORD src_size,
+    uint32_t src_size,
     int width,
     int height,
     const CPDF_Dictionary* pParams) {
   int K = 0;
   FX_BOOL EndOfLine = FALSE;
   FX_BOOL ByteAlign = FALSE;
   FX_BOOL BlackIs1 = FALSE;
   int Columns = 1728;
   int Rows = 0;
   if (pParams) {
@@ skipping 32 matching lines @@
   }
   check *= BitsPerComponent;
   if (check > INT_MAX - 7) {
     return FALSE;
   }
   return TRUE;
 }
 
 ICodec_ScanlineDecoder* FPDFAPI_CreateFlateDecoder(
     const uint8_t* src_buf,
-    FX_DWORD src_size,
+    uint32_t src_size,
     int width,
     int height,
     int nComps,
     int bpc,
     const CPDF_Dictionary* pParams) {
   int predictor = 0;
   int Colors = 0, BitsPerComponent = 0, Columns = 0;
   if (pParams) {
     predictor = pParams->GetIntegerBy("Predictor");
     Colors = pParams->GetIntegerBy("Colors", 1);
     BitsPerComponent = pParams->GetIntegerBy("BitsPerComponent", 8);
     Columns = pParams->GetIntegerBy("Columns", 1);
     if (!CheckFlateDecodeParams(Colors, BitsPerComponent, Columns)) {
       return nullptr;
     }
   }
   return CPDF_ModuleMgr::Get()->GetFlateModule()->CreateDecoder(
       src_buf, src_size, width, height, nComps, bpc, predictor, Colors,
       BitsPerComponent, Columns);
 }
 
-FX_DWORD FPDFAPI_FlateOrLZWDecode(FX_BOOL bLZW,
+uint32_t FPDFAPI_FlateOrLZWDecode(FX_BOOL bLZW,
                                   const uint8_t* src_buf,
-                                  FX_DWORD src_size,
+                                  uint32_t src_size,
                                   CPDF_Dictionary* pParams,
-                                  FX_DWORD estimated_size,
+                                  uint32_t estimated_size,
                                   uint8_t*& dest_buf,
-                                  FX_DWORD& dest_size) {
+                                  uint32_t& dest_size) {
   int predictor = 0;
   FX_BOOL bEarlyChange = TRUE;
   int Colors = 0, BitsPerComponent = 0, Columns = 0;
   if (pParams) {
     predictor = pParams->GetIntegerBy("Predictor");
     bEarlyChange = pParams->GetIntegerBy("EarlyChange", 1);
     Colors = pParams->GetIntegerBy("Colors", 1);
     BitsPerComponent = pParams->GetIntegerBy("BitsPerComponent", 8);
     Columns = pParams->GetIntegerBy("Columns", 1);
     if (!CheckFlateDecodeParams(Colors, BitsPerComponent, Columns)) {
-      return (FX_DWORD)-1;
+      return (uint32_t)-1;
     }
   }
   return CPDF_ModuleMgr::Get()->GetFlateModule()->FlateOrLZWDecode(
       bLZW, src_buf, src_size, bEarlyChange, predictor, Colors,
       BitsPerComponent, Columns, estimated_size, dest_buf, dest_size);
 }
 
 FX_BOOL PDF_DataDecode(const uint8_t* src_buf,
-                       FX_DWORD src_size,
+                       uint32_t src_size,
                        const CPDF_Dictionary* pDict,
                        uint8_t*& dest_buf,
-                       FX_DWORD& dest_size,
+                       uint32_t& dest_size,
                        CFX_ByteString& ImageEncoding,
                        CPDF_Dictionary*& pImageParms,
-                       FX_DWORD last_estimated_size,
+                       uint32_t last_estimated_size,
                        FX_BOOL bImageAcc) {
   CPDF_Object* pDecoder = pDict ? pDict->GetElementValue("Filter") : nullptr;
   if (!pDecoder || (!pDecoder->IsArray() && !pDecoder->IsName()))
     return FALSE;
 
   CPDF_Object* pParams =
       pDict ? pDict->GetElementValue("DecodeParms") : nullptr;
   std::vector<CFX_ByteString> DecoderList;
   CFX_ArrayTemplate<CPDF_Object*> ParamList;
   if (CPDF_Array* pDecoders = pDecoder->AsArray()) {
     CPDF_Array* pParamsArray = ToArray(pParams);
     if (!pParamsArray)
       pParams = nullptr;
 
-    for (FX_DWORD i = 0; i < pDecoders->GetCount(); i++) {
+    for (uint32_t i = 0; i < pDecoders->GetCount(); i++) {
       DecoderList.push_back(pDecoders->GetConstStringAt(i));
       ParamList.Add(pParams ? pParamsArray->GetDictAt(i) : nullptr);
     }
   } else {
     DecoderList.push_back(pDecoder->GetConstString());
     ParamList.Add(pParams ? pParams->GetDict() : nullptr);
   }
   uint8_t* last_buf = (uint8_t*)src_buf;
-  FX_DWORD last_size = src_size;
+  uint32_t last_size = src_size;
   int nSize = pdfium::CollectionSize<int>(DecoderList);
   for (int i = 0; i < nSize; i++) {
     int estimated_size = i == nSize - 1 ? last_estimated_size : 0;
     CFX_ByteString decoder = DecoderList[i];
     // Use ToDictionary here because we can push nullptr into the ParamList.
     CPDF_Dictionary* pParam = ToDictionary(ParamList[i]);
     uint8_t* new_buf = nullptr;
-    FX_DWORD new_size = (FX_DWORD)-1;
+    uint32_t new_size = (uint32_t)-1;
     int offset = -1;
     if (decoder == "FlateDecode" || decoder == "Fl") {
       if (bImageAcc && i == nSize - 1) {
         ImageEncoding = "FlateDecode";
         dest_buf = (uint8_t*)last_buf;
         dest_size = last_size;
         pImageParms = pParam;
         return TRUE;
       }
       offset = FPDFAPI_FlateOrLZWDecode(FALSE, last_buf, last_size, pParam,
@@ skipping 41 matching lines @@
     last_buf = new_buf;
     last_size = new_size;
   }
   ImageEncoding = "";
   pImageParms = nullptr;
   dest_buf = last_buf;
   dest_size = last_size;
   return TRUE;
 }
 
-CFX_WideString PDF_DecodeText(const uint8_t* src_data, FX_DWORD src_len) {
+CFX_WideString PDF_DecodeText(const uint8_t* src_data, uint32_t src_len) {
   CFX_WideString result;
   if (src_len >= 2 && ((src_data[0] == 0xfe && src_data[1] == 0xff) ||
                        (src_data[0] == 0xff && src_data[1] == 0xfe))) {
     bool bBE = src_data[0] == 0xfe;
-    FX_DWORD max_chars = (src_len - 2) / 2;
+    uint32_t max_chars = (src_len - 2) / 2;
     if (!max_chars) {
       return result;
     }
     if (src_data[0] == 0xff) {
       bBE = !src_data[2];
     }
     FX_WCHAR* dest_buf = result.GetBuffer(max_chars);
     const uint8_t* uni_str = src_data + 2;
     int dest_pos = 0;
-    for (FX_DWORD i = 0; i < max_chars * 2; i += 2) {
+    for (uint32_t i = 0; i < max_chars * 2; i += 2) {
       uint16_t unicode = bBE ? (uni_str[i] << 8 | uni_str[i + 1])
                              : (uni_str[i + 1] << 8 | uni_str[i]);
       if (unicode == 0x1b) {
         i += 2;
         while (i < max_chars * 2) {
           uint16_t unicode = bBE ? (uni_str[i] << 8 | uni_str[i + 1])
                                  : (uni_str[i + 1] << 8 | uni_str[i]);
           i += 2;
           if (unicode == 0x1b) {
             break;
           }
         }
       } else {
         dest_buf[dest_pos++] = unicode;
       }
     }
     result.ReleaseBuffer(dest_pos);
   } else {
     FX_WCHAR* dest_buf = result.GetBuffer(src_len);
-    for (FX_DWORD i = 0; i < src_len; i++)
+    for (uint32_t i = 0; i < src_len; i++)
       dest_buf[i] = PDFDocEncoding[src_data[i]];
     result.ReleaseBuffer(src_len);
   }
   return result;
 }
 
 CFX_WideString PDF_DecodeText(const CFX_ByteString& bstr) {
   return PDF_DecodeText((const uint8_t*)bstr.c_str(), bstr.GetLength());
 }
 
@@ skipping 67 matching lines @@
       result << "\\r";
       continue;
     }
     result.AppendChar(ch);
   }
   result.AppendChar(')');
   return result.GetByteString();
 }
 
 void FlateEncode(const uint8_t* src_buf,
-                 FX_DWORD src_size,
+                 uint32_t src_size,
                  uint8_t*& dest_buf,
-                 FX_DWORD& dest_size) {
+                 uint32_t& dest_size) {
   CCodec_ModuleMgr* pEncoders = CPDF_ModuleMgr::Get()->GetCodecModule();
   if (pEncoders) {
     pEncoders->GetFlateModule()->Encode(src_buf, src_size, dest_buf, dest_size);
   }
 }
 
 void FlateEncode(const uint8_t* src_buf,
-                 FX_DWORD src_size,
+                 uint32_t src_size,
                  int predictor,
                  int Colors,
                  int BitsPerComponent,
                  int Columns,
                  uint8_t*& dest_buf,
-                 FX_DWORD& dest_size) {
+                 uint32_t& dest_size) {
   CCodec_ModuleMgr* pEncoders = CPDF_ModuleMgr::Get()->GetCodecModule();
   if (pEncoders) {
     pEncoders->GetFlateModule()->Encode(src_buf, src_size, predictor, Colors,
                                         BitsPerComponent, Columns, dest_buf,
                                         dest_size);
   }
 }
 
-FX_DWORD FlateDecode(const uint8_t* src_buf,
-                     FX_DWORD src_size,
+uint32_t FlateDecode(const uint8_t* src_buf,
+                     uint32_t src_size,
                      uint8_t*& dest_buf,
-                     FX_DWORD& dest_size) {
+                     uint32_t& dest_size) {
   CCodec_ModuleMgr* pEncoders = CPDF_ModuleMgr::Get()->GetCodecModule();
   if (pEncoders) {
     return pEncoders->GetFlateModule()->FlateOrLZWDecode(
         FALSE, src_buf, src_size, FALSE, 0, 0, 0, 0, 0, dest_buf, dest_size);
   }
   return 0;
 }