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.
 
-#if defined(_SKIA_SUPPORT_)
+#ifdef _SKIA_SUPPORT_
 #include <algorithm>
 #include <vector>
 
 #include "core/fxcodec/include/fx_codec.h"
 #include "core/fxcrt/include/fx_memory.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/include/cfx_fontcache.h"
+#endif
+
 #include "core/fxge/include/cfx_fxgedevice.h"
+
+#ifdef _SKIA_SUPPORT_

[dsinclair, 2016/09/19 20:45:12]

Let's consolidate all of these header if's into fewer blocks if possible.

 #include "core/fxge/include/cfx_gemodule.h"
+#endif
+
 #include "core/fxge/include/cfx_graphstatedata.h"
 #include "core/fxge/include/cfx_pathdata.h"
+
+#ifdef _SKIA_SUPPORT_
 #include "core/fxge/include/cfx_renderdevice.h"
+#else
+#include "core/fxge/ge/cfx_cliprgn.h"
+#endif
+
 #include "core/fxge/skia/fx_skia_device.h"
+#include "third_party/skia/include/core/SkCanvas.h"
 
-#include "third_party/skia/include/core/SkCanvas.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"
+#endif
+
 #include "third_party/skia/include/core/SkPaint.h"
 #include "third_party/skia/include/core/SkPath.h"
+
+#ifdef _SKIA_SUPPORT_
 #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"
+#endif
+
 #include "third_party/skia/include/effects/SkDashPathEffect.h"
+
+#ifdef _SKIA_SUPPORT_
 #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 {
 
 #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
@@ skipping 41 matching lines @@
 #else  // DRAW_SKIA_CLIP
 
 void DebugDrawSkiaClipRect(SkCanvas* canvas, const SkRect& rect) {}
 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 58 matching lines @@
     case FXDIB_BLEND_COLOR:
       return SkXfermode::kColor_Mode;
     case FXDIB_BLEND_LUMINOSITY:
       return SkXfermode::kLuminosity_Mode;
     case FXDIB_BLEND_NORMAL:
     default:
       return SkXfermode::kSrcOver_Mode;
   }
 }
 
+#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 69 matching lines @@
     if (!AddColors(pSubFunc, skColors))
       return false;
     FX_FLOAT boundsEnd =
         i < inputs - 1 ? pFunc->GetBound(i) : pFunc->GetDomain(1);
     skPos->push(boundsStart);
     skPos->push(boundsEnd);
     boundsStart = boundsEnd;
   }
   return true;
 }
+#endif
 
 // see https://en.wikipedia.org/wiki/Distance_from_a_point_to_a_line
 SkScalar LineSide(const SkPoint line[2], const SkPoint& pt) {
   return (line[1].fY - line[0].fY) * pt.fX - (line[1].fX - line[0].fX) * pt.fY +
          line[1].fX * line[0].fY - line[1].fY * line[0].fX;
 }
 
 SkPoint IntersectSides(const SkPoint& parallelPt,
                        const SkVector& paraRay,
                        const SkPoint& perpendicularPt) {
   SkVector perpRay = {paraRay.fY, -paraRay.fX};
   SkScalar denom = perpRay.fY * paraRay.fX - paraRay.fY * perpRay.fX;
   if (!denom) {
     SkPoint zeroPt = {0, 0};
     return zeroPt;
   }
   SkVector ab0 = parallelPt - perpendicularPt;
   SkScalar numerA = ab0.fY * perpRay.fX - perpRay.fY * ab0.fX;
   numerA /= denom;
   SkPoint result = {parallelPt.fX + paraRay.fX * numerA,
                     parallelPt.fY + paraRay.fY * numerA};
   return result;
 }
 
+#ifdef _SKIA_SUPPORT_
 void ClipAngledGradient(const SkPoint pts[2],
                         SkPoint rectPts[4],
                         bool clipStart,
                         bool clipEnd,
                         SkPath* clip) {
   // find the corners furthest from the gradient perpendiculars
   SkScalar minPerpDist = SK_ScalarMax;
   SkScalar maxPerpDist = SK_ScalarMin;
   int minPerpPtIndex = -1;
   int maxPerpPtIndex = -1;
@@ skipping 150 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;
 }
