Revert of Create a subset of skia support for paths only

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 <algorithm>
 #include <vector>
 
 #include "core/fxcodec/fx_codec.h"
 #include "core/fxcrt/fx_memory.h"
 
 #include "core/fpdfapi/page/cpdf_shadingpattern.h"
 #include "core/fpdfapi/page/pageint.h"
 #include "core/fpdfapi/parser/cpdf_array.h"
 #include "core/fpdfapi/parser/cpdf_dictionary.h"
 #include "core/fpdfapi/parser/cpdf_stream_acc.h"
 #include "core/fxge/cfx_fxgedevice.h"
 #include "core/fxge/cfx_gemodule.h"
 #include "core/fxge/cfx_graphstatedata.h"
 #include "core/fxge/cfx_pathdata.h"
 #include "core/fxge/cfx_renderdevice.h"
 #include "core/fxge/skia/fx_skia_device.h"
-
-#ifndef _SKIA_SUPPORT_
-#include "core/fxge/ge/cfx_cliprgn.h"
-#endif
-
 #include "third_party/base/ptr_util.h"
-
 #include "third_party/skia/include/core/SkCanvas.h"
-#include "third_party/skia/include/core/SkPaint.h"
-#include "third_party/skia/include/core/SkPath.h"
-#include "third_party/skia/include/effects/SkDashPathEffect.h"
-#include "third_party/skia/include/pathops/SkPathOps.h"
-
-#ifdef _SKIA_SUPPORT_
 #include "third_party/skia/include/core/SkColorFilter.h"
 #include "third_party/skia/include/core/SkColorPriv.h"
 #include "third_party/skia/include/core/SkMaskFilter.h"
+#include "third_party/skia/include/core/SkPaint.h"
+#include "third_party/skia/include/core/SkPath.h"
 #include "third_party/skia/include/core/SkPictureRecorder.h"
 #include "third_party/skia/include/core/SkShader.h"
 #include "third_party/skia/include/core/SkStream.h"
 #include "third_party/skia/include/core/SkTypeface.h"
+#include "third_party/skia/include/effects/SkDashPathEffect.h"
 #include "third_party/skia/include/effects/SkGradientShader.h"
