Remove default arguments from IFX_RenderDeviceDriver.

core/fxge/skia/fx_skia_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.
 
 #include "core/fxge/include/fx_ge.h"
 
 #if defined(_SKIA_SUPPORT_)
+#include <algorithm>
+#include <vector>
+
 #include "core/fxcodec/include/fx_codec.h"
 
 #include "core/fpdfapi/fpdf_page/cpdf_shadingpattern.h"
 #include "core/fpdfapi/fpdf_page/pageint.h"
 #include "core/fpdfapi/fpdf_parser/include/cpdf_array.h"
 #include "core/fpdfapi/fpdf_parser/include/cpdf_dictionary.h"
 #include "core/fpdfapi/fpdf_parser/include/cpdf_stream_acc.h"
 #include "core/fxge/skia/fx_skia_device.h"
 
 #include "third_party/skia/include/core/SkCanvas.h"
@@ skipping 566 matching lines @@
   if (!m_pRecorder)
     delete m_pCanvas;
 }
 
 FX_BOOL CFX_SkiaDeviceDriver::DrawDeviceText(int nChars,
                                              const FXTEXT_CHARPOS* pCharPos,
                                              CFX_Font* pFont,
                                              CFX_FontCache* pCache,
                                              const CFX_Matrix* pObject2Device,
                                              FX_FLOAT font_size,
-                                             uint32_t color,
-                                             int alpha_flag,
-                                             void* pIccTransform) {
+                                             uint32_t color) {
   sk_sp<SkTypeface> typeface(SkSafeRef(pCache->GetDeviceCache(pFont)));
   SkPaint paint;
   paint.setAntiAlias(true);
   paint.setColor(color);
   paint.setTypeface(typeface);
   paint.setTextEncoding(SkPaint::kGlyphID_TextEncoding);
   paint.setTextSize(font_size);
   paint.setSubpixelText(true);
   m_pCanvas->save();
   SkMatrix skMatrix = ToFlippedSkMatrix(*pObject2Device);
@@ skipping 95 matching lines @@
   return TRUE;
 }
 
 FX_BOOL CFX_SkiaDeviceDriver::DrawPath(
     const CFX_PathData* pPathData,          // path info
     const CFX_Matrix* pObject2Device,       // optional transformation
     const CFX_GraphStateData* pGraphState,  // graphic state, for pen attributes
     uint32_t fill_color,                    // fill color
     uint32_t stroke_color,                  // stroke color
     int fill_mode,  // fill mode, WINDING or ALTERNATE. 0 for not filled
-    int alpha_flag,
-    void* pIccTransform,
     int blend_type) {
   SkIRect rect;
   rect.set(0, 0, GetDeviceCaps(FXDC_PIXEL_WIDTH),
            GetDeviceCaps(FXDC_PIXEL_HEIGHT));
   SkMatrix skMatrix;
   if (pObject2Device)
     skMatrix = ToSkMatrix(*pObject2Device);
   else
     skMatrix.setIdentity();
   SkPaint skPaint;
   skPaint.setAntiAlias(true);
-  int stroke_alpha = FXGETFLAG_COLORTYPE(alpha_flag)
-                         ? FXGETFLAG_ALPHA_STROKE(alpha_flag)
-                         : FXARGB_A(stroke_color);
+  int stroke_alpha = FXARGB_A(stroke_color);
   if (pGraphState && stroke_alpha)
     PaintStroke(&skPaint, pGraphState, skMatrix);
   SkPath skPath = BuildPath(pPathData);
   m_pCanvas->save();
   m_pCanvas->concat(skMatrix);
   if ((fill_mode & 3) && fill_color) {
     skPath.setFillType((fill_mode & 3) == FXFILL_WINDING
                            ? SkPath::kWinding_FillType
                            : SkPath::kEvenOdd_FillType);
     SkPath strokePath;
@@ skipping 17 matching lines @@
     DebugShowSkiaPath(skPath);
     DebugShowCanvasMatrix(m_pCanvas);
     skPaint.setStyle(SkPaint::kStroke_Style);
     skPaint.setColor(stroke_color);
     m_pCanvas->drawPath(skPath, skPaint);
   }
   m_pCanvas->restore();
   return TRUE;
 }
 
