Remove FX_DWORD from core/ and delete definition

core/fxge/ge/fx_ge_ps.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/include/fxge/fx_ge.h"
 
 #include "core/fxge/ge/fx_text_int.h"
 #include "core/include/fxcodec/fx_codec.h"
 
 struct PSGlyph {
   CFX_Font* m_pFont;
-  FX_DWORD m_GlyphIndex;
+  uint32_t m_GlyphIndex;
   FX_BOOL m_bGlyphAdjust;
   FX_FLOAT m_AdjustMatrix[4];
 };
 class CPSFont {
  public:
   PSGlyph m_Glyphs[256];
   int m_nGlyphs;
 };
 CFX_PSRenderer::CFX_PSRenderer() {
   m_pOutput = NULL;
@@ skipping 146 matching lines @@
   m_ClipBox.Intersect(rect.GetOutterRect());
   if (pObject2Device) {
     OUTPUT_PS("strokepath W n sm\n");
   } else {
     OUTPUT_PS("strokepath W n\n");
   }
 }
 FX_BOOL CFX_PSRenderer::DrawPath(const CFX_PathData* pPathData,
                                  const CFX_Matrix* pObject2Device,
                                  const CFX_GraphStateData* pGraphState,
-                                 FX_DWORD fill_color,
-                                 FX_DWORD stroke_color,
+                                 uint32_t fill_color,
+                                 uint32_t stroke_color,
                                  int fill_mode,
                                  int alpha_flag,
                                  void* pIccTransform) {
   StartRendering();
   int fill_alpha = FXGETFLAG_COLORTYPE(alpha_flag)
                        ? FXGETFLAG_ALPHA_FILL(alpha_flag)
                        : FXARGB_A(fill_color);
   int stroke_alpha = FXGETFLAG_COLORTYPE(alpha_flag)
                          ? FXGETFLAG_ALPHA_STROKE(alpha_flag)
                          : FXARGB_A(stroke_color);
@@ skipping 75 matching lines @@
   m_CurGraphState.Copy(*pGraphState);
   m_bGraphStateSet = TRUE;
   if (buf.GetSize()) {
     m_pOutput->OutputPS((const FX_CHAR*)buf.GetBuffer(), buf.GetSize());
   }
 }
 static void FaxCompressData(uint8_t* src_buf,
                             int width,
                             int height,
                             uint8_t*& dest_buf,
-                            FX_DWORD& dest_size) {
+                            uint32_t& dest_size) {
   CCodec_ModuleMgr* pEncoders = CFX_GEModule::Get()->GetCodecModule();
   if (width * height > 128 && pEncoders &&
       pEncoders->GetFaxModule()->Encode(src_buf, width, height, (width + 7) / 8,
                                         dest_buf, dest_size)) {
     FX_Free(src_buf);
   } else {
     dest_buf = src_buf;
     dest_size = (width + 7) / 8 * height;
   }
 }
 static void PSCompressData(int PSLevel,
                            uint8_t* src_buf,
-                           FX_DWORD src_size,
+                           uint32_t src_size,
                            uint8_t*& output_buf,
-                           FX_DWORD& output_size,
+                           uint32_t& output_size,
                            const FX_CHAR*& filter) {
   output_buf = src_buf;
   output_size = src_size;
   filter = "";
   if (src_size < 1024) {
     return;
   }
   CCodec_ModuleMgr* pEncoders = CFX_GEModule::Get()->GetCodecModule();
   uint8_t* dest_buf = NULL;
-  FX_DWORD dest_size = src_size;
+  uint32_t dest_size = src_size;
   if (PSLevel >= 3) {
     if (pEncoders &&
         pEncoders->GetFlateModule()->Encode(src_buf, src_size, dest_buf,
                                             dest_size)) {
       filter = "/FlateDecode filter ";
     }
   } else {
     if (pEncoders &&
         pEncoders->GetBasicModule()->RunLengthEncode(src_buf, src_size,
                                                      dest_buf, dest_size)) {
       filter = "/RunLengthDecode filter ";
     }
   }
   if (dest_size < src_size) {
     output_buf = dest_buf;
     output_size = dest_size;
   } else {
     filter = NULL;
     FX_Free(dest_buf);
   }
 }
 FX_BOOL CFX_PSRenderer::SetDIBits(const CFX_DIBSource* pSource,
-                                  FX_DWORD color,
+                                  uint32_t color,
                                   int left,
                                   int top,
                                   int alpha_flag,
                                   void* pIccTransform) {
   StartRendering();
   CFX_Matrix matrix((FX_FLOAT)(pSource->GetWidth()), 0.0f, 0.0f,
                     -(FX_FLOAT)(pSource->GetHeight()), (FX_FLOAT)(left),
                     (FX_FLOAT)(top + pSource->GetHeight()));
   return DrawDIBits(pSource, color, &matrix, 0, alpha_flag, pIccTransform);
 }
 FX_BOOL CFX_PSRenderer::StretchDIBits(const CFX_DIBSource* pSource,
-                                      FX_DWORD color,
+                                      uint32_t color,
                                       int dest_left,
                                       int dest_top,
                                       int dest_width,
                                       int dest_height,
-                                      FX_DWORD flags,
+                                      uint32_t flags,
                                       int alpha_flag,
                                       void* pIccTransform) {
   StartRendering();
   CFX_Matrix matrix((FX_FLOAT)(dest_width), 0.0f, 0.0f,
                     (FX_FLOAT)(-dest_height), (FX_FLOAT)(dest_left),
                     (FX_FLOAT)(dest_top + dest_height));
   return DrawDIBits(pSource, color, &matrix, flags, alpha_flag, pIccTransform);
 }
 FX_BOOL CFX_PSRenderer::DrawDIBits(const CFX_DIBSource* pSource,
-                                   FX_DWORD color,
+                                   uint32_t color,
                                    const CFX_Matrix* pMatrix,
-                                   FX_DWORD flags,
+                                   uint32_t flags,
                                    int alpha_flag,
                                    void* pIccTransform) {
   StartRendering();
   if ((pMatrix->a == 0 && pMatrix->b == 0) ||
       (pMatrix->c == 0 && pMatrix->d == 0)) {
     return TRUE;
   }
   if (pSource->HasAlpha()) {
     return FALSE;
   }
   int alpha = FXGETFLAG_COLORTYPE(alpha_flag) ? FXGETFLAG_ALPHA_FILL(color)
                                               : FXARGB_A(color);
   if (pSource->IsAlphaMask() && (alpha < 255 || pSource->GetBPP() != 1)) {
     return FALSE;
   }
   OUTPUT_PS("q\n");
   CFX_ByteTextBuf buf;
   buf << "[" << pMatrix->a << " " << pMatrix->b << " " << pMatrix->c << " "
       << pMatrix->d << " " << pMatrix->e << " " << pMatrix->f << "]cm ";
   int width = pSource->GetWidth();
   int height = pSource->GetHeight();
   buf << width << " " << height;
   if (pSource->GetBPP() == 1 && !pSource->GetPalette()) {
     int pitch = (width + 7) / 8;
-    FX_DWORD src_size = height * pitch;
+    uint32_t src_size = height * pitch;
     uint8_t* src_buf = FX_Alloc(uint8_t, src_size);
     for (int row = 0; row < height; row++) {
       const uint8_t* src_scan = pSource->GetScanline(row);
       FXSYS_memcpy(src_buf + row * pitch, src_scan, pitch);
     }
     uint8_t* output_buf;
-    FX_DWORD output_size;
+    uint32_t output_size;
     FaxCompressData(src_buf, width, height, output_buf, output_size);
     if (pSource->IsAlphaMask()) {
       SetColor(color, alpha_flag, pIccTransform);
       m_bColorSet = FALSE;
       buf << " true[";
     } else {
       buf << " 1[";
     }
     buf << width << " 0 0 -" << height << " 0 " << height
         << "]currentfile/ASCII85Decode filter ";
@@ skipping 64 matching lines @@
             *dest_scan++ = src_scan[2];
             *dest_scan++ = src_scan[1];
             *dest_scan++ = *src_scan;
             src_scan += 3;
           }
         } else {
           FXSYS_memcpy(dest_scan, src_scan, src_pitch);
         }
       }
       uint8_t* compressed_buf;