-#endif
+#include "third_party/skia/include/pathops/SkPathOps.h"
 
 #ifdef SK_DEBUG
 #include "third_party/skia/include/core/SkClipStack.h"
 #endif
 
 namespace {
 
-#ifndef _SKIA_SUPPORT_
-void RgbByteOrderTransferBitmap(CFX_DIBitmap* pBitmap,
-                                int dest_left,
-                                int dest_top,
-                                int width,
-                                int height,
-                                const CFX_DIBSource* pSrcBitmap,
-                                int src_left,
-                                int src_top) {
-  if (!pBitmap)
-    return;
-
-  pBitmap->GetOverlapRect(dest_left, dest_top, width, height,
-                          pSrcBitmap->GetWidth(), pSrcBitmap->GetHeight(),
-                          src_left, src_top, nullptr);
-  if (width == 0 || height == 0)
-    return;
-
-  int Bpp = pBitmap->GetBPP() / 8;
-  FXDIB_Format dest_format = pBitmap->GetFormat();
-  FXDIB_Format src_format = pSrcBitmap->GetFormat();
-  int pitch = pBitmap->GetPitch();
-  uint8_t* buffer = pBitmap->GetBuffer();
-  if (dest_format == src_format) {
-    for (int row = 0; row < height; row++) {
-      uint8_t* dest_scan = buffer + (dest_top + row) * pitch + dest_left * Bpp;
-      uint8_t* src_scan =
-          (uint8_t*)pSrcBitmap->GetScanline(src_top + row) + src_left * Bpp;
-      if (Bpp == 4) {
-        for (int col = 0; col < width; col++) {
-          FXARGB_SETDIB(dest_scan, FXARGB_MAKE(src_scan[3], src_scan[0],
-                                               src_scan[1], src_scan[2]));
-          dest_scan += 4;
-          src_scan += 4;
-        }
-      } else {
-        for (int col = 0; col < width; col++) {
-          *dest_scan++ = src_scan[2];
-          *dest_scan++ = src_scan[1];
-          *dest_scan++ = src_scan[0];
-          src_scan += 3;
-        }
-      }
-    }
-    return;
-  }
-
-  uint8_t* dest_buf = buffer + dest_top * pitch + dest_left * Bpp;
-  if (dest_format == FXDIB_Rgb) {
-    if (src_format == FXDIB_Rgb32) {
-      for (int row = 0; row < height; row++) {
-        uint8_t* dest_scan = dest_buf + row * pitch;
-        uint8_t* src_scan =
-            (uint8_t*)pSrcBitmap->GetScanline(src_top + row) + src_left * 4;
-        for (int col = 0; col < width; col++) {
-          *dest_scan++ = src_scan[2];
-          *dest_scan++ = src_scan[1];
-          *dest_scan++ = src_scan[0];
-          src_scan += 4;
-        }
-      }
-    } else {
-      ASSERT(false);
-    }
-    return;
-  }
-
-  if (dest_format == FXDIB_Argb || dest_format == FXDIB_Rgb32) {
-    if (src_format == FXDIB_Rgb) {
-      for (int row = 0; row < height; row++) {
-        uint8_t* dest_scan = (uint8_t*)(dest_buf + row * pitch);
-        uint8_t* src_scan =
-            (uint8_t*)pSrcBitmap->GetScanline(src_top + row) + src_left * 3;
-        for (int col = 0; col < width; col++) {
-          FXARGB_SETDIB(dest_scan, FXARGB_MAKE(0xff, src_scan[0], src_scan[1],
-                                               src_scan[2]));
-          dest_scan += 4;
-          src_scan += 3;
-        }
-      }
-    } else if (src_format == FXDIB_Rgb32) {
-      ASSERT(dest_format == FXDIB_Argb);
-      for (int row = 0; row < height; row++) {
-        uint8_t* dest_scan = dest_buf + row * pitch;
-        uint8_t* src_scan =
-            (uint8_t*)(pSrcBitmap->GetScanline(src_top + row) + src_left * 4);
-        for (int col = 0; col < width; col++) {
-          FXARGB_SETDIB(dest_scan, FXARGB_MAKE(0xff, src_scan[0], src_scan[1],
-                                               src_scan[2]));
-          src_scan += 4;
-          dest_scan += 4;
-        }
-      }
-    }
-    return;
-  }
-
-  ASSERT(false);
-}
-
-#endif
-
 #define SHOW_SKIA_PATH 0  // set to 1 to print the path contents
 #define DRAW_SKIA_CLIP 0  // set to 1 to draw a green rectangle around the clip
 
 void DebugShowSkiaPath(const SkPath& path) {
 #if SHOW_SKIA_PATH
   char buffer[4096];
   sk_bzero(buffer, sizeof(buffer));
   SkMemoryWStream stream(buffer, sizeof(buffer));
   path.dump(&stream, false, false);
   printf("%s\n", buffer);
@@ skipping 13 matching lines @@
 #if DRAW_SKIA_CLIP
 
 SkPaint DebugClipPaint() {
   SkPaint paint;
   paint.setAntiAlias(true);
   paint.setColor(SK_ColorGREEN);
   paint.setStyle(SkPaint::kStroke_Style);
   return paint;
 }
 
-#ifdef _SKIA_SUPPORT_
 void DebugDrawSkiaClipRect(SkCanvas* canvas, const SkRect& rect) {
   SkPaint paint = DebugClipPaint();
   canvas->drawRect(rect, paint);
 }
-#endif
 
 void DebugDrawSkiaClipPath(SkCanvas* canvas, const SkPath& path) {
   SkPaint paint = DebugClipPaint();
   canvas->drawPath(path, paint);
 }
 
 #else  // DRAW_SKIA_CLIP
 
-#ifdef _SKIA_SUPPORT_
 void DebugDrawSkiaClipRect(SkCanvas* canvas, const SkRect& rect) {}
-#endif
-
 void DebugDrawSkiaClipPath(SkCanvas* canvas, const SkPath& path) {}
 
 #endif  // DRAW_SKIA_CLIP
 
 #undef SHOW_SKIA_PATH
 #undef DRAW_SKIA_CLIP
 
-#ifdef _SKIA_SUPPORT_
 static void DebugValidate(const CFX_DIBitmap* bitmap,
                           const CFX_DIBitmap* device) {
   if (bitmap) {
     SkASSERT(bitmap->GetBPP() == 8 || bitmap->GetBPP() == 32);
     if (bitmap->GetBPP() == 32) {
       bitmap->DebugVerifyBitmapIsPreMultiplied();
     }
   }
   if (device) {
     SkASSERT(device->GetBPP() == 8 || device->GetBPP() == 32);
     if (device->GetBPP() == 32) {
       device->DebugVerifyBitmapIsPreMultiplied();
     }
   }
 }
-#endif
 
 SkPath BuildPath(const CFX_PathData* pPathData) {
   SkPath skPath;
   const CFX_PathData* pFPath = pPathData;
   int nPoints = pFPath->GetPointCount();
   FX_PATHPOINT* pPoints = pFPath->GetPoints();
   for (int i = 0; i < nPoints; i++) {
     FX_FLOAT x = pPoints[i].m_PointX;
     FX_FLOAT y = pPoints[i].m_PointY;
     int point_type = pPoints[i].m_Flag & FXPT_TYPE;
@@ skipping 12 matching lines @@
   }
   return skPath;
 }
 
 SkMatrix ToSkMatrix(const CFX_Matrix& m) {
   SkMatrix skMatrix;
   skMatrix.setAll(m.a, m.b, m.e, m.c, m.d, m.f, 0, 0, 1);
   return skMatrix;
 }
 
-#ifdef _SKIA_SUPPORT_
 // use when pdf's y-axis points up insead of down
 SkMatrix ToFlippedSkMatrix(const CFX_Matrix& m, SkScalar flip) {
   SkMatrix skMatrix;
   skMatrix.setAll(m.a * flip, -m.c * flip, m.e, m.b * flip, -m.d * flip, m.f, 0,
                   0, 1);
   return skMatrix;
 }
-#endif
 
 SkBlendMode GetSkiaBlendMode(int blend_type) {
   switch (blend_type) {
     case FXDIB_BLEND_MULTIPLY:
       return SkBlendMode::kMultiply;
     case FXDIB_BLEND_SCREEN:
       return SkBlendMode::kScreen;
     case FXDIB_BLEND_OVERLAY:
       return SkBlendMode::kOverlay;
     case FXDIB_BLEND_DARKEN:
@@ skipping 19 matching lines @@
     case FXDIB_BLEND_COLOR:
       return SkBlendMode::kColor;
     case FXDIB_BLEND_LUMINOSITY:
       return SkBlendMode::kLuminosity;
     case FXDIB_BLEND_NORMAL:
     default:
       return SkBlendMode::kSrcOver;
   }
 }
 
-#ifdef _SKIA_SUPPORT_
 bool AddColors(const CPDF_ExpIntFunc* pFunc, SkTDArray<SkColor>* skColors) {
   if (pFunc->CountInputs() != 1)
     return false;
   if (pFunc->m_Exponent != 1)
     return false;
   if (pFunc->m_nOrigOutputs != 3)
     return false;
   skColors->push(
       SkColorSetARGB(0xFF, SkUnitScalarClampToByte(pFunc->m_pBeginValues[0]),
                      SkUnitScalarClampToByte(pFunc->m_pBeginValues[1]),
@@ skipping 263 matching lines @@
       colorType = SkColorType::kUnknown_SkColorType;
   }
   SkImageInfo imageInfo =
       SkImageInfo::Make(width, height, colorType, alphaType);
   skBitmap->installPixels(imageInfo, buffer, rowBytes, *ctPtr, nullptr,
                           nullptr);
   *widthPtr = width;
   *heightPtr = height;
   return true;
 }
-#endif
 
 }  // namespace
 
 // Encapsulate the state used for successive text and path draws so that
 // they can be combined.
 class SkiaState {
  public:
   enum class Clip {
     kSave,
     kPath,
   };
 
   // mark all cached state as uninitialized
   SkiaState()
       : m_pFont(nullptr),
         m_fontSize(0),
         m_fillColor(0),
         m_strokeColor(0),
         m_blendType(0),
         m_commandIndex(0),
-#if _SKIA_SUPPORT_
         m_drawText(false),
-#endif
         m_drawPath(false),
         m_fillPath(false),
-        m_debugDisable(true) {
-  }
+        m_debugDisable(false) {}
 
   bool DrawPath(const CFX_PathData* pPathData,
                 const CFX_Matrix* pMatrix,
                 const CFX_GraphStateData* pDrawState,
                 uint32_t fill_color,
                 uint32_t stroke_color,
                 int fill_mode,
                 int blend_type,
                 CFX_SkiaDeviceDriver* pDriver) {
     if (m_debugDisable)
       return false;
     if (m_commandIndex < m_commands.count())
       FlushCommands(pDriver);
-#if _SKIA_SUPPORT_
     if (m_drawText)
       FlushText(pDriver);
-#endif
     if (m_drawPath && DrawChanged(pMatrix, pDrawState, fill_color, stroke_color,
                                   fill_mode, blend_type)) {
       FlushPath(pDriver);
     }
     if (!m_drawPath) {
       m_skPath.reset();
       m_fillPath = (fill_mode & 3) && fill_color;
       m_skPath.setFillType((fill_mode & 3) == FXFILL_ALTERNATE
                                ? SkPath::kEvenOdd_FillType
                                : SkPath::kWinding_FillType);
@@ skipping 46 matching lines @@
       DebugShowSkiaPath(m_skPath);
       DebugShowCanvasMatrix(skCanvas);
       skPaint.setStyle(SkPaint::kStroke_Style);
       skPaint.setColor(m_strokeColor);
       skCanvas->drawPath(m_skPath, skPaint);
     }
     skCanvas->restore();
     m_drawPath = false;
   }
 
-#ifdef _SKIA_SUPPORT_
   bool DrawText(int nChars,
                 const FXTEXT_CHARPOS* pCharPos,
                 CFX_Font* pFont,
                 const CFX_Matrix* pMatrix,
                 FX_FLOAT font_size,
                 uint32_t color,
                 CFX_SkiaDeviceDriver* pDriver) {
     if (m_debugDisable)
       return false;
     if (m_commandIndex < m_commands.count())
@@ skipping 43 matching lines @@
     skPaint.setSubpixelText(true);
     skPaint.setHinting(SkPaint::kNo_Hinting);
     SkCanvas* skCanvas = pDriver->SkiaCanvas();
     skCanvas->save();
     skCanvas->concat(skMatrix);
     skCanvas->drawPosText(m_glyphs.begin(), m_glyphs.count() * 2,
                           m_positions.begin(), skPaint);
     skCanvas->restore();
     m_drawText = false;
   }
-#endif
 
   bool SetClipFill(const CFX_PathData* pPathData,
                    const CFX_Matrix* pMatrix,
                    int fill_mode,
                    CFX_SkiaDeviceDriver* pDriver) {
     if (m_debugDisable)
       return false;
     SkPath skClipPath = BuildPath(pPathData);
     skClipPath.setFillType((fill_mode & 3) == FXFILL_ALTERNATE
                                ? SkPath::kEvenOdd_FillType
@@ skipping 169 matching lines @@
     for (int index = 0; index < pState->m_DashCount; ++index) {
       if (pState->m_DashArray[index] != refState.m_DashArray[index])
         return false;
     }
     return true;
   }
 
   void Flush(CFX_SkiaDeviceDriver* pDriver) {
     if (m_drawPath)
       FlushPath(pDriver);
-#ifdef _SKIA_SUPPORT_
     if (m_drawText)
       FlushText(pDriver);
-#endif
   }
 
 #ifdef SK_DEBUG
   void Dump(const CFX_SkiaDeviceDriver* pDriver) const {
     SkDebugf("\n\nSkia Save Count %d:\n", pDriver->m_pCanvas->getSaveCount());
     pDriver->m_pCanvas->getClipStack()->dump();
     SkDebugf("Cache:\n");
     for (int index = 0; index < m_commands.count(); ++index) {
       SkDebugf("%s ", m_commandIndex == index ? "-->" : "   ");
       switch (m_commands[index]) {
@@ skipping 22 matching lines @@
   CFX_Matrix m_drawMatrix;
   CFX_GraphStateData m_clipState;
   CFX_GraphStateData m_drawState;
   CFX_Matrix m_clipMatrix;
   CFX_Font* m_pFont;
   FX_FLOAT m_fontSize;
   uint32_t m_fillColor;
   uint32_t m_strokeColor;
   int m_blendType;
   int m_commandIndex;  // active position in clip command stack
-#ifdef _SKIA_SUPPORT_
   bool m_drawText;
-#endif
   bool m_drawPath;
   bool m_fillPath;
   bool m_debugDisable;  // turn off cache for debugging
 };
 
 // convert a stroking path to scanlines
 void CFX_SkiaDeviceDriver::PaintStroke(SkPaint* spaint,
                                        const CFX_GraphStateData* pGraphState,
                                        const SkMatrix& matrix) {
   SkPaint::Cap cap;
@@ skipping 58 matching lines @@
 }
 
 CFX_SkiaDeviceDriver::CFX_SkiaDeviceDriver(CFX_DIBitmap* pBitmap,
                                            bool bRgbByteOrder,
                                            CFX_DIBitmap* pOriDevice,
                                            bool bGroupKnockout)
     : m_pBitmap(pBitmap),
       m_pOriDevice(pOriDevice),
       m_pRecorder(nullptr),
       m_pCache(new SkiaState),
-#ifndef _SKIA_SUPPORT_
-      m_pClipRgn(nullptr),
-      m_FillFlags(0),
-      m_bRgbByteOrder(bRgbByteOrder),
-#endif
       m_bGroupKnockout(bGroupKnockout) {
   SkBitmap skBitmap;
   SkASSERT(pBitmap->GetBPP() == 8 || pBitmap->GetBPP() == 32);
   SkImageInfo imageInfo = SkImageInfo::Make(
       pBitmap->GetWidth(), pBitmap->GetHeight(),
       pBitmap->GetBPP() == 8 ? kAlpha_8_SkColorType : kN32_SkColorType,
       kOpaque_SkAlphaType);
   skBitmap.installPixels(imageInfo, pBitmap->GetBuffer(), pBitmap->GetPitch(),
-                         nullptr,  // FIXME(caryclark) set color table
+                         nullptr, /* to do : set color table */
                          nullptr, nullptr);
   m_pCanvas = new SkCanvas(skBitmap);
+  if (m_bGroupKnockout)
+    SkDebugf("");  // FIXME(caryclark) suppress 'm_bGroupKnockout is unused'
 }
 
-#ifdef _SKIA_SUPPORT_
 CFX_SkiaDeviceDriver::CFX_SkiaDeviceDriver(int size_x, int size_y)
     : m_pBitmap(nullptr),
       m_pOriDevice(nullptr),
       m_pRecorder(new SkPictureRecorder),
       m_pCache(new SkiaState),
       m_bGroupKnockout(false) {
   m_pRecorder->beginRecording(SkIntToScalar(size_x), SkIntToScalar(size_y));
   m_pCanvas = m_pRecorder->getRecordingCanvas();
 }
 
 CFX_SkiaDeviceDriver::CFX_SkiaDeviceDriver(SkPictureRecorder* recorder)
     : m_pBitmap(nullptr),
       m_pOriDevice(nullptr),
       m_pRecorder(recorder),
       m_pCache(new SkiaState),
       m_bGroupKnockout(false) {
   m_pCanvas = m_pRecorder->getRecordingCanvas();
 }
-#endif
 
 CFX_SkiaDeviceDriver::~CFX_SkiaDeviceDriver() {
   Flush();
   if (!m_pRecorder)
     delete m_pCanvas;
 }
 
 void CFX_SkiaDeviceDriver::Flush() {
   m_pCache->Flush(this);
   m_pCache->FlushCommands(this);
 }
 
 bool CFX_SkiaDeviceDriver::DrawDeviceText(int nChars,
                                           const FXTEXT_CHARPOS* pCharPos,
                                           CFX_Font* pFont,
                                           const CFX_Matrix* pObject2Device,
                                           FX_FLOAT font_size,
                                           uint32_t color) {
-#ifdef _SKIA_SUPPORT_
   if (m_pCache->DrawText(nChars, pCharPos, pFont, pObject2Device, font_size,
                          color, this)) {
     return true;
   }
   sk_sp<SkTypeface> typeface(SkSafeRef(pFont->GetDeviceCache()));
   SkPaint paint;
   paint.setAntiAlias(true);
   paint.setColor(color);
   paint.setTypeface(typeface);
   paint.setTextEncoding(SkPaint::kGlyphID_TextEncoding);
   paint.setHinting(SkPaint::kNo_Hinting);
   paint.setTextSize(font_size);
   paint.setSubpixelText(true);
   m_pCanvas->save();
   SkScalar flip = font_size < 0 ? -1 : 1;
   SkMatrix skMatrix = ToFlippedSkMatrix(*pObject2Device, flip);
   m_pCanvas->concat(skMatrix);
   SkTDArray<SkPoint> positions;
   positions.setCount(nChars);
   SkTDArray<uint16_t> glyphs;
   glyphs.setCount(nChars);
   for (int index = 0; index < nChars; ++index) {
     const FXTEXT_CHARPOS& cp = pCharPos[index];
     positions[index] = {cp.m_OriginX * flip, cp.m_OriginY * flip};
     glyphs[index] = (uint16_t)cp.m_GlyphIndex;
   }
   m_pCanvas->drawPosText(glyphs.begin(), nChars * 2, positions.begin(), paint);
   m_pCanvas->restore();
   return true;
-#else
-  return false;
-#endif
 }
 
 int CFX_SkiaDeviceDriver::GetDeviceCaps(int caps_id) const {
   switch (caps_id) {
     case FXDC_DEVICE_CLASS:
       return FXDC_DISPLAY;
-#ifdef _SKIA_SUPPORT_
     case FXDC_PIXEL_WIDTH:
       return m_pCanvas->imageInfo().width();
     case FXDC_PIXEL_HEIGHT:
       return m_pCanvas->imageInfo().height();
     case FXDC_BITS_PIXEL:
       return 32;
     case FXDC_HORZ_SIZE:
     case FXDC_VERT_SIZE:
       return 0;
     case FXDC_RENDER_CAPS:
       return FXRC_GET_BITS | FXRC_ALPHA_PATH | FXRC_ALPHA_IMAGE |
              FXRC_BLEND_MODE | FXRC_SOFT_CLIP | FXRC_ALPHA_OUTPUT |
              FXRC_FILLSTROKE_PATH | FXRC_SHADING;
-#else
-    case FXDC_PIXEL_WIDTH:
-      return m_pBitmap->GetWidth();
-    case FXDC_PIXEL_HEIGHT:
-      return m_pBitmap->GetHeight();
-    case FXDC_BITS_PIXEL:
-      return m_pBitmap->GetBPP();
-    case FXDC_HORZ_SIZE:
-    case FXDC_VERT_SIZE:
-      return 0;
-    case FXDC_RENDER_CAPS: {
-      int flags = FXRC_GET_BITS | FXRC_ALPHA_PATH | FXRC_ALPHA_IMAGE |
-                  FXRC_BLEND_MODE | FXRC_SOFT_CLIP;
-      if (m_pBitmap->HasAlpha()) {
-        flags |= FXRC_ALPHA_OUTPUT;
-      } else if (m_pBitmap->IsAlphaMask()) {
-        if (m_pBitmap->GetBPP() == 1) {
-          flags |= FXRC_BITMASK_OUTPUT;
-        } else {
-          flags |= FXRC_BYTEMASK_OUTPUT;
-        }
-      }
-      if (m_pBitmap->IsCmykImage()) {
-        flags |= FXRC_CMYK_OUTPUT;
-      }
-      return flags;
-    }
-#endif
   }
   return 0;
 }
 
 void CFX_SkiaDeviceDriver::SaveState() {
-#ifdef _SKIA_SUPPORT_
   if (!m_pCache->ClipSave(this))
     m_pCanvas->save();
-#else
-  std::unique_ptr<CFX_ClipRgn> pClip;
-  if (m_pClipRgn)
-    pClip = pdfium::MakeUnique<CFX_ClipRgn>(*m_pClipRgn);
-  m_StateStack.push_back(std::move(pClip));
-#endif
 }
 
 void CFX_SkiaDeviceDriver::RestoreState(bool bKeepSaved) {
-#ifdef _SKIA_SUPPORT_
   if (!m_pCache->ClipRestore(this))
     m_pCanvas->restore();
   if (bKeepSaved)
     SaveState();
-#else
-  m_pClipRgn.reset();
-
-  if (m_StateStack.empty())
-    return;
-
-  if (bKeepSaved) {
-    if (m_StateStack.back())
-      m_pClipRgn = pdfium::MakeUnique<CFX_ClipRgn>(*m_StateStack.back());
-  } else {
-    m_pClipRgn = std::move(m_StateStack.back());
-    m_StateStack.pop_back();
-  }
-#endif
 }
 
-#ifndef _SKIA_SUPPORT_
-void CFX_SkiaDeviceDriver::SetClipMask(const FX_RECT& clipBox,
-                                       const SkPath& path) {
-  FX_RECT path_rect(clipBox.left, clipBox.top, clipBox.right + 1,
-                    clipBox.bottom + 1);
-  path_rect.Intersect(m_pClipRgn->GetBox());
-  CFX_DIBitmapRef mask;
-  CFX_DIBitmap* pThisLayer = mask.Emplace();
-  pThisLayer->Create(path_rect.Width(), path_rect.Height(), FXDIB_8bppMask);
-  pThisLayer->Clear(0);
-
-  SkImageInfo imageInfo =
-      SkImageInfo::Make(pThisLayer->GetWidth(), pThisLayer->GetHeight(),
-                        SkColorType::kAlpha_8_SkColorType, kOpaque_SkAlphaType);
-  SkBitmap bitmap;
-  bitmap.installPixels(imageInfo, pThisLayer->GetBuffer(),
-                       pThisLayer->GetPitch(), nullptr, nullptr, nullptr);
-  SkCanvas* canvas = new SkCanvas(bitmap);
-  canvas->translate(
-      clipBox.left,
-      clipBox.top);  // FIXME(caryclark) wrong sign(s)? upside down?
-  SkPaint paint;
-  paint.setAntiAlias((m_FillFlags & FXFILL_NOPATHSMOOTH) == 0);
-  canvas->drawPath(path, paint);
-  std::unique_ptr<uint8_t, FxFreeDeleter> raw_buf;
-  raw_buf.reset(
-      FX_Alloc2D(uint8_t, pThisLayer->GetWidth(), pThisLayer->GetHeight()));
-  m_pClipRgn->IntersectMaskF(path_rect.left, path_rect.top, mask);
-  delete canvas;
-}
-#endif
-
 bool CFX_SkiaDeviceDriver::SetClip_PathFill(
     const CFX_PathData* pPathData,     // path info
     const CFX_Matrix* pObject2Device,  // flips object's y-axis
     int fill_mode                      // fill mode, WINDING or ALTERNATE
     ) {
   CFX_Matrix identity;
   const CFX_Matrix* deviceMatrix = pObject2Device ? pObject2Device : &identity;
-#ifdef _SKIA_SUPPORT_
   if (m_pCache->SetClipFill(pPathData, deviceMatrix, fill_mode, this))
     return true;
-#else
-  m_FillFlags = fill_mode;
-  if (!m_pClipRgn) {
-    m_pClipRgn = pdfium::MakeUnique<CFX_ClipRgn>(
-        GetDeviceCaps(FXDC_PIXEL_WIDTH), GetDeviceCaps(FXDC_PIXEL_HEIGHT));
-  }
-#endif
   if (pPathData->GetPointCount() == 5 || pPathData->GetPointCount() == 4) {
     CFX_FloatRect rectf;
     if (pPathData->IsRect(deviceMatrix, &rectf)) {
       rectf.Intersect(
           CFX_FloatRect(0, 0, (FX_FLOAT)GetDeviceCaps(FXDC_PIXEL_WIDTH),
                         (FX_FLOAT)GetDeviceCaps(FXDC_PIXEL_HEIGHT)));
-#ifdef _SKIA_SUPPORT_
       // note that PDF's y-axis goes up; Skia's y-axis goes down
       SkRect skClipRect =
           SkRect::MakeLTRB(rectf.left, rectf.bottom, rectf.right, rectf.top);
       DebugDrawSkiaClipRect(m_pCanvas, skClipRect);
       m_pCanvas->clipRect(skClipRect, SkCanvas::kIntersect_Op, true);
-#else
-      FX_RECT rect = rectf.GetOuterRect();
-      m_pClipRgn->IntersectRect(rect);
-#endif
       return true;
     }
   }
   SkPath skClipPath = BuildPath(pPathData);
   skClipPath.setFillType((fill_mode & 3) == FXFILL_ALTERNATE
                              ? SkPath::kEvenOdd_FillType
                              : SkPath::kWinding_FillType);
   SkMatrix skMatrix = ToSkMatrix(*deviceMatrix);
   skClipPath.transform(skMatrix);
   DebugShowSkiaPath(skClipPath);
   DebugDrawSkiaClipPath(m_pCanvas, skClipPath);
   m_pCanvas->clipPath(skClipPath, SkCanvas::kIntersect_Op, true);
-#ifndef _SKIA_SUPPORT_
-  FX_RECT clipBox(0, 0, GetDeviceCaps(FXDC_PIXEL_WIDTH),
-                  GetDeviceCaps(FXDC_PIXEL_HEIGHT));
-  SetClipMask(clipBox, skClipPath);
-#endif
+
   return true;
 }
 
 bool CFX_SkiaDeviceDriver::SetClip_PathStroke(
     const CFX_PathData* pPathData,         // path info
     const CFX_Matrix* pObject2Device,      // optional transformation
     const CFX_GraphStateData* pGraphState  // graphic state, for pen attributes
     ) {
-#ifdef _SKIA_SUPPORT_
   if (m_pCache->SetClipStroke(pPathData, pObject2Device, pGraphState, this))
     return true;
-#else
-  if (!m_pClipRgn) {
-    m_pClipRgn = pdfium::MakeUnique<CFX_ClipRgn>(
-        GetDeviceCaps(FXDC_PIXEL_WIDTH), GetDeviceCaps(FXDC_PIXEL_HEIGHT));
-  }
-#endif
   // build path data
   SkPath skPath = BuildPath(pPathData);
   SkMatrix skMatrix = ToSkMatrix(*pObject2Device);
   SkPaint skPaint;
   PaintStroke(&skPaint, pGraphState, skMatrix);
   SkPath dst_path;
   skPaint.getFillPath(skPath, &dst_path);
   dst_path.transform(skMatrix);
   DebugDrawSkiaClipPath(m_pCanvas, dst_path);
-#ifdef _SKIA_SUPPORT_
   m_pCanvas->clipPath(dst_path, SkCanvas::kIntersect_Op, true);
-#else
-  FX_RECT clipBox(0, 0, GetDeviceCaps(FXDC_PIXEL_WIDTH),
-                  GetDeviceCaps(FXDC_PIXEL_HEIGHT));
-  SetClipMask(clipBox, dst_path);
-#endif
   return true;
 }
 
 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 blend_type) {
   if (m_pCache->DrawPath(pPathData, pObject2Device, pGraphState, fill_color,
                          stroke_color, fill_mode, blend_type, this)) {
     return true;
   }
   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);
-  if (fill_mode & FXFILL_FULLCOVER)
-    skPaint.setBlendMode(SkBlendMode::kPlus);
   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_ALTERNATE
                            ? SkPath::kEvenOdd_FillType
                            : SkPath::kWinding_FillType);
     SkPath strokePath;
     const SkPath* fillPath = &skPath;
     if (pGraphState && stroke_alpha) {
-      if (m_bGroupKnockout) {
+      SkAlpha fillA = SkColorGetA(fill_color);
+      SkAlpha strokeA = SkColorGetA(stroke_color);
+      if (fillA && fillA < 0xFF && strokeA && strokeA < 0xFF) {
         skPaint.getFillPath(skPath, &strokePath);
         if (Op(skPath, strokePath, SkPathOp::kDifference_SkPathOp,
                &strokePath)) {
           fillPath = &strokePath;
         }
       }
     }
     skPaint.setStyle(SkPaint::kFill_Style);
     skPaint.setColor(fill_color);
     m_pCanvas->drawPath(*fillPath, skPaint);
@@ skipping 25 matching lines @@
   spaint.setAntiAlias(true);
   spaint.setColor(fill_color);
   spaint.setBlendMode(GetSkiaBlendMode(blend_type));
 
   m_pCanvas->drawRect(
       SkRect::MakeLTRB(pRect->left, pRect->top, pRect->right, pRect->bottom),
       spaint);
   return true;
 }
 
-#ifdef _SKIA_SUPPORT_
 bool CFX_SkiaDeviceDriver::DrawShading(const CPDF_ShadingPattern* pPattern,
                                        const CFX_Matrix* pMatrix,
                                        const FX_RECT& clip_rect,
                                        int alpha,
                                        bool bAlphaMode) {
   if (kAxialShading != pPattern->GetShadingType() &&
       kRadialShading != pPattern->GetShadingType()) {
     // TODO(caryclark) more types
     return false;
   }
@@ skipping 113 matching lines @@
     skPath.transform(inverse);
   }
   m_pCanvas->save();
   if (!skClip.isEmpty())
     m_pCanvas->clipPath(skClip, SkCanvas::kIntersect_Op, true);
   m_pCanvas->concat(skMatrix);
   m_pCanvas->drawPath(skPath, paint);
   m_pCanvas->restore();
   return true;
 }
-#endif
 
 uint8_t* CFX_SkiaDeviceDriver::GetBuffer() const {
   return m_pBitmap->GetBuffer();
 }
 
 bool CFX_SkiaDeviceDriver::GetClipBox(FX_RECT* pRect) {
   // TODO(caryclark) call m_canvas->getClipDeviceBounds() instead
   pRect->left = 0;
   pRect->top = 0;
   const SkImageInfo& canvasSize = m_pCanvas->imageInfo();
   pRect->right = canvasSize.width();
   pRect->bottom = canvasSize.height();
   return true;
 }
 
 bool CFX_SkiaDeviceDriver::GetDIBits(CFX_DIBitmap* pBitmap, int left, int top) {
   if (!m_pBitmap)
     return true;
   uint8_t* srcBuffer = m_pBitmap->GetBuffer();
   if (!srcBuffer)
     return true;
-#ifdef _SKIA_SUPPORT_
   int srcWidth = m_pBitmap->GetWidth();
   int srcHeight = m_pBitmap->GetHeight();
   int srcRowBytes = srcWidth * sizeof(uint32_t);
   SkImageInfo srcImageInfo = SkImageInfo::Make(
       srcWidth, srcHeight, SkColorType::kN32_SkColorType, kPremul_SkAlphaType);
   SkBitmap skSrcBitmap;
   skSrcBitmap.installPixels(srcImageInfo, srcBuffer, srcRowBytes, nullptr,
                             nullptr, nullptr);
   SkASSERT(pBitmap);
   uint8_t* dstBuffer = pBitmap->GetBuffer();
   SkASSERT(dstBuffer);
   int dstWidth = pBitmap->GetWidth();
   int dstHeight = pBitmap->GetHeight();
   int dstRowBytes = dstWidth * sizeof(uint32_t);
   SkImageInfo dstImageInfo = SkImageInfo::Make(
       dstWidth, dstHeight, SkColorType::kN32_SkColorType, kPremul_SkAlphaType);
   SkBitmap skDstBitmap;
   skDstBitmap.installPixels(dstImageInfo, dstBuffer, dstRowBytes, nullptr,
                             nullptr, nullptr);
   SkCanvas canvas(skDstBitmap);
   canvas.drawBitmap(skSrcBitmap, left, top, nullptr);
   return true;
-#else
-  FX_RECT rect(left, top, left + pBitmap->GetWidth(),
-               top + pBitmap->GetHeight());
-  CFX_DIBitmap* pBack = nullptr;
-  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;
-  }
-
-  bool bRet = true;
-  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);
-  }
-  delete pBack;
-  return bRet;
-#endif
 }
 
 CFX_DIBitmap* CFX_SkiaDeviceDriver::GetBackDrop() {
   return m_pOriDevice;
 }
 
 bool CFX_SkiaDeviceDriver::SetDIBits(const CFX_DIBSource* pBitmap,
                                      uint32_t argb,
                                      const FX_RECT* pSrcRect,
                                      int left,
                                      int top,
                                      int blend_type) {
   if (!m_pBitmap || !m_pBitmap->GetBuffer())
     return true;
 
-#ifdef _SKIA_SUPPORT_
   CFX_Matrix m(pBitmap->GetWidth(), 0, 0, -pBitmap->GetHeight(), left,
                top + pBitmap->GetHeight());
   void* dummy;
   return StartDIBits(pBitmap, 0xFF, argb, &m, 0, dummy, blend_type);
-#else
-  if (pBitmap->IsAlphaMask()) {
-    return m_pBitmap->CompositeMask(
-        left, top, pSrcRect->Width(), pSrcRect->Height(), pBitmap, argb,
-        pSrcRect->left, pSrcRect->top, blend_type, m_pClipRgn.get(),
-        m_bRgbByteOrder, 0, nullptr);
-  }
-  return m_pBitmap->CompositeBitmap(
-      left, top, pSrcRect->Width(), pSrcRect->Height(), pBitmap, pSrcRect->left,
-      pSrcRect->top, blend_type, m_pClipRgn.get(), m_bRgbByteOrder, nullptr);
-#endif
 }
 
 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 blend_type) {
-#ifdef _SKIA_SUPPORT_
   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, SkCanvas::kIntersect_Op, true);
   void* dummy;
   bool result = StartDIBits(pSource, 0xFF, argb, &m, 0, dummy, blend_type);
   m_pCanvas->restore();
 
   return result;
