handle antialiased rendering as premultiplied

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 <utility>
 #include <vector>
 
 #include "core/fxcodec/fx_codec.h"
 #include "core/fxcrt/fx_memory.h"
@@ skipping 16 matching lines @@
 
 #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/core/SkStream.h"
 #include "third_party/skia/include/core/SkTypeface.h"
 #include "third_party/skia/include/effects/SkDashPathEffect.h"
 #include "third_party/skia/include/pathops/SkPathOps.h"
+#include "third_party/skia/include/core/SkShader.h"
+#include "third_party/skia/include/effects/SkGradientShader.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/SkPictureRecorder.h"
-#include "third_party/skia/include/core/SkShader.h"
-#include "third_party/skia/include/effects/SkGradientShader.h"
 #endif  // _SKIA_SUPPORT_
 
 #ifdef SK_DEBUG
 #include "third_party/skia/include/core/SkClipStack.h"
 #endif  // SK_DEBUG
 
 namespace {
 
 #ifdef _SKIA_SUPPORT_PATHS_
 void RgbByteOrderTransferBitmap(CFX_DIBitmap* pBitmap,
@@ skipping 251 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 163 matching lines @@
   ASSERT(maxBounds != minBounds && maxBounds >= 0);
   // construct a clip parallel to the gradient that goes through
   // rectPts[minBounds] and rectPts[maxBounds] and perpendicular to the
   // gradient that goes through startEdgePt, endEdgePt.
   clip->moveTo(IntersectSides(rectPts[minBounds], slope, startEdgePt));
   clip->lineTo(IntersectSides(rectPts[minBounds], slope, endEdgePt));
   clip->lineTo(IntersectSides(rectPts[maxBounds], slope, endEdgePt));
   clip->lineTo(IntersectSides(rectPts[maxBounds], slope, startEdgePt));
 }
 
+#ifdef _SKIA_SUPPORT_
 void SetBitmapMatrix(const CFX_Matrix* pMatrix,
                      int width,
                      int height,
                      SkMatrix* skMatrix) {
   const CFX_Matrix& m = *pMatrix;
   skMatrix->setAll(m.a / width, -m.c / height, m.c + m.e, m.b / width,
                    -m.d / height, m.d + m.f, 0, 0, 1);
 }
 
 void SetBitmapPaint(bool isAlphaMask,
@@ skipping 654 matching lines @@
   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 * vFlip};
     glyphs[index] = (uint16_t)cp.m_GlyphIndex;
   }
+#ifdef _SKIA_SUPPORT_PATHS_
+  m_pBitmap->PreMultiply();
+#endif  // _SKIA_SUPPORT_PATHS_
   m_pCanvas->drawPosText(glyphs.begin(), nChars * 2, positions.begin(), paint);
   m_pCanvas->restore();
 
-#ifdef _SKIA_SUPPORT_PATHS_
-  if (FXARGB_A(color) < 255) {
-    m_pBitmap->MarkForUnPreMultiply(true);
-  }
-#endif  // _SKIA_SUPPORT_PATHS_
   return true;
 }
 
 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();
@@ skipping 250 matching lines @@
                &strokePath)) {
           fillPath = &strokePath;
         }
       }
     }
     skPaint.setStyle(SkPaint::kFill_Style);
     skPaint.setColor(fill_color);
     DebugShowSkiaPath(*fillPath);
     DebugShowCanvasMatrix(m_pCanvas);
     DebugShowCanvasClip(m_pCanvas);
+#ifdef _SKIA_SUPPORT_PATHS_
+    m_pBitmap->PreMultiply();
+#endif  // _SKIA_SUPPORT_PATHS_
     m_pCanvas->drawPath(*fillPath, skPaint);
   }
   if (pGraphState && stroke_alpha) {
     DebugShowSkiaPath(skPath);
     DebugShowCanvasMatrix(m_pCanvas);
     DebugShowCanvasClip(m_pCanvas);
     skPaint.setStyle(SkPaint::kStroke_Style);
     skPaint.setColor(stroke_color);
+#ifdef _SKIA_SUPPORT_PATHS_
+    m_pBitmap->PreMultiply();
+#endif  // _SKIA_SUPPORT_PATHS_
     m_pCanvas->drawPath(skPath, skPaint);
   }
   m_pCanvas->restore();
