Remove default arguments in CFX_RenderDevice.

core/fxge/ge/fx_ge_text.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 <limits>
 #include <vector>
 
 #include "core/fxcodec/include/fx_codec.h"
@@ skipping 409 matching lines @@
   return rect;
 }
 
 FX_BOOL CFX_RenderDevice::DrawNormalText(int nChars,
                                          const FXTEXT_CHARPOS* pCharPos,
                                          CFX_Font* pFont,
                                          CFX_FontCache* pCache,
                                          FX_FLOAT font_size,
                                          const CFX_Matrix* pText2Device,
                                          uint32_t fill_color,
-                                         uint32_t text_flags,
-                                         int alpha_flag,
-                                         void* pIccTransform) {
+                                         uint32_t text_flags) {
   int nativetext_flags = text_flags;
   if (m_DeviceClass != FXDC_DISPLAY) {
     if (!(text_flags & FXTEXT_PRINTGRAPHICTEXT)) {
       bool should_call_draw_device_text = true;
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
       if ((text_flags & FXFONT_CIDFONT) ||
           (pFont->GetPsName().Find(
                CFX_WideString::FromLocal("+ZJHL").AsStringC()) != -1) ||
           (pFont->GetPsName() == CFX_WideString::FromLocal("CNAAJI+cmex10"))) {
         should_call_draw_device_text = false;
       }
 #endif
       if (should_call_draw_device_text &&
           m_pDeviceDriver->DrawDeviceText(nChars, pCharPos, pFont, pCache,
                                           pText2Device, font_size, fill_color,
-                                          alpha_flag, pIccTransform)) {
+                                          0, nullptr)) {
         return TRUE;
       }
     }
-    int alpha = FXGETFLAG_COLORTYPE(alpha_flag)
-                    ? FXGETFLAG_ALPHA_FILL(alpha_flag)
-                    : FXARGB_A(fill_color);
-    if (alpha < 255) {
+    if (FXARGB_A(fill_color) < 255)
       return FALSE;
-    }
   } else if (!(text_flags & FXTEXT_NO_NATIVETEXT)) {
     bool should_call_draw_device_text = true;
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
     if ((text_flags & FXFONT_CIDFONT) ||
         (pFont->GetPsName() == CFX_WideString::FromLocal("CNAAJI+cmex10"))) {
       should_call_draw_device_text = false;
     }
 #endif
     if (should_call_draw_device_text &&
         m_pDeviceDriver->DrawDeviceText(nChars, pCharPos, pFont, pCache,
-                                        pText2Device, font_size, fill_color,
-                                        alpha_flag, pIccTransform)) {
+                                        pText2Device, font_size, fill_color, 0,
+                                        nullptr)) {
       return TRUE;
     }
   }
   CFX_Matrix char2device;
   CFX_Matrix text2Device;
   if (pText2Device) {
     char2device = *pText2Device;
     text2Device = *pText2Device;
   }
   char2device.Scale(font_size, -font_size);
   if (FXSYS_fabs(char2device.a) + FXSYS_fabs(char2device.b) > 50 * 1.0f ||
       ((m_DeviceClass == FXDC_PRINTER && !m_pDeviceDriver->IsPSPrintDriver()) &&
        !(text_flags & FXTEXT_PRINTIMAGETEXT))) {
     if (pFont->GetFace() ||
         (pFont->GetSubstFont()->m_SubstFlags & FXFONT_SUBST_GLYPHPATH)) {
       int nPathFlags =
           (text_flags & FXTEXT_NOSMOOTH) == 0 ? 0 : FXFILL_NOPATHSMOOTH;
-      return DrawTextPath(nChars, pCharPos, pFont, pCache, font_size,
-                          pText2Device, NULL, NULL, fill_color, 0, NULL,
-                          nPathFlags, alpha_flag, pIccTransform);
+      return DrawTextPathWithFlags(nChars, pCharPos, pFont, pCache, font_size,
+                                   pText2Device, nullptr, nullptr, fill_color,
+                                   0, nullptr, nPathFlags);
     }
   }
   int anti_alias = FXFT_RENDER_MODE_MONO;
   bool bNormal = false;
   if ((text_flags & FXTEXT_NOSMOOTH) == 0) {
     if (m_DeviceClass == FXDC_DISPLAY && m_bpp > 1) {
       if (!CFX_GEModule::Get()->GetFontMgr()->FTLibrarySupportsHinting()) {
         // Some Freetype implementations (like the one packaged with Fedora) do
         // not support hinting due to patents 6219025, 6239783, 6307566,
         // 6225973, 6243070, 6393145, 6421054, 6282327, and 6624828; the latest
@@ skipping 114 matching lines @@
       bitmap.m_pAlphaMask->Clear(0);
     }
   }
 
   int dest_width = pixel_width;
   int a = 0;
   int r = 0;
   int g = 0;
   int b = 0;
   if (anti_alias == FXFT_RENDER_MODE_LCD) {
-    Color2Argb(fill_color, fill_color, alpha_flag | (1 << 24), pIccTransform);
+    Color2Argb(fill_color, fill_color, (1 << 24), nullptr);
     ArgbDecode(fill_color, a, r, g, b);
   }
   for (const FXTEXT_GLYPHPOS& glyph : glyphs) {
     if (!glyph.m_pGlyph)
       continue;
 
     const CFX_DIBitmap* pGlyph = &glyph.m_pGlyph->m_Bitmap;
     int left = glyph.m_OriginX + glyph.m_pGlyph->m_Left - pixel_left;
     int top = glyph.m_OriginY - glyph.m_pGlyph->m_Top - pixel_top;
     int ncols = pGlyph->GetWidth();
     int nrows = pGlyph->GetHeight();
     if (anti_alias == FXFT_RENDER_MODE_NORMAL) {
       if (!bitmap.CompositeMask(left, top, ncols, nrows, pGlyph, fill_color, 0,
-                                0, FXDIB_BLEND_NORMAL, nullptr, FALSE,
-                                alpha_flag, pIccTransform)) {
+                                0, FXDIB_BLEND_NORMAL, nullptr, FALSE, 0,
+                                nullptr)) {
         return FALSE;
       }
       continue;
     }
 
     bool bBGRStripe = !!(text_flags & FXTEXT_BGR_STRIPE);
     ncols /= 3;
     int x_subpixel = (int)(glyph.m_fOriginX * 3) % 3;
     int start_col = std::max(left, 0);
     int end_col = std::min(left + ncols, dest_width);
     if (start_col >= end_col)
       continue;
 
     DrawNormalTextHelper(&bitmap, pGlyph, nrows, left, top, start_col, end_col,
                          bNormal, bBGRStripe, x_subpixel, a, r, g, b);
   }