-#else
-  if (dest_width == pSource->GetWidth() &&
-      dest_height == pSource->GetHeight()) {
-    FX_RECT rect(0, 0, dest_width, dest_height);
-    return SetDIBits(pSource, argb, &rect, dest_left, dest_top, blend_type);
-  }
-  FX_RECT dest_rect(dest_left, dest_top, dest_left + dest_width,
-                    dest_top + dest_height);
-  dest_rect.Normalize();
-  FX_RECT dest_clip = dest_rect;
-  dest_clip.Intersect(*pClipRect);
-  CFX_BitmapComposer composer;
-  composer.Compose(m_pBitmap, m_pClipRgn.get(), 255, argb, dest_clip, false,
-                   false, false, m_bRgbByteOrder, 0, nullptr, blend_type);
-  dest_clip.Offset(-dest_rect.left, -dest_rect.top);
-  CFX_ImageStretcher stretcher(&composer, pSource, dest_width, dest_height,
-                               dest_clip, flags);
-  if (stretcher.Start())
-    stretcher.Continue(nullptr);
-  return true;
-#endif
 }
 
 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 blend_type) {
-#ifdef _SKIA_SUPPORT_
   DebugValidate(m_pBitmap, m_pOriDevice);
   SkColorTable* ct = nullptr;
   std::unique_ptr<uint8_t, FxFreeDeleter> dst8Storage;
   std::unique_ptr<uint32_t, FxFreeDeleter> dst32Storage;
   SkBitmap skBitmap;
   int width, height;
   if (!Upsample(pSource, dst8Storage, dst32Storage, &ct, &skBitmap, &width,
                 &height, false)) {
     return false;
   }
@@ skipping 18 matching lines @@
         m_pBitmap->SetPixel(x, y, skBitmap.getColor(src.fX, src.fY));
       }
     }
   } else {
     m_pCanvas->drawBitmap(skBitmap, 0, 0, &paint);
   }
   m_pCanvas->restore();
   if (ct)
     ct->unref();
   DebugValidate(m_pBitmap, m_pOriDevice);