+#else
+
+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;
+  }
+}
+
+#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,
@@ skipping 18 matching lines @@
                 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,
                 CFX_FontCache* pCache,
                 const CFX_Matrix* pMatrix,
                 FX_FLOAT font_size,
                 uint32_t color,
                 CFX_SkiaDeviceDriver* pDriver) {
     if (m_debugDisable)
       return false;
@@ skipping 45 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 171 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 117 matching lines @@
       pBitmap->GetBPP() == 8 ? kAlpha_8_SkColorType : kN32_SkColorType,
       kOpaque_SkAlphaType);
   skBitmap.installPixels(imageInfo, pBitmap->GetBuffer(), pBitmap->GetPitch(),
                          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);
 }
 
 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) {
+#ifdef _SKIA_SUPPORT_
   if (!pCache)
     pCache = CFX_GEModule::Get()->GetFontCache();
   if (m_pCache->DrawText(nChars, pCharPos, pFont, pCache, pObject2Device,
                          font_size, color, this)) {
     return TRUE;
   }
   sk_sp<SkTypeface> typeface(
       SkSafeRef(pCache ? pCache->GetDeviceCache(pFont) : nullptr));
   SkPaint paint;
   paint.setAntiAlias(true);
@@ skipping 12 matching lines @@
   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;
     case FXDC_PIXEL_WIDTH:
       return m_pCanvas->imageInfo().width();
     case FXDC_PIXEL_HEIGHT:
       return m_pCanvas->imageInfo().height();
@@ skipping 154 matching lines @@
   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;
 }
 
+#ifdef _SKIA_SUPPORT_
 FX_BOOL CFX_SkiaDeviceDriver::DrawShading(const CPDF_ShadingPattern* pPattern,
                                           const CFX_Matrix* pMatrix,
                                           const FX_RECT& clip_rect,
                                           int alpha,
                                           FX_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, SkRegion::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();
 }
 
 FX_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;
 }
 
 FX_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;
+  }
+
+  FX_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;
 }
 
 FX_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
 }
 
 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 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, SkRegion::kIntersect_Op, true);
   void* dummy;
   FX_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
 }
 
 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 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 19 matching lines @@
       }
     }
   } else {
     m_pCanvas->drawBitmap(skBitmap, 0, 0, &paint);
   }
   m_pCanvas->restore();
   if (ct)
     ct->unref();
   DebugValidate(m_pBitmap, m_pOriDevice);
   return TRUE;
+#else
+  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;
+  return TRUE;
+#endif
 }
 
-FX_BOOL CFX_SkiaDeviceDriver::ContinueDIBits(void* handle, IFX_Pause* pPause) {
+FX_BOOL CFX_SkiaDeviceDriver::ContinueDIBits(void* pHandle, IFX_Pause* pPause) {
+#ifdef _SKIA_SUPPORT
   return FALSE;
+#else
+  if (!m_pBitmap->GetBuffer()) {
+    return TRUE;
+  }
+  return ((CFX_ImageRenderer*)pHandle)->Continue(pPause);

[dsinclair, 2016/09/19 20:45:12]

nit: static_cast.

+#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 61 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(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(WrapUnique(new CFX_SkiaDeviceDriver(
       pBitmap, bRgbByteOrder, pOriDevice, bGroupKnockout)));
   return true;
 }
 
+#ifdef _SKIA_SUPPORT_
 bool CFX_FxgeDevice::AttachRecorder(SkPictureRecorder* recorder) {
   if (!recorder)
     return false;
   SetDeviceDriver(WrapUnique(new 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(
       WrapUnique(new 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 27 matching lines @@
       SkA32Assert(a);
       SkASSERT(r <= a);
       SkASSERT(g <= a);
       SkASSERT(b <= a);
     }
   }
 #endif
 }
 
 #endif