Remove default arguments in CFX_RenderDevice.

core/fpdfapi/fpdf_render/fpdf_render_image.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_render/render_int.h"
 
 #include <utility>
 #include <vector>
@@ skipping 58 matching lines @@
   bool bBackAlphaRequired = blend_mode && bIsolated && !m_bDropObjects;
   bool bGetBackGround =
       ((m_pDevice->GetRenderCaps() & FXRC_ALPHA_OUTPUT)) ||
       (!(m_pDevice->GetRenderCaps() & FXRC_ALPHA_OUTPUT) &&
        (m_pDevice->GetRenderCaps() & FXRC_GET_BITS) && !bBackAlphaRequired);
   if (bGetBackGround) {
     if (bIsolated || !bGroup) {
       if (pDIBitmap->IsAlphaMask()) {
         return;
       }
-      m_pDevice->SetDIBits(pDIBitmap, left, top, blend_mode);
+      m_pDevice->SetDIBitsWithBlend(pDIBitmap, left, top, blend_mode);
     } else {
       FX_RECT rect(left, top, left + pDIBitmap->GetWidth(),
                    top + pDIBitmap->GetHeight());
       rect.Intersect(m_pDevice->GetClipBox());
       CFX_DIBitmap* pClone = NULL;
       FX_BOOL bClone = FALSE;
       if (m_pDevice->GetBackDrop() && m_pDevice->GetBitmap()) {
         bClone = TRUE;
         pClone = m_pDevice->GetBackDrop()->Clone(&rect);
         CFX_DIBitmap* pForeBitmap = m_pDevice->GetBitmap();
         pClone->CompositeBitmap(0, 0, pClone->GetWidth(), pClone->GetHeight(),
                                 pForeBitmap, rect.left, rect.top);
         left = left >= 0 ? 0 : left;
         top = top >= 0 ? 0 : top;
         if (!pDIBitmap->IsAlphaMask())
           pClone->CompositeBitmap(0, 0, pClone->GetWidth(), pClone->GetHeight(),
                                   pDIBitmap, left, top, blend_mode);
         else
           pClone->CompositeMask(0, 0, pClone->GetWidth(), pClone->GetHeight(),
                                 pDIBitmap, mask_argb, left, top, blend_mode);
       } else {
         pClone = pDIBitmap;
       }
       if (m_pDevice->GetBackDrop()) {
         m_pDevice->SetDIBits(pClone, rect.left, rect.top);
       } else {
         if (pDIBitmap->IsAlphaMask()) {
           return;
         }
-        m_pDevice->SetDIBits(pDIBitmap, rect.left, rect.top, blend_mode);
+        m_pDevice->SetDIBitsWithBlend(pDIBitmap, rect.left, rect.top,
+                                      blend_mode);
       }
       if (bClone) {
         delete pClone;
       }
     }
     return;
   }
   int back_left, back_top;
   FX_RECT rect(left, top, left + pDIBitmap->GetWidth(),
                top + pDIBitmap->GetHeight());
@@ skipping 473 matching lines @@
           } else {
             dest_scan += 4;
           }
         }
       }
     }
     bitmap_device2.GetBitmap()->ConvertFormat(FXDIB_8bppMask);
     bitmap_device1.GetBitmap()->MultiplyAlpha(bitmap_device2.GetBitmap());
     bitmap_device1.GetBitmap()->MultiplyAlpha(255);
   }
-  m_pRenderStatus->m_pDevice->SetDIBits(bitmap_device1.GetBitmap(), rect.left,
-                                        rect.top, m_BlendType);
+  m_pRenderStatus->m_pDevice->SetDIBitsWithBlend(
+      bitmap_device1.GetBitmap(), rect.left, rect.top, m_BlendType);
   return FALSE;
 }
 FX_BOOL CPDF_ImageRenderer::DrawMaskedImage() {
   if (m_pRenderStatus->m_bPrint &&
       !(m_pRenderStatus->m_pDevice->GetRenderCaps() & FXRC_BLEND_MODE)) {
     m_Result = FALSE;
     return FALSE;
   }
   FX_RECT rect = m_ImageMatrix.GetUnitRect().GetOutterRect();
   rect.Intersect(m_pRenderStatus->m_pDevice->GetClipBox());
@@ skipping 73 matching lines @@
           }
         }
       }
     }
     bitmap_device2.GetBitmap()->ConvertFormat(FXDIB_8bppMask);
     bitmap_device1.GetBitmap()->MultiplyAlpha(bitmap_device2.GetBitmap());
     if (m_BitmapAlpha < 255) {
       bitmap_device1.GetBitmap()->MultiplyAlpha(m_BitmapAlpha);
     }
   }
