Remove default arguments from IFX_RenderDeviceDriver.

core/fxge/win32/fx_win32_device.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/fxge/include/fx_ge.h"
 
 #include <algorithm>
 #include <memory>
@@ skipping 735 matching lines @@
     m_Width = ::GetDeviceCaps(m_hDC, HORZRES);
     m_Height = ::GetDeviceCaps(m_hDC, VERTRES);
   }
   if (m_DeviceClass != FXDC_DISPLAY) {
     m_RenderCaps = FXRC_BIT_MASK;
   } else {
     m_RenderCaps = FXRC_GET_BITS | FXRC_BIT_MASK;
   }
 }
 
+CGdiDeviceDriver::~CGdiDeviceDriver() {}
+
 int CGdiDeviceDriver::GetDeviceCaps(int caps_id) {
   switch (caps_id) {
     case FXDC_DEVICE_CLASS:
       return m_DeviceClass;
     case FXDC_PIXEL_WIDTH:
       return m_Width;
     case FXDC_PIXEL_HEIGHT:
       return m_Height;
     case FXDC_BITS_PIXEL:
       return m_nBitsPerPixel;
@@ skipping 225 matching lines @@
   MoveToEx(m_hDC, FXSYS_round(x1), FXSYS_round(y1), nullptr);
   LineTo(m_hDC, FXSYS_round(x2), FXSYS_round(y2));
 }
 
 FX_BOOL CGdiDeviceDriver::DrawPath(const CFX_PathData* pPathData,
                                    const CFX_Matrix* pMatrix,
                                    const CFX_GraphStateData* pGraphState,
                                    uint32_t fill_color,
                                    uint32_t stroke_color,
                                    int fill_mode,
-                                   int alpha_flag,
-                                   void* pIccTransform,
                                    int blend_type) {
-  if (blend_type != FXDIB_BLEND_NORMAL) {
+  if (blend_type != FXDIB_BLEND_NORMAL)
     return FALSE;
-  }
-  Color2Argb(fill_color, fill_color, alpha_flag | (1 << 24), pIccTransform);
-  Color2Argb(stroke_color, stroke_color, alpha_flag, pIccTransform);
+
+  Color2Argb(fill_color, fill_color, 1 << 24, nullptr);
+  Color2Argb(stroke_color, stroke_color, 0, nullptr);
   CWin32Platform* pPlatform =
       (CWin32Platform*)CFX_GEModule::Get()->GetPlatformData();
   if (!(pGraphState || stroke_color == 0) &&
       !pPlatform->m_GdiplusExt.IsAvailable()) {
     CFX_FloatRect bbox_f = pPathData->GetBoundingBox();
     if (pMatrix) {
       bbox_f.Transform(pMatrix);
     }
     FX_RECT bbox = bbox_f.GetInnerRect();
     if (bbox.Width() <= 0) {
-      return DrawCosmeticLine((FX_FLOAT)(bbox.left), (FX_FLOAT)(bbox.top),
-                              (FX_FLOAT)(bbox.left),
-                              (FX_FLOAT)(bbox.bottom + 1), fill_color,
-                              alpha_flag, pIccTransform, FXDIB_BLEND_NORMAL);
-    } else if (bbox.Height() <= 0) {
+      return DrawCosmeticLine(
+          (FX_FLOAT)(bbox.left), (FX_FLOAT)(bbox.top), (FX_FLOAT)(bbox.left),
+          (FX_FLOAT)(bbox.bottom + 1), fill_color, FXDIB_BLEND_NORMAL);
+    }
+    if (bbox.Height() <= 0) {
       return DrawCosmeticLine((FX_FLOAT)(bbox.left), (FX_FLOAT)(bbox.top),
                               (FX_FLOAT)(bbox.right + 1), (FX_FLOAT)(bbox.top),
-                              fill_color, alpha_flag, pIccTransform,
-                              FXDIB_BLEND_NORMAL);
+                              fill_color, FXDIB_BLEND_NORMAL);
     }
   }
   int fill_alpha = FXARGB_A(fill_color);
   int stroke_alpha = FXARGB_A(stroke_color);
   FX_BOOL bDrawAlpha = (fill_alpha > 0 && fill_alpha < 255) ||
                        (stroke_alpha > 0 && stroke_alpha < 255 && pGraphState);
-  if (!pPlatform->m_GdiplusExt.IsAvailable() && bDrawAlpha) {
+  if (!pPlatform->m_GdiplusExt.IsAvailable() && bDrawAlpha)
     return FALSE;
-  }
+
   if (pPlatform->m_GdiplusExt.IsAvailable()) {
     if (bDrawAlpha ||
         ((m_DeviceClass != FXDC_PRINTER && !(fill_mode & FXFILL_FULLCOVER)) ||
          (pGraphState && pGraphState->m_DashCount))) {
       if (!((!pMatrix || MatrixNoScaled(pMatrix)) && pGraphState &&
             pGraphState->m_LineWidth == 1.f &&
             (pPathData->GetPointCount() == 5 ||
              pPathData->GetPointCount() == 4) &&
             pPathData->IsRect())) {
         if (pPlatform->m_GdiplusExt.DrawPath(m_hDC, pPathData, pMatrix,
@@ skipping 13 matching lines @@
     hPen = CreatePen(pGraphState, pMatrix, stroke_color);
     hPen = (HPEN)SelectObject(m_hDC, hPen);
   }
   if (fill_mode && fill_alpha) {
     SetPolyFillMode(m_hDC, fill_mode);
     hBrush = CreateBrush(fill_color);
     hBrush = (HBRUSH)SelectObject(m_hDC, hBrush);
   }
   if (pPathData->GetPointCount() == 2 && pGraphState &&
       pGraphState->m_DashCount) {
-    FX_FLOAT x1 = pPathData->GetPointX(0), y1 = pPathData->GetPointY(0);
+    FX_FLOAT x1 = pPathData->GetPointX(0);
+    FX_FLOAT y1 = pPathData->GetPointY(0);
+    FX_FLOAT x2 = pPathData->GetPointX(1);
+    FX_FLOAT y2 = pPathData->GetPointY(1);
     if (pMatrix) {
       pMatrix->Transform(x1, y1);
-    }
-    FX_FLOAT x2 = pPathData->GetPointX(1), y2 = pPathData->GetPointY(1);
-    if (pMatrix) {
       pMatrix->Transform(x2, y2);
     }
     DrawLine(x1, y1, x2, y2);
   } else {
     SetPathToDC(m_hDC, pPathData, pMatrix);
     if (pGraphState && stroke_alpha) {
       if (fill_mode && fill_alpha) {
         if (old_fill_mode & FX_FILL_TEXT_MODE) {
           StrokeAndFillPath(m_hDC);
         } else {
@@ skipping 12 matching lines @@
     hPen = (HPEN)SelectObject(m_hDC, hPen);
     DeleteObject(hPen);
   }
   if (hBrush) {
     hBrush = (HBRUSH)SelectObject(m_hDC, hBrush);
     DeleteObject(hBrush);
   }
   return TRUE;
 }
 
-FX_BOOL CGdiDeviceDriver::FillRect(const FX_RECT* pRect,
-                                   uint32_t fill_color,
-                                   int alpha_flag,
-                                   void* pIccTransform,
-                                   int blend_type) {
-  if (blend_type != FXDIB_BLEND_NORMAL) {
+FX_BOOL CGdiDeviceDriver::FillRectWithBlend(const FX_RECT* pRect,
+                                            uint32_t fill_color,
+                                            int blend_type) {
+  if (blend_type != FXDIB_BLEND_NORMAL)
     return FALSE;
-  }
-  Color2Argb(fill_color, fill_color, alpha_flag | (1 << 24), pIccTransform);
+
+  Color2Argb(fill_color, fill_color, 1 << 24, nullptr);
   int alpha;
   FX_COLORREF rgb;
   ArgbDecode(fill_color, alpha, rgb);
-  if (alpha == 0) {
+  if (alpha == 0)
     return TRUE;
-  }
-  if (alpha < 255) {
+
+  if (alpha < 255)
     return FALSE;
-  }
+
   HBRUSH hBrush = CreateSolidBrush(rgb);
   ::FillRect(m_hDC, (RECT*)pRect, hBrush);
   DeleteObject(hBrush);
   return TRUE;
 }
 
 FX_BOOL CGdiDeviceDriver::SetClip_PathFill(const CFX_PathData* pPathData,
                                            const CFX_Matrix* pMatrix,
                                            int fill_mode) {
   if (pPathData->GetPointCount() == 5) {
@@ skipping 23 matching lines @@
   hPen = (HPEN)SelectObject(m_hDC, hPen);
   DeleteObject(hPen);
   return ret;
 }
 
 FX_BOOL CGdiDeviceDriver::DrawCosmeticLine(FX_FLOAT x1,
                                            FX_FLOAT y1,
                                            FX_FLOAT x2,
                                            FX_FLOAT y2,
                                            uint32_t color,
-                                           int alpha_flag,
-                                           void* pIccTransform,
                                            int blend_type) {
-  if (blend_type != FXDIB_BLEND_NORMAL) {
+  if (blend_type != FXDIB_BLEND_NORMAL)
     return FALSE;
-  }
-  Color2Argb(color, color, alpha_flag | (1 << 24), pIccTransform);
+
+  Color2Argb(color, color, 1 << 24, nullptr);
   int a;
   FX_COLORREF rgb;
   ArgbDecode(color, a, rgb);
-  if (a == 0) {
+  if (a == 0)
     return TRUE;
-  }
+
   HPEN hPen = CreatePen(PS_SOLID, 1, rgb);
   hPen = (HPEN)SelectObject(m_hDC, hPen);
   MoveToEx(m_hDC, FXSYS_round(x1), FXSYS_round(y1), nullptr);
   LineTo(m_hDC, FXSYS_round(x2), FXSYS_round(y2));
   hPen = (HPEN)SelectObject(m_hDC, hPen);
   DeleteObject(hPen);
   return TRUE;
 }
 
 FX_BOOL CGdiDeviceDriver::DeleteDeviceRgn(void* pRgn) {
   DeleteObject((HGDIOBJ)pRgn);
   return TRUE;
 }
 
 CGdiDisplayDriver::CGdiDisplayDriver(HDC hDC)
     : CGdiDeviceDriver(hDC, FXDC_DISPLAY) {
   CWin32Platform* pPlatform =
       (CWin32Platform*)CFX_GEModule::Get()->GetPlatformData();
   if (pPlatform->m_GdiplusExt.IsAvailable()) {
     m_RenderCaps |= FXRC_ALPHA_PATH | FXRC_ALPHA_IMAGE;
   }
 }
 
-FX_BOOL CGdiDisplayDriver::GetDIBits(CFX_DIBitmap* pBitmap,
-                                     int left,
-                                     int top,
-                                     void* pIccTransform,
-                                     FX_BOOL bDEdge) {
+CGdiDisplayDriver::~CGdiDisplayDriver() {}
+
+FX_BOOL CGdiDisplayDriver::GetDIBits(CFX_DIBitmap* pBitmap, int left, int top) {
   FX_BOOL ret = FALSE;
   int width = pBitmap->GetWidth();
   int height = pBitmap->GetHeight();
   HBITMAP hbmp = CreateCompatibleBitmap(m_hDC, width, height);
   HDC hDCMemory = CreateCompatibleDC(m_hDC);
   HBITMAP holdbmp = (HBITMAP)SelectObject(hDCMemory, hbmp);
   BitBlt(hDCMemory, 0, 0, width, height, m_hDC, left, top, SRCCOPY);
   SelectObject(hDCMemory, holdbmp);
   BITMAPINFO bmi;
   FXSYS_memset(&bmi, 0, sizeof bmi);
   bmi.bmiHeader.biSize = sizeof bmi.bmiHeader;
   bmi.bmiHeader.biBitCount = pBitmap->GetBPP();
   bmi.bmiHeader.biHeight = -height;
   bmi.bmiHeader.biPlanes = 1;
   bmi.bmiHeader.biWidth = width;
-  if (!CFX_GEModule::Get()->GetCodecModule() ||
-      !CFX_GEModule::Get()->GetCodecModule()->GetIccModule()) {
-    pIccTransform = nullptr;
-  }
-  if (pBitmap->GetBPP() > 8 && !pBitmap->IsCmykImage() && !pIccTransform) {
+  if (pBitmap->GetBPP() > 8 && !pBitmap->IsCmykImage()) {
     ret = ::GetDIBits(hDCMemory, hbmp, 0, height, pBitmap->GetBuffer(), &bmi,
                       DIB_RGB_COLORS) == height;
   } else {
     CFX_DIBitmap bitmap;
     if (bitmap.Create(width, height, FXDIB_Rgb)) {
       bmi.bmiHeader.biBitCount = 24;
       ::GetDIBits(hDCMemory, hbmp, 0, height, bitmap.GetBuffer(), &bmi,
                   DIB_RGB_COLORS);
-      ret = pBitmap->TransferBitmap(0, 0, width, height, &bitmap, 0, 0,
-                                    pIccTransform);
+      ret =
+          pBitmap->TransferBitmap(0, 0, width, height, &bitmap, 0, 0, nullptr);
     } else {
       ret = FALSE;
     }
   }
-  if (pBitmap->HasAlpha() && ret) {
+  if (pBitmap->HasAlpha() && ret)
     pBitmap->LoadChannel(FXDIB_Alpha, 0xff);
-  }
+
   DeleteObject(hbmp);
   DeleteObject(hDCMemory);
   return ret;
 }
 
 FX_BOOL CGdiDisplayDriver::SetDIBits(const CFX_DIBSource* pSource,
                                      uint32_t color,
                                      const FX_RECT* pSrcRect,
                                      int left,
                                      int top,
-                                     int blend_type,
-                                     int alpha_flag,
-                                     void* pIccTransform) {
+                                     int blend_type) {
   ASSERT(blend_type == FXDIB_BLEND_NORMAL);
   if (pSource->IsAlphaMask()) {
     int width = pSource->GetWidth(), height = pSource->GetHeight();
-    int alpha = FXGETFLAG_COLORTYPE(alpha_flag)
-                    ? FXGETFLAG_ALPHA_FILL(alpha_flag)
-                    : FXARGB_A(color);
+    int alpha = FXARGB_A(color);
     if (pSource->GetBPP() != 1 || alpha != 255) {
       CFX_DIBitmap background;
       if (!background.Create(width, height, FXDIB_Rgb32) ||
-          !GetDIBits(&background, left, top, nullptr) ||
+          !GetDIBits(&background, left, top) ||
           !background.CompositeMask(0, 0, width, height, pSource, color, 0, 0,
-                                    FXDIB_BLEND_NORMAL, nullptr, FALSE,
-                                    alpha_flag, pIccTransform)) {
+                                    FXDIB_BLEND_NORMAL, nullptr, FALSE, 0,
+                                    nullptr)) {
         return FALSE;
       }
       FX_RECT src_rect(0, 0, width, height);
-      return SetDIBits(&background, 0, &src_rect, left, top, FXDIB_BLEND_NORMAL,
-                       0, nullptr);
+      return SetDIBits(&background, 0, &src_rect, left, top,
+                       FXDIB_BLEND_NORMAL);
     }
     FX_RECT clip_rect(left, top, left + pSrcRect->Width(),
                       top + pSrcRect->Height());
     return StretchDIBits(pSource, color, left - pSrcRect->left,
                          top - pSrcRect->top, width, height, &clip_rect, 0,
-                         alpha_flag, pIccTransform, FXDIB_BLEND_NORMAL);
+                         FXDIB_BLEND_NORMAL);
   }
   int width = pSrcRect->Width(), height = pSrcRect->Height();
   if (pSource->HasAlpha()) {
     CFX_DIBitmap bitmap;
     if (!bitmap.Create(width, height, FXDIB_Rgb) ||
-        !GetDIBits(&bitmap, left, top, nullptr) ||
+        !GetDIBits(&bitmap, left, top) ||
         !bitmap.CompositeBitmap(0, 0, width, height, pSource, pSrcRect->left,
                                 pSrcRect->top, FXDIB_BLEND_NORMAL, nullptr,
-                                FALSE, pIccTransform)) {
+                                FALSE, nullptr)) {
       return FALSE;
     }
     FX_RECT src_rect(0, 0, width, height);
-    return SetDIBits(&bitmap, 0, &src_rect, left, top, FXDIB_BLEND_NORMAL, 0,
-                     nullptr);
+    return SetDIBits(&bitmap, 0, &src_rect, left, top, FXDIB_BLEND_NORMAL);
   }
   CFX_DIBExtractor temp(pSource);
   CFX_DIBitmap* pBitmap = temp;
-  if (pBitmap) {
-    return GDI_SetDIBits(pBitmap, pSrcRect, left, top, pIccTransform);
-  }
-  return FALSE;
+  if (!pBitmap)
+    return FALSE;
+  return GDI_SetDIBits(pBitmap, pSrcRect, left, top, nullptr);
 }
 
 FX_BOOL CGdiDisplayDriver::UseFoxitStretchEngine(const CFX_DIBSource* pSource,
                                                  uint32_t color,
                                                  int dest_left,
                                                  int dest_top,
                                                  int dest_width,
                                                  int dest_height,
                                                  const FX_RECT* pClipRect,
-                                                 int render_flags,
-                                                 int alpha_flag,
-                                                 void* pIccTransform,
-                                                 int blend_type) {
+                                                 int render_flags) {
   FX_RECT bitmap_clip = *pClipRect;
-  if (dest_width < 0) {
+  if (dest_width < 0)
     dest_left += dest_width;
-  }
-  if (dest_height < 0) {
+
+  if (dest_height < 0)
     dest_top += dest_height;
-  }
+
   bitmap_clip.Offset(-dest_left, -dest_top);
   std::unique_ptr<CFX_DIBitmap> pStretched(
       pSource->StretchTo(dest_width, dest_height, render_flags, &bitmap_clip));
   if (!pStretched)
     return TRUE;
 
   FX_RECT src_rect(0, 0, pStretched->GetWidth(), pStretched->GetHeight());
   return SetDIBits(pStretched.get(), color, &src_rect, pClipRect->left,
-                   pClipRect->top, FXDIB_BLEND_NORMAL, alpha_flag,
-                   pIccTransform);
+                   pClipRect->top, FXDIB_BLEND_NORMAL);
 }
 
 FX_BOOL CGdiDisplayDriver::StretchDIBits(const CFX_DIBSource* pSource,
                                          uint32_t color,
                                          int dest_left,
                                          int dest_top,
                                          int dest_width,
                                          int dest_height,
                                          const FX_RECT* pClipRect,
                                          uint32_t flags,
-                                         int alpha_flag,
-                                         void* pIccTransform,
                                          int blend_type) {
   ASSERT(pSource && pClipRect);
   if (flags || dest_width > 10000 || dest_width < -10000 ||
       dest_height > 10000 || dest_height < -10000) {
     return UseFoxitStretchEngine(pSource, color, dest_left, dest_top,
-                                 dest_width, dest_height, pClipRect, flags,
-                                 alpha_flag, pIccTransform, blend_type);
+                                 dest_width, dest_height, pClipRect, flags);
   }
   if (pSource->IsAlphaMask()) {
     FX_RECT image_rect;
     image_rect.left = dest_width > 0 ? dest_left : dest_left + dest_width;
     image_rect.right = dest_width > 0 ? dest_left + dest_width : dest_left;
     image_rect.top = dest_height > 0 ? dest_top : dest_top + dest_height;
     image_rect.bottom = dest_height > 0 ? dest_top + dest_height : dest_top;
     FX_RECT clip_rect = image_rect;
     clip_rect.Intersect(*pClipRect);
     clip_rect.Offset(-image_rect.left, -image_rect.top);
     int clip_width = clip_rect.Width(), clip_height = clip_rect.Height();
     std::unique_ptr<CFX_DIBitmap> pStretched(
         pSource->StretchTo(dest_width, dest_height, flags, &clip_rect));
     if (!pStretched)
       return TRUE;
 
     CFX_DIBitmap background;
     if (!background.Create(clip_width, clip_height, FXDIB_Rgb32) ||
         !GetDIBits(&background, image_rect.left + clip_rect.left,
-                   image_rect.top + clip_rect.top, nullptr) ||
+                   image_rect.top + clip_rect.top) ||
         !background.CompositeMask(
             0, 0, clip_width, clip_height, pStretched.get(), color, 0, 0,
-            FXDIB_BLEND_NORMAL, nullptr, FALSE, alpha_flag, pIccTransform)) {
+            FXDIB_BLEND_NORMAL, nullptr, FALSE, 0, nullptr)) {
       return FALSE;
     }
 
     FX_RECT src_rect(0, 0, clip_width, clip_height);
-    return SetDIBits(
-        &background, 0, &src_rect, image_rect.left + clip_rect.left,
-        image_rect.top + clip_rect.top, FXDIB_BLEND_NORMAL, 0, nullptr);
+    return SetDIBits(&background, 0, &src_rect,
+                     image_rect.left + clip_rect.left,
+                     image_rect.top + clip_rect.top, FXDIB_BLEND_NORMAL);
   }
   if (pSource->HasAlpha()) {
     CWin32Platform* pPlatform =
         (CWin32Platform*)CFX_GEModule::Get()->GetPlatformData();
-    if (pPlatform->m_GdiplusExt.IsAvailable() && !pIccTransform &&
-        !pSource->IsCmykImage()) {
+    if (pPlatform->m_GdiplusExt.IsAvailable() && !pSource->IsCmykImage()) {
       CFX_DIBExtractor temp(pSource);
       CFX_DIBitmap* pBitmap = temp;
       if (!pBitmap)
         return FALSE;
       return pPlatform->m_GdiplusExt.StretchDIBits(
           m_hDC, pBitmap, dest_left, dest_top, dest_width, dest_height,
           pClipRect, flags);
     }
     return UseFoxitStretchEngine(pSource, color, dest_left, dest_top,
-                                 dest_width, dest_height, pClipRect, flags,
-                                 alpha_flag, pIccTransform, blend_type);
+                                 dest_width, dest_height, pClipRect, flags);
   }
   CFX_DIBExtractor temp(pSource);
   CFX_DIBitmap* pBitmap = temp;
-  if (pBitmap) {
-    return GDI_StretchDIBits(pBitmap, dest_left, dest_top, dest_width,
-                             dest_height, flags, pIccTransform);
-  }
-  return FALSE;
+  if (!pBitmap)
+    return FALSE;
+  return GDI_StretchDIBits(pBitmap, dest_left, dest_top, dest_width,
+                           dest_height, flags, nullptr);
 }
 
 CFX_WindowsDevice::CFX_WindowsDevice(HDC hDC) {
   SetDeviceDriver(CreateDriver(hDC));
 }
 
 CFX_WindowsDevice::~CFX_WindowsDevice() {}
 
 HDC CFX_WindowsDevice::GetDC() const {
   IFX_RenderDeviceDriver* pRDD = GetDeviceDriver();
@@ skipping 41 matching lines @@
   if (m_hDC) {
     SelectObject(m_hDC, m_hOldBitmap);
     DeleteDC(m_hDC);
   }
   if (m_hBitmap)
     DeleteObject(m_hBitmap);
   delete GetBitmap();
 }
 
 #endif  // _FX_OS_ == _FX_WIN32_DESKTOP_ || _FX_OS_ == _FX_WIN64_