-  if (bitmap.IsAlphaMask()) {
-    SetBitMask(&bitmap, bmp_rect.left, bmp_rect.top, fill_color, alpha_flag,
-               pIccTransform);
-  } else {
+  if (bitmap.IsAlphaMask())
+    SetBitMask(&bitmap, bmp_rect.left, bmp_rect.top, fill_color);
+  else
     SetDIBits(&bitmap, bmp_rect.left, bmp_rect.top);
-  }
-
   return TRUE;
 }
 
-FX_BOOL CFX_RenderDevice::DrawTextPath(int nChars,
-                                       const FXTEXT_CHARPOS* pCharPos,
-                                       CFX_Font* pFont,
-                                       CFX_FontCache* pCache,
-                                       FX_FLOAT font_size,
-                                       const CFX_Matrix* pText2User,
-                                       const CFX_Matrix* pUser2Device,
-                                       const CFX_GraphStateData* pGraphState,
-                                       uint32_t fill_color,
-                                       FX_ARGB stroke_color,
-                                       CFX_PathData* pClippingPath,
-                                       int nFlag,
-                                       int alpha_flag,
-                                       void* pIccTransform,
-                                       int blend_type) {
-  if (!pCache) {
+FX_BOOL CFX_RenderDevice::DrawTextPathWithFlags(
+    int nChars,
+    const FXTEXT_CHARPOS* pCharPos,
+    CFX_Font* pFont,
+    CFX_FontCache* pCache,
+    FX_FLOAT font_size,
+    const CFX_Matrix* pText2User,
+    const CFX_Matrix* pUser2Device,
+    const CFX_GraphStateData* pGraphState,
+    uint32_t fill_color,
+    FX_ARGB stroke_color,
+    CFX_PathData* pClippingPath,
+    int nFlag) {
+  if (!pCache)
     pCache = CFX_GEModule::Get()->GetFontCache();
-  }
+
   CFX_FaceCache* pFaceCache = pCache->GetCachedFace(pFont);
   FX_FONTCACHE_DEFINE(pCache, pFont);
   for (int iChar = 0; iChar < nChars; iChar++) {
     const FXTEXT_CHARPOS& charpos = pCharPos[iChar];
     CFX_Matrix matrix;
     if (charpos.m_bGlyphAdjust)
       matrix.Set(charpos.m_AdjustMatrix[0], charpos.m_AdjustMatrix[1],
                  charpos.m_AdjustMatrix[2], charpos.m_AdjustMatrix[3], 0, 0);
     matrix.Concat(font_size, 0, 0, font_size, charpos.m_OriginX,
                   charpos.m_OriginY);
     const CFX_PathData* pPath = pFaceCache->LoadGlyphPath(
         pFont, charpos.m_GlyphIndex, charpos.m_FontCharWidth);
-    if (!pPath) {
+    if (!pPath)
       continue;
-    }
+
     matrix.Concat(*pText2User);
     CFX_PathData TransformedPath(*pPath);
     TransformedPath.Transform(&matrix);
-    FX_BOOL bHasAlpha = FXGETFLAG_COLORTYPE(alpha_flag)
-                            ? (FXGETFLAG_ALPHA_FILL(alpha_flag) ||
-                               FXGETFLAG_ALPHA_STROKE(alpha_flag))
-                            : (fill_color || stroke_color);
-    if (bHasAlpha) {
+    if (fill_color || stroke_color) {
       int fill_mode = nFlag;
-      if (FXGETFLAG_COLORTYPE(alpha_flag)) {
-        if (FXGETFLAG_ALPHA_FILL(alpha_flag)) {
-          fill_mode |= FXFILL_WINDING;
-        }
-      } else {
-        if (fill_color) {
-          fill_mode |= FXFILL_WINDING;
-        }
-      }
+      if (fill_color)
+        fill_mode |= FXFILL_WINDING;
       fill_mode |= FX_FILL_TEXT_MODE;
-      if (!DrawPath(&TransformedPath, pUser2Device, pGraphState, fill_color,
-                    stroke_color, fill_mode, alpha_flag, pIccTransform,
-                    blend_type)) {
+      if (!DrawPathWithBlend(&TransformedPath, pUser2Device, pGraphState,
+                             fill_color, stroke_color, fill_mode,
+                             FXDIB_BLEND_NORMAL)) {
         return FALSE;
       }
     }
-    if (pClippingPath) {
+    if (pClippingPath)
       pClippingPath->Append(&TransformedPath, pUser2Device);
-    }
   }
   return TRUE;
 }
 
 CFX_FontCache::CFX_FontCache() {}
 
 CFX_FontCache::~CFX_FontCache() {
   FreeCache(TRUE);
 }
 
@@ skipping 719 matching lines @@
 void _CFX_UniqueKeyGen::Generate(int count, ...) {
   va_list argList;
   va_start(argList, count);
   for (int i = 0; i < count; i++) {
     int p = va_arg(argList, int);
     ((uint32_t*)m_Key)[i] = p;
   }
   va_end(argList);
   m_KeyLen = count * sizeof(uint32_t);
 }