-      FX_DWORD compressed_size;
+      uint32_t compressed_size;
       PSCompressData(m_PSLevel, output_buf, output_size, compressed_buf,
                      compressed_size, filter);
       if (output_buf != compressed_buf) {
         FX_Free(output_buf);
       }
       output_buf = compressed_buf;
       output_size = compressed_size;
     }
     if (pConverted != pSource) {
       delete pConverted;
       pConverted = NULL;
     }
     buf << " 8[";
     buf << width << " 0 0 -" << height << " 0 " << height << "]";
     buf << "currentfile/ASCII85Decode filter ";
     if (filter) {
       buf << filter;
     }
     buf << "false " << Bpp;
     buf << " colorimage\n";
     m_pOutput->OutputPS((const FX_CHAR*)buf.GetBuffer(), buf.GetSize());
     WritePSBinary(output_buf, output_size);
     FX_Free(output_buf);
   }
   OUTPUT_PS("\nQ\n");
   return TRUE;
 }
-void CFX_PSRenderer::SetColor(FX_DWORD color,
+void CFX_PSRenderer::SetColor(uint32_t color,
                               int alpha_flag,
                               void* pIccTransform) {
   if (!CFX_GEModule::Get()->GetCodecModule() ||
       !CFX_GEModule::Get()->GetCodecModule()->GetIccModule()) {
     pIccTransform = NULL;
   }
   FX_BOOL bCMYK = FALSE;
   if (pIccTransform) {
     ICodec_IccModule* pIccModule =
         CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
@@ skipping 128 matching lines @@
   buf << "/X" << ps_fontnum << " Ff/Encoding get " << ps_glyphindex << "/"
       << ps_glyphindex << " put\n";
   m_pOutput->OutputPS((const FX_CHAR*)buf.GetBuffer(), buf.GetSize());
 }
 FX_BOOL CFX_PSRenderer::DrawText(int nChars,
                                  const FXTEXT_CHARPOS* pCharPos,
                                  CFX_Font* pFont,
                                  CFX_FontCache* pCache,
                                  const CFX_Matrix* pObject2Device,
                                  FX_FLOAT font_size,
-                                 FX_DWORD color,
+                                 uint32_t color,
                                  int alpha_flag,
                                  void* pIccTransform) {
   StartRendering();
   int alpha = FXGETFLAG_COLORTYPE(alpha_flag) ? FXGETFLAG_ALPHA_FILL(alpha_flag)
                                               : FXARGB_A(color);
   if (alpha < 255) {
     return FALSE;
   }
   if ((pObject2Device->a == 0 && pObject2Device->b == 0) ||
       (pObject2Device->c == 0 && pObject2Device->d == 0)) {
@@ skipping 21 matching lines @@
     CFX_ByteString hex;
     hex.Format("<%02X>", ps_glyphindex);
     buf << hex << "Tj\n";
   }
   buf << "Q\n";
   m_pOutput->OutputPS((const FX_CHAR*)buf.GetBuffer(), buf.GetSize());
   return TRUE;
 }
 void CFX_PSRenderer::WritePSBinary(const uint8_t* data, int len) {
   uint8_t* dest_buf;
-  FX_DWORD dest_size;
+  uint32_t dest_size;
   CCodec_ModuleMgr* pEncoders = CFX_GEModule::Get()->GetCodecModule();
   if (pEncoders &&
       pEncoders->GetBasicModule()->A85Encode(data, len, dest_buf, dest_size)) {
     m_pOutput->OutputPS((const FX_CHAR*)dest_buf, dest_size);
     FX_Free(dest_buf);
   } else {
     m_pOutput->OutputPS((const FX_CHAR*)data, len);
   }
 }