-FX_BOOL CFX_SkiaDeviceDriver::FillRect(const FX_RECT* pRect,
-                                       uint32_t fill_color,
-                                       int alpha_flag,
-                                       void* pIccTransform,
-                                       int blend_type) {
+FX_BOOL CFX_SkiaDeviceDriver::FillRectWithBlend(const FX_RECT* pRect,
+                                                uint32_t fill_color,
+                                                int blend_type) {
   SkPaint spaint;
   spaint.setAntiAlias(true);
   spaint.setColor(fill_color);
   spaint.setXfermodeMode(GetSkiaBlendMode(blend_type));
 
   m_pCanvas->drawRect(
       SkRect::MakeLTRB(pRect->left, pRect->top, pRect->right, pRect->bottom),
       spaint);
   return TRUE;
 }
@@ skipping 137 matching lines @@
   pRect->left = 0;
   pRect->top = 0;
   const SkImageInfo& canvasSize = m_pCanvas->imageInfo();
   pRect->right = canvasSize.width();
   pRect->bottom = canvasSize.height();
   return TRUE;
 }
 
 FX_BOOL CFX_SkiaDeviceDriver::GetDIBits(CFX_DIBitmap* pBitmap,
                                         int left,
-                                        int top,
-                                        void* pIccTransform,
-                                        FX_BOOL bDEdge) {
+                                        int top) {
   if (!m_pBitmap || !m_pBitmap->GetBuffer())
     return TRUE;
-  if (bDEdge) {
-    if (m_bRgbByteOrder) {
-      RgbByteOrderTransferBitmap(pBitmap, 0, 0, pBitmap->GetWidth(),
-                                 pBitmap->GetHeight(), m_pBitmap, left, top);
-    } else {
-      return pBitmap->TransferBitmap(0, 0, pBitmap->GetWidth(),
-                                     pBitmap->GetHeight(), m_pBitmap, left, top,
-                                     pIccTransform);
-    }
-    return TRUE;
-  }
+
   FX_RECT rect(left, top, left + pBitmap->GetWidth(),
                top + pBitmap->GetHeight());
   CFX_DIBitmap* pBack;
   if (m_pOriDevice) {
     pBack = m_pOriDevice->Clone(&rect);
     if (!pBack)
       return TRUE;
+
     pBack->CompositeBitmap(0, 0, pBack->GetWidth(), pBack->GetHeight(),
                            m_pBitmap, 0, 0);
   } else {
     pBack = m_pBitmap->Clone(&rect);
     if (!pBack)
       return TRUE;
   }
+
   FX_BOOL bRet = TRUE;
-  left = left >= 0 ? 0 : left;
-  top = top >= 0 ? 0 : top;
+  left = std::min(left, 0);
+  top = std::min(top, 0);
   if (m_bRgbByteOrder) {
     RgbByteOrderTransferBitmap(pBitmap, 0, 0, rect.Width(), rect.Height(),
                                pBack, left, top);
   } else {
     bRet = pBitmap->TransferBitmap(0, 0, rect.Width(), rect.Height(), pBack,
-                                   left, top, pIccTransform);
+                                   left, top, nullptr);
   }
   delete pBack;
   return bRet;
 }
 
 FX_BOOL CFX_SkiaDeviceDriver::SetDIBits(const CFX_DIBSource* pBitmap,
                                         uint32_t argb,
                                         const FX_RECT* pSrcRect,
                                         int left,
                                         int top,
-                                        int blend_type,
-                                        int alpha_flag,
-                                        void* pIccTransform) {
+                                        int blend_type) {
   if (!m_pBitmap || !m_pBitmap->GetBuffer())
     return TRUE;
 
   CFX_Matrix m(pBitmap->GetWidth(), 0, 0, -pBitmap->GetHeight(), left,
                top + pBitmap->GetHeight());
   void* dummy;
-  return this->StartDIBits(pBitmap, 0xFF, argb, &m, 0, dummy, alpha_flag,
-                           pIccTransform, blend_type);
+  return StartDIBits(pBitmap, 0xFF, argb, &m, 0, dummy, blend_type);
 }
 
 FX_BOOL CFX_SkiaDeviceDriver::StretchDIBits(const CFX_DIBSource* pSource,
                                             uint32_t argb,
                                             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) {
   if (!m_pBitmap->GetBuffer())
     return TRUE;
   CFX_Matrix m(dest_width, 0, 0, -dest_height, dest_left,
                dest_top + dest_height);
 
   m_pCanvas->save();
   SkRect skClipRect = SkRect::MakeLTRB(pClipRect->left, pClipRect->bottom,
                                        pClipRect->right, pClipRect->top);
   m_pCanvas->clipRect(skClipRect);
   void* dummy;
-  FX_BOOL result = this->StartDIBits(pSource, 0xFF, argb, &m, 0, dummy,
-                                     alpha_flag, pIccTransform, blend_type);
+  FX_BOOL result = StartDIBits(pSource, 0xFF, argb, &m, 0, dummy, blend_type);
   m_pCanvas->restore();
 
   return result;
 }
 
 FX_BOOL CFX_SkiaDeviceDriver::StartDIBits(const CFX_DIBSource* pSource,
                                           int bitmap_alpha,
                                           uint32_t argb,
                                           const CFX_Matrix* pMatrix,
                                           uint32_t render_flags,
                                           void*& handle,
-                                          int alpha_flag,
-                                          void* pIccTransform,
                                           int blend_type) {
   DebugValidate(m_pBitmap, m_pOriDevice);
   SkColorType colorType = pSource->IsAlphaMask()
                               ? SkColorType::kAlpha_8_SkColorType
                               : SkColorType::kGray_8_SkColorType;
   SkAlphaType alphaType =
       pSource->IsAlphaMask() ? kPremul_SkAlphaType : kOpaque_SkAlphaType;
   SkColorTable* ct = nullptr;
   void* buffer = pSource->GetBuffer();
   std::unique_ptr<uint8_t, FxFreeDeleter> dst8Storage;
@@ skipping 139 matching lines @@
   SetDeviceDriver(pDriver);
   return true;
 }
 
 CFX_FxgeDevice::~CFX_FxgeDevice() {
   if (m_bOwnedBitmap && GetBitmap())
     delete GetBitmap();
 }
 
 void CFX_FxgeDevice::PreMultiply() {
-  (static_cast<CFX_SkiaDeviceDriver*>(this->GetDeviceDriver()))->PreMultiply();
+  (static_cast<CFX_SkiaDeviceDriver*>(GetDeviceDriver()))->PreMultiply();
 }
 
 #endif