-#else
-  if (!m_pBitmap->GetBuffer())
-    return true;
-
-  CFX_ImageRenderer* pRenderer = new CFX_ImageRenderer;
-  pRenderer->Start(m_pBitmap, m_pClipRgn.get(), pSource, bitmap_alpha, argb,
-                   pMatrix, render_flags, m_bRgbByteOrder, 0, nullptr);
-  handle = pRenderer;
-#endif
   return true;
 }
 
 bool CFX_SkiaDeviceDriver::ContinueDIBits(void* handle, IFX_Pause* pPause) {
-#ifdef _SKIA_SUPPORT_
   return false;
-#else
-  if (!m_pBitmap->GetBuffer()) {
-    return true;
-  }
-  return static_cast<CFX_ImageRenderer*>(handle)->Continue(pPause);
-#endif
 }
 
-#ifdef _SKIA_SUPPORT_
 void CFX_SkiaDeviceDriver::PreMultiply(CFX_DIBitmap* pDIBitmap) {
   void* buffer = pDIBitmap->GetBuffer();
   if (!buffer)
     return;
   if (pDIBitmap->GetBPP() != 32) {
     return;
   }
   int height = pDIBitmap->GetHeight();
   int width = pDIBitmap->GetWidth();
   int rowBytes = pDIBitmap->GetPitch();
@@ skipping 60 matching lines @@
   if (!m_pBitmap || !m_pBitmap->GetBuffer())
     return true;
   CFX_Matrix m(pBitmap->GetWidth(), 0, 0, -pBitmap->GetHeight(), dest_left,
                dest_top + pBitmap->GetHeight());
   return DrawBitsWithMask(pBitmap, pMask, bitmap_alpha, &m, blend_type);
 }
 
 void CFX_SkiaDeviceDriver::Clear(uint32_t color) {
   m_pCanvas->clear(color);
 }