-#ifdef _SKIA_SUPPORT_PATHS_
-  if ((fill_mode & 3 && FXARGB_A(fill_color) < 255) ||
-      (pGraphState && stroke_alpha < 255)) {
-    m_pBitmap->MarkForUnPreMultiply(true);
-  }
-#endif  // _SKIA_SUPPORT_PATHS_
   return true;
 }
 
 bool CFX_SkiaDeviceDriver::DrawCosmeticLine(FX_FLOAT x1,
                                             FX_FLOAT y1,
                                             FX_FLOAT x2,
                                             FX_FLOAT y2,
                                             uint32_t color,
                                             int blend_type) {
   return false;
@@ skipping 12 matching lines @@
       SkRect::MakeLTRB(pRect->left, SkTMin(pRect->top, pRect->bottom),
                        pRect->right, SkTMax(pRect->bottom, pRect->top));
 #if SHOW_SKIA_PATH
   printf("fill rect = %g %g %g %g\n\n", rect.fLeft, rect.fTop, rect.fRight,
          rect.fBottom);
 #endif  // SHOW_SKIA_PATH
   m_pCanvas->drawRect(rect, 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  // _SKIA_SUPPORT_
 
 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();
@@ skipping 27 matching lines @@
       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;
 #endif  // _SKIA_SUPPORT_
 
 #ifdef _SKIA_SUPPORT_PATHS_
+  m_pBitmap->UnPreMultiply();
   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);
@@ skipping 144 matching lines @@
   }
   m_pCanvas->restore();
   if (ct)
     ct->unref();
   DebugValidate(m_pBitmap, m_pOriDevice);
 #endif  // _SKIA_SUPPORT_
 
 #ifdef _SKIA_SUPPORT_PATHS_
   if (!m_pBitmap->GetBuffer())
     return true;
-
+  m_pBitmap->UnPreMultiply();
   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  // _SKIA_SUPPORT_PATHS_
   return true;
 }
 
 bool CFX_SkiaDeviceDriver::ContinueDIBits(void* handle, IFX_Pause* pPause) {
 #ifdef _SKIA_SUPPORT_
   return false;
 #endif  // _SKIA_SUPPORT_
 
 #ifdef _SKIA_SUPPORT_PATHS_
   if (!m_pBitmap->GetBuffer()) {
     return true;
   }
   return static_cast<CFX_ImageRenderer*>(handle)->Continue(pPause);
 #endif  // _SKIA_SUPPORT_PATHS_
 }
 
-#ifdef _SKIA_SUPPORT_
+#if defined _SKIA_SUPPORT_
 void CFX_SkiaDeviceDriver::PreMultiply(CFX_DIBitmap* pDIBitmap) {
-  void* buffer = pDIBitmap->GetBuffer();
+  pDIBitmap->PreMultiply();
+}
+#endif  // _SKIA_SUPPORT_
+
+void CFX_DIBitmap::PreMultiply() {
+  if (this->GetBPP() != 32)
+    return;
+  void* buffer = this->GetBuffer();
   if (!buffer)
     return;
-  if (pDIBitmap->GetBPP() != 32) {
+#if defined _SKIA_SUPPORT_PATHS_
+  Format priorFormat = m_nFormat;
+  m_nFormat = Format::kPreMultiplied;
+  if (priorFormat != Format::kUnPreMultiplied)
     return;
-  }
-  int height = pDIBitmap->GetHeight();
-  int width = pDIBitmap->GetWidth();
-  int rowBytes = pDIBitmap->GetPitch();
+#endif
+  int height = this->GetHeight();
+  int width = this->GetWidth();
+  int rowBytes = this->GetPitch();
   SkImageInfo unpremultipliedInfo =
       SkImageInfo::Make(width, height, kN32_SkColorType, kUnpremul_SkAlphaType);
   SkPixmap unpremultiplied(unpremultipliedInfo, buffer, rowBytes);
   SkImageInfo premultipliedInfo =
       SkImageInfo::Make(width, height, kN32_SkColorType, kPremul_SkAlphaType);
   SkPixmap premultiplied(premultipliedInfo, buffer, rowBytes);
   unpremultiplied.readPixels(premultiplied);
-  pDIBitmap->DebugVerifyBitmapIsPreMultiplied();
+  this->DebugVerifyBitmapIsPreMultiplied();
 }
-#endif  // _SKIA_SUPPORT_
 
 #ifdef _SKIA_SUPPORT_PATHS_