-  m_pRenderStatus->m_pDevice->SetDIBits(bitmap_device1.GetBitmap(), rect.left,
-                                        rect.top, m_BlendType);
+  m_pRenderStatus->m_pDevice->SetDIBitsWithBlend(
+      bitmap_device1.GetBitmap(), rect.left, rect.top, m_BlendType);
   return FALSE;
 }
 
 FX_BOOL CPDF_ImageRenderer::StartDIBSource() {
   if (!(m_Flags & RENDER_FORCE_DOWNSAMPLE) && m_pDIBSource->GetBPP() > 1) {
     int image_size = m_pDIBSource->GetBPP() / 8 * m_pDIBSource->GetWidth() *
                      m_pDIBSource->GetHeight();
     if (image_size > FPDF_HUGE_IMAGE_SIZE &&
         !(m_Flags & RENDER_FORCE_HALFTONE)) {
       m_Flags |= RENDER_FORCE_DOWNSAMPLE;
     }
   }
-  if (m_pRenderStatus->m_pDevice->StartDIBits(
+  if (m_pRenderStatus->m_pDevice->StartDIBitsWithBlend(
           m_pDIBSource, m_BitmapAlpha, m_FillArgb, &m_ImageMatrix, m_Flags,
-          m_DeviceHandle, 0, nullptr, m_BlendType)) {
+          m_DeviceHandle, m_BlendType)) {
     if (m_DeviceHandle) {
       m_Status = 3;
       return TRUE;
     }
     return FALSE;
   }
   CFX_FloatRect image_rect_f = m_ImageMatrix.GetUnitRect();
   FX_RECT image_rect = image_rect_f.GetOutterRect();
   int dest_width = image_rect.Width();
   int dest_height = image_rect.Height();
@@ skipping 14 matching lines @@
   }
   if (m_ImageMatrix.a < 0)
     dest_width = -dest_width;
 
   if (m_ImageMatrix.d > 0)
     dest_height = -dest_height;
 
   int dest_left = dest_width > 0 ? image_rect.left : image_rect.right;
   int dest_top = dest_height > 0 ? image_rect.top : image_rect.bottom;
   if (m_pDIBSource->IsOpaqueImage() && m_BitmapAlpha == 255) {
-    if (m_pRenderStatus->m_pDevice->StretchDIBits(
+    if (m_pRenderStatus->m_pDevice->StretchDIBitsWithFlagsAndBlend(
             m_pDIBSource, dest_left, dest_top, dest_width, dest_height, m_Flags,
-            nullptr, m_BlendType)) {
+            m_BlendType)) {
       return FALSE;
     }
   }
   if (m_pDIBSource->IsAlphaMask()) {
     if (m_BitmapAlpha != 255)
       m_FillArgb = FXARGB_MUL_ALPHA(m_FillArgb, m_BitmapAlpha);
-    if (m_pRenderStatus->m_pDevice->StretchBitMask(
+    if (m_pRenderStatus->m_pDevice->StretchBitMaskWithFlags(
             m_pDIBSource, dest_left, dest_top, dest_width, dest_height,
             m_FillArgb, m_Flags)) {
       return FALSE;
     }
   }
   if (m_pRenderStatus->m_bPrint &&
       !(m_pRenderStatus->m_pDevice->GetRenderCaps() & FXRC_BLEND_MODE)) {
     m_Result = FALSE;
     return TRUE;
   }
@@ skipping 69 matching lines @@
 
     if (pBitmap->IsAlphaMask()) {
       if (m_BitmapAlpha != 255)
         m_FillArgb = FXARGB_MUL_ALPHA(m_FillArgb, m_BitmapAlpha);
       m_Result = m_pRenderStatus->m_pDevice->SetBitMask(
           pBitmap.get(), m_pTransformer->result().left,
           m_pTransformer->result().top, m_FillArgb);
     } else {
       if (m_BitmapAlpha != 255)
         pBitmap->MultiplyAlpha(m_BitmapAlpha);
-      m_Result = m_pRenderStatus->m_pDevice->SetDIBits(
+      m_Result = m_pRenderStatus->m_pDevice->SetDIBitsWithBlend(
           pBitmap.get(), m_pTransformer->result().left,
           m_pTransformer->result().top, m_BlendType);
     }
     return FALSE;
   }
   if (m_Status == 3)
     return m_pRenderStatus->m_pDevice->ContinueDIBits(m_DeviceHandle, pPause);
 
   if (m_Status == 4) {
     if (m_Loader.Continue(m_LoadHandle, pPause))
@@ skipping 138 matching lines @@
   } else if (pFunc) {
     int size = dest_pitch * height;
     for (int i = 0; i < size; i++) {
       dest_buf[i] = transfers[src_buf[i]];
     }
   } else {
     FXSYS_memcpy(dest_buf, src_buf, dest_pitch * height);
   }
   return pMask.release();
 }