-#endif
 
 void CFX_SkiaDeviceDriver::Dump() const {
 #ifdef SK_DEBUG
   if (m_pCache)
     m_pCache->Dump(this);
 #endif
 }
 
-#ifdef _SKIA_SUPPORT_
 void CFX_SkiaDeviceDriver::DebugVerifyBitmapIsPreMultiplied() const {
   if (m_pOriDevice)
     m_pOriDevice->DebugVerifyBitmapIsPreMultiplied();
 }
-#endif
 
 CFX_FxgeDevice::CFX_FxgeDevice() {
-#ifdef _SKIA_SUPPORT_
   m_bOwnedBitmap = false;
-#endif
 }
 
-#ifdef _SKIA_SUPPORT_
 void CFX_FxgeDevice::Clear(uint32_t color) {
   CFX_SkiaDeviceDriver* skDriver =
       static_cast<CFX_SkiaDeviceDriver*>(GetDeviceDriver());
   skDriver->Clear(color);
 }
 
 SkPictureRecorder* CFX_FxgeDevice::CreateRecorder(int size_x, int size_y) {
   CFX_SkiaDeviceDriver* skDriver = new CFX_SkiaDeviceDriver(size_x, size_y);
   SetDeviceDriver(pdfium::WrapUnique(skDriver));
   return skDriver->GetRecorder();
 }
-#endif
 
 bool CFX_FxgeDevice::Attach(CFX_DIBitmap* pBitmap,
                             bool bRgbByteOrder,
                             CFX_DIBitmap* pOriDevice,
                             bool bGroupKnockout) {
   if (!pBitmap)
     return false;
   SetBitmap(pBitmap);
   SetDeviceDriver(pdfium::MakeUnique<CFX_SkiaDeviceDriver>(
       pBitmap, bRgbByteOrder, pOriDevice, bGroupKnockout));
   return true;
 }
 
-#ifdef _SKIA_SUPPORT_
 bool CFX_FxgeDevice::AttachRecorder(SkPictureRecorder* recorder) {
   if (!recorder)
     return false;
   SetDeviceDriver(pdfium::MakeUnique<CFX_SkiaDeviceDriver>(recorder));
   return true;
 }
-#endif
 
 bool CFX_FxgeDevice::Create(int width,
                             int height,
                             FXDIB_Format format,
                             CFX_DIBitmap* pOriDevice) {
   m_bOwnedBitmap = true;
   CFX_DIBitmap* pBitmap = new CFX_DIBitmap;
   if (!pBitmap->Create(width, height, format)) {
     delete pBitmap;
     return false;
   }
   SetBitmap(pBitmap);
   SetDeviceDriver(pdfium::MakeUnique<CFX_SkiaDeviceDriver>(pBitmap, false,
                                                            pOriDevice, false));
   return true;
 }
 
 CFX_FxgeDevice::~CFX_FxgeDevice() {
-#ifdef _SKIA_SUPPORT_
   Flush();
   // call destructor of CFX_RenderDevice / CFX_SkiaDeviceDriver immediately
   if (m_bOwnedBitmap && GetBitmap())
     delete GetBitmap();
-#endif
 }
 
-#ifdef _SKIA_SUPPORT_
 void CFX_FxgeDevice::DebugVerifyBitmapIsPreMultiplied() const {
 #ifdef SK_DEBUG
   CFX_SkiaDeviceDriver* skDriver =
       static_cast<CFX_SkiaDeviceDriver*>(GetDeviceDriver());
   if (skDriver)
     skDriver->DebugVerifyBitmapIsPreMultiplied();
 #endif
 }
 
 bool CFX_FxgeDevice::SetBitsWithMask(const CFX_DIBSource* pBitmap,
@@ skipping 25 matching lines @@
       uint8_t g = SkGetPackedG32(srcRow[x]);
       uint8_t b = SkGetPackedB32(srcRow[x]);
       SkA32Assert(a);
       SkASSERT(r <= a);
       SkASSERT(g <= a);
       SkASSERT(b <= a);
     }
   }
 #endif
 }