-void CFX_SkiaDeviceDriver::UnPreMultiply(CFX_DIBitmap* pDIBitmap) {
-  if (!pDIBitmap->IsMarkedForUnPreMultiply())
+void CFX_DIBitmap::UnPreMultiply() {
+  if (this->GetBPP() != 32)
     return;
-  pDIBitmap->DebugVerifyBitmapIsPreMultiplied();
-  void* buffer = pDIBitmap->GetBuffer();
+  void* buffer = this->GetBuffer();
   if (!buffer)
     return;
-  if (pDIBitmap->GetBPP() != 32) {
+  Format priorFormat = m_nFormat;
+  m_nFormat = Format::kUnPreMultiplied;
+  if (priorFormat != Format::kPreMultiplied)
     return;
-  }
-  int height = pDIBitmap->GetHeight();
-  int width = pDIBitmap->GetWidth();
-  int rowBytes = pDIBitmap->GetPitch();
+  this->DebugVerifyBitmapIsPreMultiplied();
+  int height = this->GetHeight();
+  int width = this->GetWidth();
+  int rowBytes = this->GetPitch();
   SkImageInfo premultipliedInfo =
       SkImageInfo::Make(width, height, kN32_SkColorType, kPremul_SkAlphaType);
   SkPixmap premultiplied(premultipliedInfo, buffer, rowBytes);
   SkImageInfo unpremultipliedInfo =
       SkImageInfo::Make(width, height, kN32_SkColorType, kUnpremul_SkAlphaType);
   SkPixmap unpremultiplied(unpremultipliedInfo, buffer, rowBytes);
   premultiplied.readPixels(unpremultiplied);
-  pDIBitmap->MarkForUnPreMultiply(false);
 }
 #endif  // _SKIA_SUPPORT_PATHS_
 
 #ifdef _SKIA_SUPPORT_
 bool CFX_SkiaDeviceDriver::DrawBitsWithMask(const CFX_DIBSource* pSource,
                                             const CFX_DIBSource* pMask,
                                             int bitmap_alpha,
                                             const CFX_Matrix* pMatrix,
                                             int blend_type) {
   DebugValidate(m_pBitmap, m_pOriDevice);
@@ skipping 47 matching lines @@
                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  // _SKIA_SUPPORT_
 
 void CFX_SkiaDeviceDriver::Dump() const {
-#if SHOW_SKIA_PATH
+#if SHOW_SKIA_PATH && defined _SKIA_SUPPORT_
   if (m_pCache)
     m_pCache->Dump(this);
-#endif  // SHOW_SKIA_PATH
+#endif  // SHOW_SKIA_PATH && defined _SKIA_SUPPORT_
 }
 
 #ifdef _SKIA_SUPPORT_
 void CFX_SkiaDeviceDriver::DebugVerifyBitmapIsPreMultiplied() const {
   if (m_pOriDevice)
     m_pOriDevice->DebugVerifyBitmapIsPreMultiplied();
 }
 #endif  // _SKIA_SUPPORT_
 
-#ifdef _SKIA_SUPPORT_PATHS_
-void CFX_SkiaDeviceDriver::UnPreMultiplyDevice() {
-  UnPreMultiply(m_pBitmap);
-}
-#endif  // _SKIA_SUPPORT_PATHS_
-
 CFX_FxgeDevice::CFX_FxgeDevice() {
 #ifdef _SKIA_SUPPORT_
   m_bOwnedBitmap = false;
 #endif  // _SKIA_SUPPORT_
 }
 
 #ifdef _SKIA_SUPPORT_
 void CFX_FxgeDevice::Clear(uint32_t color) {
   CFX_SkiaDeviceDriver* skDriver =
       static_cast<CFX_SkiaDeviceDriver*>(GetDeviceDriver());
@@ skipping 71 matching lines @@
                                      int blend_type) {
   CFX_SkiaDeviceDriver* skDriver =
       static_cast<CFX_SkiaDeviceDriver*>(GetDeviceDriver());
   if (skDriver)
     return skDriver->SetBitsWithMask(pBitmap, pMask, left, top, bitmap_alpha,
                                      blend_type);
   return false;
 }
 #endif  // _SKIA_SUPPORT_
 
-#ifdef _SKIA_SUPPORT_PATHS_
-void CFX_FxgeDevice::UnPreMultiplyDevice() {
-  CFX_SkiaDeviceDriver* skDriver =
-      static_cast<CFX_SkiaDeviceDriver*>(GetDeviceDriver());
-  if (skDriver)
-    skDriver->UnPreMultiplyDevice();
-}
-#endif  // _SKIA_SUPPORT_PATHS_
-
 void CFX_DIBSource::DebugVerifyBitmapIsPreMultiplied(void* opt) const {
 #ifdef SK_DEBUG
   SkASSERT(32 == GetBPP());
   const uint32_t* buffer = (const uint32_t*)(opt ? opt : GetBuffer());
   int width = GetWidth();
   int height = GetHeight();
   // verify that input is really premultiplied
   for (int y = 0; y < height; ++y) {
     const uint32_t* srcRow = buffer + y * width;
     for (int x = 0; x < width; ++x) {
@@ skipping 833 matching lines @@
       }
     }
     if (m_pDevice->GetBPP() == 1) {
       composite_span = &CFX_Renderer::CompositeSpan1bpp;
     }
     return true;
   }
 };
 
 #endif  // _SKIA_SUPPORT_PATHS_