-#endif
-
-#ifndef _SKIA_SUPPORT_
-class CFX_Renderer {
- private:
-  int m_Alpha, m_Red, m_Green, m_Blue, m_Gray;
-  uint32_t m_Color;
-  bool m_bFullCover;
-  bool m_bRgbByteOrder;
-  CFX_DIBitmap* m_pOriDevice;
-  FX_RECT m_ClipBox;
-  const CFX_DIBitmap* m_pClipMask;
-  CFX_DIBitmap* m_pDevice;
-  const CFX_ClipRgn* m_pClipRgn;
-  void (CFX_Renderer::*composite_span)(uint8_t*,
-                                       int,
-                                       int,
-                                       int,
-                                       uint8_t*,
-                                       int,
-                                       int,
-                                       uint8_t*,
-                                       uint8_t*);
-
- public:
-  void prepare(unsigned) {}
-
-  void CompositeSpan(uint8_t* dest_scan,
-                     uint8_t* ori_scan,
-                     int Bpp,
-                     bool bDestAlpha,
-                     int span_left,
-                     int span_len,
-                     uint8_t* cover_scan,
-                     int clip_left,
-                     int clip_right,
-                     uint8_t* clip_scan) {
-    ASSERT(!m_pDevice->IsCmykImage());
-    int col_start = span_left < clip_left ? clip_left - span_left : 0;
-    int col_end = (span_left + span_len) < clip_right
-                      ? span_len
-                      : (clip_right - span_left);
-    if (Bpp) {
-      dest_scan += col_start * Bpp;
-      ori_scan += col_start * Bpp;
-    } else {
-      dest_scan += col_start / 8;
-      ori_scan += col_start / 8;
-    }
-    if (m_bRgbByteOrder) {
-      if (Bpp == 4 && bDestAlpha) {
-        for (int col = col_start; col < col_end; col++) {
-          int src_alpha;
-          if (clip_scan) {
-            src_alpha = m_Alpha * clip_scan[col] / 255;
-          } else {
-            src_alpha = m_Alpha;
-          }
-          uint8_t dest_alpha =
-              ori_scan[3] + src_alpha - ori_scan[3] * src_alpha / 255;
-          dest_scan[3] = dest_alpha;
-          int alpha_ratio = src_alpha * 255 / dest_alpha;
-          if (m_bFullCover) {
-            *dest_scan++ = FXDIB_ALPHA_MERGE(*ori_scan++, m_Red, alpha_ratio);
-            *dest_scan++ = FXDIB_ALPHA_MERGE(*ori_scan++, m_Green, alpha_ratio);
-            *dest_scan++ = FXDIB_ALPHA_MERGE(*ori_scan++, m_Blue, alpha_ratio);
-            dest_scan++;
-            ori_scan++;
-          } else {
-            int r = FXDIB_ALPHA_MERGE(*ori_scan++, m_Red, alpha_ratio);
-            int g = FXDIB_ALPHA_MERGE(*ori_scan++, m_Green, alpha_ratio);
-            int b = FXDIB_ALPHA_MERGE(*ori_scan++, m_Blue, alpha_ratio);
-            ori_scan++;
-            *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, r, cover_scan[col]);
-            dest_scan++;
-            *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, g, cover_scan[col]);
-            dest_scan++;
-            *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, b, cover_scan[col]);
-            dest_scan += 2;
-          }
-        }
-        return;
-      }
-      if (Bpp == 3 || Bpp == 4) {
-        for (int col = col_start; col < col_end; col++) {
-          int src_alpha;
-          if (clip_scan) {
-            src_alpha = m_Alpha * clip_scan[col] / 255;
-          } else {
-            src_alpha = m_Alpha;
-          }
-          int r = FXDIB_ALPHA_MERGE(*ori_scan++, m_Red, src_alpha);
-          int g = FXDIB_ALPHA_MERGE(*ori_scan++, m_Green, src_alpha);
-          int b = FXDIB_ALPHA_MERGE(*ori_scan, m_Blue, src_alpha);
-          ori_scan += Bpp - 2;
-          *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, r, cover_scan[col]);
-          dest_scan++;
-          *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, g, cover_scan[col]);
-          dest_scan++;
-          *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, b, cover_scan[col]);
-          dest_scan += Bpp - 2;
-        }
-      }
-      return;
-    }
-    if (Bpp == 4 && bDestAlpha) {
-      for (int col = col_start; col < col_end; col++) {
-        int src_alpha;
-        if (clip_scan) {
-          src_alpha = m_Alpha * clip_scan[col] / 255;
-        } else {
-          src_alpha = m_Alpha;
-        }
-        int src_alpha_covered = src_alpha * cover_scan[col] / 255;
-        if (src_alpha_covered == 0) {
-          dest_scan += 4;
-          continue;
-        }
-        if (cover_scan[col] == 255) {
-          dest_scan[3] = src_alpha_covered;
-          *dest_scan++ = m_Blue;
-          *dest_scan++ = m_Green;
-          *dest_scan = m_Red;
-          dest_scan += 2;
-          continue;
-        } else {
-          if (dest_scan[3] == 0) {
-            dest_scan[3] = src_alpha_covered;
-            *dest_scan++ = m_Blue;
-            *dest_scan++ = m_Green;
-            *dest_scan = m_Red;
-            dest_scan += 2;
-            continue;
-          }
-          uint8_t cover = cover_scan[col];
-          dest_scan[3] = FXDIB_ALPHA_MERGE(dest_scan[3], src_alpha, cover);
-          *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, cover);
-          dest_scan++;
-          *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, cover);
-          dest_scan++;
-          *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, cover);
-          dest_scan += 2;
-        }
-      }
-      return;
-    }
-    if (Bpp == 3 || Bpp == 4) {
-      for (int col = col_start; col < col_end; col++) {
-        int src_alpha;
-        if (clip_scan) {
-          src_alpha = m_Alpha * clip_scan[col] / 255;
-        } else {
-          src_alpha = m_Alpha;
-        }
-        if (m_bFullCover) {
-          *dest_scan++ = FXDIB_ALPHA_MERGE(*ori_scan++, m_Blue, src_alpha);
-          *dest_scan++ = FXDIB_ALPHA_MERGE(*ori_scan++, m_Green, src_alpha);
-          *dest_scan = FXDIB_ALPHA_MERGE(*ori_scan, m_Red, src_alpha);
-          dest_scan += Bpp - 2;
-          ori_scan += Bpp - 2;
-          continue;
-        }
-        int b = FXDIB_ALPHA_MERGE(*ori_scan++, m_Blue, src_alpha);
-        int g = FXDIB_ALPHA_MERGE(*ori_scan++, m_Green, src_alpha);
-        int r = FXDIB_ALPHA_MERGE(*ori_scan, m_Red, src_alpha);
-        ori_scan += Bpp - 2;
-        *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, b, cover_scan[col]);
-        dest_scan++;
-        *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, g, cover_scan[col]);
-        dest_scan++;
-        *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, r, cover_scan[col]);
-        dest_scan += Bpp - 2;
-        continue;
-      }
-      return;
-    }
-    if (Bpp == 1) {
-      for (int col = col_start; col < col_end; col++) {
-        int src_alpha;
-        if (clip_scan) {
-          src_alpha = m_Alpha * clip_scan[col] / 255;
-        } else {
-          src_alpha = m_Alpha;
-        }
-        if (m_bFullCover) {
-          *dest_scan = FXDIB_ALPHA_MERGE(*ori_scan++, m_Gray, src_alpha);
-        } else {
-          int gray = FXDIB_ALPHA_MERGE(*ori_scan++, m_Gray, src_alpha);
-          *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, cover_scan[col]);
-          dest_scan++;
-        }
-      }
-    } else {
-      int index = 0;
-      if (m_pDevice->GetPalette()) {
-        for (int i = 0; i < 2; i++) {
-          if (FXARGB_TODIB(m_pDevice->GetPalette()[i]) == m_Color) {
-            index = i;
-          }
-        }
-      } else {
-        index = ((uint8_t)m_Color == 0xff) ? 1 : 0;
-      }
-      uint8_t* dest_scan1 = dest_scan;
-      for (int col = col_start; col < col_end; col++) {
-        int src_alpha;
-        if (clip_scan) {
-          src_alpha = m_Alpha * cover_scan[col] * clip_scan[col] / 255 / 255;
-        } else {
-          src_alpha = m_Alpha * cover_scan[col] / 255;
-        }
-        if (src_alpha) {
-          if (!index) {
-            *dest_scan1 &= ~(1 << (7 - (col + span_left) % 8));
-          } else {
-            *dest_scan1 |= 1 << (7 - (col + span_left) % 8);
-          }
-        }
-        dest_scan1 = dest_scan + (span_left % 8 + col - col_start + 1) / 8;
-      }
-    }
-  }
-
-  void CompositeSpan1bpp(uint8_t* dest_scan,
-                         int Bpp,
-                         int span_left,
-                         int span_len,
-                         uint8_t* cover_scan,
-                         int clip_left,
-                         int clip_right,
-                         uint8_t* clip_scan,
-                         uint8_t* dest_extra_alpha_scan) {
-    ASSERT(!m_bRgbByteOrder);
-    ASSERT(!m_pDevice->IsCmykImage());
-    int col_start = span_left < clip_left ? clip_left - span_left : 0;
-    int col_end = (span_left + span_len) < clip_right
-                      ? span_len
-                      : (clip_right - span_left);
-    dest_scan += col_start / 8;
-    int index = 0;
-    if (m_pDevice->GetPalette()) {
-      for (int i = 0; i < 2; i++) {
-        if (FXARGB_TODIB(m_pDevice->GetPalette()[i]) == m_Color) {
-          index = i;
-        }
-      }
-    } else {
-      index = ((uint8_t)m_Color == 0xff) ? 1 : 0;
-    }
-    uint8_t* dest_scan1 = dest_scan;
-    for (int col = col_start; col < col_end; col++) {
-      int src_alpha;
-      if (clip_scan) {
-        src_alpha = m_Alpha * cover_scan[col] * clip_scan[col] / 255 / 255;
-      } else {
-        src_alpha = m_Alpha * cover_scan[col] / 255;
-      }
-      if (src_alpha) {
-        if (!index) {
-          *dest_scan1 &= ~(1 << (7 - (col + span_left) % 8));
-        } else {
-          *dest_scan1 |= 1 << (7 - (col + span_left) % 8);
-        }
-      }
-      dest_scan1 = dest_scan + (span_left % 8 + col - col_start + 1) / 8;
-    }
-  }
-
-  void CompositeSpanGray(uint8_t* dest_scan,
-                         int Bpp,
-                         int span_left,
-                         int span_len,
-                         uint8_t* cover_scan,
-                         int clip_left,
-                         int clip_right,
-                         uint8_t* clip_scan,
-                         uint8_t* dest_extra_alpha_scan) {
-    ASSERT(!m_bRgbByteOrder);
-    int col_start = span_left < clip_left ? clip_left - span_left : 0;
-    int col_end = (span_left + span_len) < clip_right
-                      ? span_len
-                      : (clip_right - span_left);
-    dest_scan += col_start;
-    if (dest_extra_alpha_scan) {
-      for (int col = col_start; col < col_end; col++) {
-        int src_alpha;
-        if (m_bFullCover) {
-          if (clip_scan) {
-            src_alpha = m_Alpha * clip_scan[col] / 255;
-          } else {
-            src_alpha = m_Alpha;
-          }
-        } else {
-          if (clip_scan) {
-            src_alpha = m_Alpha * cover_scan[col] * clip_scan[col] / 255 / 255;
-          } else {
-            src_alpha = m_Alpha * cover_scan[col] / 255;
-          }
-        }
-        if (src_alpha) {
-          if (src_alpha == 255) {
-            *dest_scan = m_Gray;
-            *dest_extra_alpha_scan = m_Alpha;
-          } else {
-            uint8_t dest_alpha = (*dest_extra_alpha_scan) + src_alpha -
-                                 (*dest_extra_alpha_scan) * src_alpha / 255;
-            *dest_extra_alpha_scan++ = dest_alpha;
-            int alpha_ratio = src_alpha * 255 / dest_alpha;
-            *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Gray, alpha_ratio);
-            dest_scan++;
-            continue;
-          }
-        }
-        dest_extra_alpha_scan++;
-        dest_scan++;
-      }
-    } else {
-      for (int col = col_start; col < col_end; col++) {
-        int src_alpha;
-        if (clip_scan) {
-          src_alpha = m_Alpha * cover_scan[col] * clip_scan[col] / 255 / 255;
-        } else {
-          src_alpha = m_Alpha * cover_scan[col] / 255;
-        }
-        if (src_alpha) {
-          if (src_alpha == 255) {
-            *dest_scan = m_Gray;
-          } else {
-            *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Gray, src_alpha);
-          }
-        }
-        dest_scan++;
-      }
-    }
-  }
-
-  void CompositeSpanARGB(uint8_t* dest_scan,
-                         int Bpp,
-                         int span_left,
-                         int span_len,
-                         uint8_t* cover_scan,
-                         int clip_left,
-                         int clip_right,
-                         uint8_t* clip_scan,
-                         uint8_t* dest_extra_alpha_scan) {
-    int col_start = span_left < clip_left ? clip_left - span_left : 0;
-    int col_end = (span_left + span_len) < clip_right
-                      ? span_len
-                      : (clip_right - span_left);
-    dest_scan += col_start * Bpp;
-    if (m_bRgbByteOrder) {
-      for (int col = col_start; col < col_end; col++) {
-        int src_alpha;
-        if (m_bFullCover) {
-          if (clip_scan) {
-            src_alpha = m_Alpha * clip_scan[col] / 255;
-          } else {
-            src_alpha = m_Alpha;
-          }
-        } else {
-          if (clip_scan) {
-            src_alpha = m_Alpha * cover_scan[col] * clip_scan[col] / 255 / 255;
-          } else {
-            src_alpha = m_Alpha * cover_scan[col] / 255;
-          }
-        }
-        if (src_alpha) {
-          if (src_alpha == 255) {
-            *(uint32_t*)dest_scan = m_Color;
-          } else {
-            uint8_t dest_alpha =
-                dest_scan[3] + src_alpha - dest_scan[3] * src_alpha / 255;
-            dest_scan[3] = dest_alpha;
-            int alpha_ratio = src_alpha * 255 / dest_alpha;
-            *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, alpha_ratio);
-            dest_scan++;
-            *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, alpha_ratio);
-            dest_scan++;
-            *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, alpha_ratio);
-            dest_scan += 2;
-            continue;
-          }
-        }
-        dest_scan += 4;
-      }
-      return;
-    }
-    for (int col = col_start; col < col_end; col++) {
-      int src_alpha;
-      if (m_bFullCover) {
-        if (clip_scan) {
-          src_alpha = m_Alpha * clip_scan[col] / 255;
-        } else {
-          src_alpha = m_Alpha;
-        }
-      } else {
-        if (clip_scan) {
-          src_alpha = m_Alpha * cover_scan[col] * clip_scan[col] / 255 / 255;
-        } else {
-          src_alpha = m_Alpha * cover_scan[col] / 255;
-        }
-      }
-      if (src_alpha) {
-        if (src_alpha == 255) {
-          *(uint32_t*)dest_scan = m_Color;
-        } else {
-          if (dest_scan[3] == 0) {
-            dest_scan[3] = src_alpha;
-            *dest_scan++ = m_Blue;
-            *dest_scan++ = m_Green;
-            *dest_scan = m_Red;
-            dest_scan += 2;
-            continue;
-          }
-          uint8_t dest_alpha =
-              dest_scan[3] + src_alpha - dest_scan[3] * src_alpha / 255;
-          dest_scan[3] = dest_alpha;
-          int alpha_ratio = src_alpha * 255 / dest_alpha;
-          *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, alpha_ratio);
-          dest_scan++;
-          *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, alpha_ratio);
-          dest_scan++;
-          *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, alpha_ratio);
-          dest_scan += 2;
-          continue;
-        }
-      }
-      dest_scan += Bpp;
-    }
-  }
-
-  void CompositeSpanRGB(uint8_t* dest_scan,
-                        int Bpp,
-                        int span_left,
-                        int span_len,
-                        uint8_t* cover_scan,
-                        int clip_left,
-                        int clip_right,
-                        uint8_t* clip_scan,
-                        uint8_t* dest_extra_alpha_scan) {
-    int col_start = span_left < clip_left ? clip_left - span_left : 0;
-    int col_end = (span_left + span_len) < clip_right
-                      ? span_len
-                      : (clip_right - span_left);
-    dest_scan += col_start * Bpp;
-    if (m_bRgbByteOrder) {
-      for (int col = col_start; col < col_end; col++) {
-        int src_alpha;
-        if (clip_scan) {
-          src_alpha = m_Alpha * cover_scan[col] * clip_scan[col] / 255 / 255;
-        } else {
-          src_alpha = m_Alpha * cover_scan[col] / 255;
-        }
-        if (src_alpha) {
-          if (src_alpha == 255) {
-            if (Bpp == 4) {
-              *(uint32_t*)dest_scan = m_Color;
-            } else if (Bpp == 3) {
-              *dest_scan++ = m_Red;
-              *dest_scan++ = m_Green;
-              *dest_scan++ = m_Blue;
-              continue;
-            }
-          } else {
-            *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, src_alpha);
-            dest_scan++;
-            *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, src_alpha);
-            dest_scan++;
-            *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, src_alpha);
-            dest_scan += Bpp - 2;
-            continue;
-          }
-        }
-        dest_scan += Bpp;
-      }
-      return;
-    }
-    if (Bpp == 3 && dest_extra_alpha_scan) {
-      for (int col = col_start; col < col_end; col++) {
-        int src_alpha;
-        if (m_bFullCover) {
-          if (clip_scan) {
-            src_alpha = m_Alpha * clip_scan[col] / 255;
-          } else {
-            src_alpha = m_Alpha;
-          }
-        } else {
-          if (clip_scan) {
-            src_alpha = m_Alpha * cover_scan[col] * clip_scan[col] / 255 / 255;
-          } else {
-            src_alpha = m_Alpha * cover_scan[col] / 255;
-          }
-        }
-        if (src_alpha) {
-          if (src_alpha == 255) {
-            *dest_scan++ = (uint8_t)m_Blue;
-            *dest_scan++ = (uint8_t)m_Green;
-            *dest_scan++ = (uint8_t)m_Red;
-            *dest_extra_alpha_scan++ = (uint8_t)m_Alpha;
-            continue;
-          } else {
-            uint8_t dest_alpha = (*dest_extra_alpha_scan) + src_alpha -
-                                 (*dest_extra_alpha_scan) * src_alpha / 255;
-            *dest_extra_alpha_scan++ = dest_alpha;
-            int alpha_ratio = src_alpha * 255 / dest_alpha;
-            *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, alpha_ratio);
-            dest_scan++;
-            *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, alpha_ratio);
-            dest_scan++;
-            *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, alpha_ratio);
-            dest_scan++;
-            continue;
-          }
-        }
-        dest_extra_alpha_scan++;
-        dest_scan += Bpp;
-      }
-    } else {
-      for (int col = col_start; col < col_end; col++) {
-        int src_alpha;
-        if (m_bFullCover) {
-          if (clip_scan) {
-            src_alpha = m_Alpha * clip_scan[col] / 255;
-          } else {
-            src_alpha = m_Alpha;
-          }
-        } else {
-          if (clip_scan) {
-            src_alpha = m_Alpha * cover_scan[col] * clip_scan[col] / 255 / 255;
-          } else {
-            src_alpha = m_Alpha * cover_scan[col] / 255;
-          }
-        }
-        if (src_alpha) {
-          if (src_alpha == 255) {
-            if (Bpp == 4) {
-              *(uint32_t*)dest_scan = m_Color;
-            } else if (Bpp == 3) {
-              *dest_scan++ = m_Blue;
-              *dest_scan++ = m_Green;
-              *dest_scan++ = m_Red;
-              continue;
-            }
-          } else {
-            *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, src_alpha);
-            dest_scan++;
-            *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, src_alpha);
-            dest_scan++;
-            *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, src_alpha);
-            dest_scan += Bpp - 2;
-            continue;
-          }
-        }
-        dest_scan += Bpp;
-      }
-    }
-  }
-
-  void CompositeSpanCMYK(uint8_t* dest_scan,
-                         int Bpp,
-                         int span_left,
-                         int span_len,
-                         uint8_t* cover_scan,
-                         int clip_left,
-                         int clip_right,
-                         uint8_t* clip_scan,
-                         uint8_t* dest_extra_alpha_scan) {
-    ASSERT(!m_bRgbByteOrder);
-    int col_start = span_left < clip_left ? clip_left - span_left : 0;
-    int col_end = (span_left + span_len) < clip_right
-                      ? span_len
-                      : (clip_right - span_left);
-    dest_scan += col_start * 4;
-    if (dest_extra_alpha_scan) {
-      for (int col = col_start; col < col_end; col++) {
-        int src_alpha;
-        if (m_bFullCover) {
-          if (clip_scan) {
-            src_alpha = m_Alpha * clip_scan[col] / 255;
-          } else {
-            src_alpha = m_Alpha;
-          }
-        } else {
-          if (clip_scan) {
-            src_alpha = m_Alpha * cover_scan[col] * clip_scan[col] / 255 / 255;
-          } else {
-            src_alpha = m_Alpha * cover_scan[col] / 255;
-          }
-        }
-        if (src_alpha) {
-          if (src_alpha == 255) {
-            *(FX_CMYK*)dest_scan = m_Color;
-            *dest_extra_alpha_scan = (uint8_t)m_Alpha;
-          } else {
-            uint8_t dest_alpha = (*dest_extra_alpha_scan) + src_alpha -
-                                 (*dest_extra_alpha_scan) * src_alpha / 255;
-            *dest_extra_alpha_scan++ = dest_alpha;
-            int alpha_ratio = src_alpha * 255 / dest_alpha;
-            *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, alpha_ratio);
-            dest_scan++;
-            *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, alpha_ratio);
-            dest_scan++;
-            *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, alpha_ratio);
-            dest_scan++;
-            *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Gray, alpha_ratio);
-            dest_scan++;
-            continue;
-          }
-        }
-        dest_extra_alpha_scan++;
-        dest_scan += 4;
-      }
-    } else {
-      for (int col = col_start; col < col_end; col++) {
-        int src_alpha;
-        if (clip_scan) {
-          src_alpha = m_Alpha * cover_scan[col] * clip_scan[col] / 255 / 255;
-        } else {
-          src_alpha = m_Alpha * cover_scan[col] / 255;
-        }
-        if (src_alpha) {
-          if (src_alpha == 255) {
-            *(FX_CMYK*)dest_scan = m_Color;
-          } else {
-            *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, src_alpha);
-            dest_scan++;
-            *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, src_alpha);
-            dest_scan++;
-            *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, src_alpha);
-            dest_scan++;
-            *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Gray, src_alpha);
-            dest_scan++;
-            continue;
-          }
-        }
-        dest_scan += 4;
-      }
-    }
-  }
-
-  template <class Scanline>
-  void render(const Scanline& sl) {
-    if (!m_pOriDevice && !composite_span) {
-      return;
-    }
-    int y = sl.y();
-    if (y < m_ClipBox.top || y >= m_ClipBox.bottom) {
-      return;
-    }
-    uint8_t* dest_scan = m_pDevice->GetBuffer() + m_pDevice->GetPitch() * y;
-    uint8_t* dest_scan_extra_alpha = nullptr;
-    CFX_DIBitmap* pAlphaMask = m_pDevice->m_pAlphaMask;
-    if (pAlphaMask) {
-      dest_scan_extra_alpha =
-          pAlphaMask->GetBuffer() + pAlphaMask->GetPitch() * y;
-    }
-    uint8_t* ori_scan = nullptr;
-    if (m_pOriDevice) {
-      ori_scan = m_pOriDevice->GetBuffer() + m_pOriDevice->GetPitch() * y;
-    }
-    int Bpp = m_pDevice->GetBPP() / 8;
-    bool bDestAlpha = m_pDevice->HasAlpha() || m_pDevice->IsAlphaMask();
-    unsigned num_spans = sl.num_spans();
-    typename Scanline::const_iterator span = sl.begin();
-    while (1) {
-      int x = span->x;
-      ASSERT(span->len > 0);
-      uint8_t* dest_pos = nullptr;
-      uint8_t* dest_extra_alpha_pos = nullptr;
-      uint8_t* ori_pos = nullptr;
-      if (Bpp) {
-        ori_pos = ori_scan ? ori_scan + x * Bpp : nullptr;
-        dest_pos = dest_scan + x * Bpp;
-        dest_extra_alpha_pos =
-            dest_scan_extra_alpha ? dest_scan_extra_alpha + x : nullptr;
-      } else {
-        dest_pos = dest_scan + x / 8;
-        ori_pos = ori_scan ? ori_scan + x / 8 : nullptr;
-      }
-      uint8_t* clip_pos = nullptr;
-      if (m_pClipMask) {
-        clip_pos = m_pClipMask->GetBuffer() +
-                   (y - m_ClipBox.top) * m_pClipMask->GetPitch() + x -
-                   m_ClipBox.left;
-      }
-      if (ori_pos) {
-        CompositeSpan(dest_pos, ori_pos, Bpp, bDestAlpha, x, span->len,
-                      span->covers, m_ClipBox.left, m_ClipBox.right, clip_pos);
-      } else {
-        (this->*composite_span)(dest_pos, Bpp, x, span->len, span->covers,
-                                m_ClipBox.left, m_ClipBox.right, clip_pos,
-                                dest_extra_alpha_pos);
-      }
-      if (--num_spans == 0) {
-        break;
-      }
-      ++span;
-    }
-  }
-
-  bool Init(CFX_DIBitmap* pDevice,
-            CFX_DIBitmap* pOriDevice,
-            const CFX_ClipRgn* pClipRgn,
-            uint32_t color,
-            bool bFullCover,
-            bool bRgbByteOrder,
-            int alpha_flag = 0,
-            void* pIccTransform = nullptr) {
-    m_pDevice = pDevice;
-    m_pClipRgn = pClipRgn;
-    composite_span = nullptr;
-    m_bRgbByteOrder = bRgbByteOrder;
-    m_pOriDevice = pOriDevice;
-    if (m_pClipRgn) {
-      m_ClipBox = m_pClipRgn->GetBox();
-    } else {
-      m_ClipBox.left = m_ClipBox.top = 0;
-      m_ClipBox.right = m_pDevice->GetWidth();
-      m_ClipBox.bottom = m_pDevice->GetHeight();
-    }
-    m_pClipMask = nullptr;
-    if (m_pClipRgn && m_pClipRgn->GetType() == CFX_ClipRgn::MaskF) {
-      m_pClipMask = m_pClipRgn->GetMask().GetObject();
-    }
-    m_bFullCover = bFullCover;
-    bool bObjectCMYK = !!FXGETFLAG_COLORTYPE(alpha_flag);
-    bool bDeviceCMYK = pDevice->IsCmykImage();
-    m_Alpha = bObjectCMYK ? FXGETFLAG_ALPHA_FILL(alpha_flag) : FXARGB_A(color);
-    CCodec_IccModule* pIccModule = nullptr;
-    if (!CFX_GEModule::Get()->GetCodecModule() ||
-        !CFX_GEModule::Get()->GetCodecModule()->GetIccModule()) {
-      pIccTransform = nullptr;
-    } else {
-      pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
-    }
-    if (m_pDevice->GetBPP() == 8) {
-      ASSERT(!m_bRgbByteOrder);
-      composite_span = &CFX_Renderer::CompositeSpanGray;
-      if (m_pDevice->IsAlphaMask()) {
-        m_Gray = 255;
-      } else {
-        if (pIccTransform) {
-          uint8_t gray;
-          color = bObjectCMYK ? FXCMYK_TODIB(color) : FXARGB_TODIB(color);
-          pIccModule->TranslateScanline(pIccTransform, &gray,
-                                        (const uint8_t*)&color, 1);
-          m_Gray = gray;
-        } else {
-          if (bObjectCMYK) {
-            uint8_t r, g, b;
-            AdobeCMYK_to_sRGB1(FXSYS_GetCValue(color), FXSYS_GetMValue(color),
-                               FXSYS_GetYValue(color), FXSYS_GetKValue(color),
-                               r, g, b);
-            m_Gray = FXRGB2GRAY(r, g, b);
-          } else {
-            m_Gray =
-                FXRGB2GRAY(FXARGB_R(color), FXARGB_G(color), FXARGB_B(color));
-          }
-        }
-      }
-      return true;
-    }
-    if (bDeviceCMYK) {
-      ASSERT(!m_bRgbByteOrder);
-      composite_span = &CFX_Renderer::CompositeSpanCMYK;
-      if (bObjectCMYK) {
-        m_Color = FXCMYK_TODIB(color);
-        if (pIccTransform) {
-          pIccModule->TranslateScanline(pIccTransform, (uint8_t*)&m_Color,
-                                        (const uint8_t*)&m_Color, 1);
-        }
-      } else {
-        if (!pIccTransform) {
-          return false;
-        }
-        color = FXARGB_TODIB(color);
-        pIccModule->TranslateScanline(pIccTransform, (uint8_t*)&m_Color,
-                                      (const uint8_t*)&color, 1);
-      }
-      m_Red = ((uint8_t*)&m_Color)[0];
-      m_Green = ((uint8_t*)&m_Color)[1];
-      m_Blue = ((uint8_t*)&m_Color)[2];
-      m_Gray = ((uint8_t*)&m_Color)[3];
-    } else {
-      composite_span = (pDevice->GetFormat() == FXDIB_Argb)
-                           ? &CFX_Renderer::CompositeSpanARGB
-                           : &CFX_Renderer::CompositeSpanRGB;
-      if (pIccTransform) {
-        color = bObjectCMYK ? FXCMYK_TODIB(color) : FXARGB_TODIB(color);
-        pIccModule->TranslateScanline(pIccTransform, (uint8_t*)&m_Color,
-                                      (const uint8_t*)&color, 1);
-        ((uint8_t*)&m_Color)[3] = m_Alpha;
-        m_Red = ((uint8_t*)&m_Color)[2];
-        m_Green = ((uint8_t*)&m_Color)[1];
-        m_Blue = ((uint8_t*)&m_Color)[0];
-        if (m_bRgbByteOrder) {
-          m_Color = FXARGB_TODIB(m_Color);
-          m_Color = FXARGB_TOBGRORDERDIB(m_Color);
-        }
-      } else {
-        if (bObjectCMYK) {
-          uint8_t r, g, b;
-          AdobeCMYK_to_sRGB1(FXSYS_GetCValue(color), FXSYS_GetMValue(color),
-                             FXSYS_GetYValue(color), FXSYS_GetKValue(color), r,
-                             g, b);
-          m_Color = FXARGB_MAKE(m_Alpha, r, g, b);
-          if (m_bRgbByteOrder) {
-            m_Color = FXARGB_TOBGRORDERDIB(m_Color);
-          } else {
-            m_Color = FXARGB_TODIB(m_Color);
-          }
-          m_Red = r;
-          m_Green = g;
-          m_Blue = b;
-        } else {
-          if (m_bRgbByteOrder) {
-            m_Color = FXARGB_TOBGRORDERDIB(color);
-          } else {
-            m_Color = FXARGB_TODIB(color);
-          }
-          ArgbDecode(color, m_Alpha, m_Red, m_Green, m_Blue);
-        }
-      }
-    }
-    if (m_pDevice->GetBPP() == 1) {
-      composite_span = &CFX_Renderer::CompositeSpan1bpp;
-    }
-    return true;
-  }
-};
-
-#endif