Removing the dependency on GraphicsContext for drawing images in 2D canvas

Source/platform/graphics/GraphicsContext.cpp

 /*
  * Copyright (C) 2003, 2004, 2005, 2006, 2009 Apple Inc. All rights reserved.
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 23 matching lines @@
 #include "platform/graphics/Gradient.h"
 #include "platform/graphics/ImageBuffer.h"
 #include "platform/weborigin/KURL.h"
 #include "third_party/skia/include/core/SkAnnotation.h"
 #include "third_party/skia/include/core/SkColorFilter.h"
 #include "third_party/skia/include/core/SkData.h"
 #include "third_party/skia/include/core/SkPicture.h"
 #include "third_party/skia/include/core/SkPictureRecorder.h"
 #include "third_party/skia/include/core/SkRRect.h"
 #include "third_party/skia/include/core/SkRefCnt.h"
-#include "third_party/skia/include/effects/SkCornerPathEffect.h"
-#include "third_party/skia/include/effects/SkDropShadowImageFilter.h"
 #include "third_party/skia/include/effects/SkLumaColorFilter.h"
 #include "third_party/skia/include/effects/SkPictureImageFilter.h"
 #include "third_party/skia/include/utils/SkNullCanvas.h"
 #include "wtf/Assertions.h"
 #include "wtf/MathExtras.h"
 
 namespace blink {
 
 class GraphicsContext::RecordingState {
     WTF_MAKE_FAST_ALLOCATED(GraphicsContext::RecordingState);
@@ skipping 41 matching lines @@
     , m_paintStateIndex(0)
 #if ENABLE(ASSERT)
     , m_layerCount(0)
     , m_disableDestructionChecks(false)
     , m_inDrawingRecorder(false)
 #endif
     , m_disabledState(disableContextOrPainting)
     , m_deviceScaleFactor(1.0f)
     , m_accelerated(false)
     , m_printing(false)
-    , m_antialiasHairlineImages(false)
 {
     // FIXME: Do some tests to determine how many states are typically used, and allocate
     // several here.
     m_paintStateStack.append(GraphicsContextState::create());
     m_paintState = m_paintStateStack.last().get();
 
     if (contextDisabled()) {
         DEFINE_STATIC_LOCAL(RefPtr<SkCanvas>, nullCanvas, (adoptRef(SkCreateNullCanvas())));
         m_canvas = nullCanvas.get();
     }
@@ skipping 154 matching lines @@
     if (contextDisabled())
         return;
 
     OwnPtr<DrawLooperBuilder> drawLooperBuilder = DrawLooperBuilder::create();
     if (!color.alpha()) {
         if (shadowMode == DrawShadowOnly) {
             // shadow only, but there is no shadow: use an empty draw looper to disable rendering of the source primitive
             setDrawLooper(drawLooperBuilder.release());
             return;
         }
-        clearShadow();
+        clearDrawLooper();
         return;
     }
 
     drawLooperBuilder->addShadow(offset, blur, color, shadowTransformMode, shadowAlphaMode);
     if (shadowMode == DrawShadowAndForeground) {
         drawLooperBuilder->addUnmodifiedContent();
     }
     setDrawLooper(drawLooperBuilder.release());
-
-    if (shadowTransformMode == DrawLooperBuilder::ShadowIgnoresTransforms
-        && shadowAlphaMode == DrawLooperBuilder::ShadowRespectsAlpha) {
-        // This image filter will be used in place of the drawLooper created above but only for drawing non-opaque bitmaps;
-        // see preparePaintForDrawRectToRect().
-        SkColor skColor = color.rgb();
-        // These constants are from RadiusToSigma() from DrawLooperBuilder.cpp.
-        const SkScalar sigma = 0.288675f * blur + 0.5f;
-        SkDropShadowImageFilter::ShadowMode dropShadowMode = shadowMode == DrawShadowAndForeground ? SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode : SkDropShadowImageFilter::kDrawShadowOnly_ShadowMode;
-        RefPtr<SkImageFilter> filter = adoptRef(SkDropShadowImageFilter::Create(offset.width(), offset.height(), sigma, sigma, skColor, dropShadowMode));
-        setDropShadowImageFilter(filter);
-    }
 }
 
 void GraphicsContext::setDrawLooper(PassOwnPtr<DrawLooperBuilder> drawLooperBuilder)
 {
     if (contextDisabled())
         return;
 
     mutableState()->setDrawLooper(drawLooperBuilder->detachDrawLooper());
 }
 
 void GraphicsContext::clearDrawLooper()
 {
     if (contextDisabled())
         return;
 
     mutableState()->clearDrawLooper();
 }
 
-void GraphicsContext::setDropShadowImageFilter(PassRefPtr<SkImageFilter> imageFilter)
-{
-    if (contextDisabled())
-        return;
-
-    mutableState()->setDropShadowImageFilter(imageFilter);
-}
-
-void GraphicsContext::clearDropShadowImageFilter()
-{
-    if (contextDisabled())
-        return;
-
-    mutableState()->clearDropShadowImageFilter();
-}
-
 SkMatrix GraphicsContext::getTotalMatrix() const
 {
     // FIXME: this is a hack to avoid changing all call sites of getTotalMatrix() to not use this method.
     // The code needs to be cleand up after Slimming Paint is launched.
     if (RuntimeEnabledFeatures::slimmingPaintEnabled())
         return SkMatrix::I();
 
     if (contextDisabled() || !m_canvas)
         return SkMatrix::I();
 
     ASSERT(m_canvas);
 
     if (!isRecording())
         return m_canvas->getTotalMatrix();
 
     SkMatrix totalMatrix = m_recordingStateStack.last()->matrix();
     totalMatrix.preConcat(m_canvas->getTotalMatrix());
 
     return totalMatrix;
 }
 
-void GraphicsContext::setCompositeOperation(SkXfermode::Mode xferMode)
-{
-    if (contextDisabled())
-        return;
-    mutableState()->setCompositeOperation(xferMode);
-}
-
-SkXfermode::Mode GraphicsContext::compositeOperation() const
-{
-    return immutableState()->compositeOperation();
-}
-
 SkColorFilter* GraphicsContext::colorFilter() const
 {
     return immutableState()->colorFilter();
 }
 
 void GraphicsContext::setColorFilter(ColorFilter colorFilter)
 {
     GraphicsContextState* stateToSet = mutableState();
 
     // We only support one active color filter at the moment. If (when) this becomes a problem,
@@ skipping 33 matching lines @@
     SkPaint layerPaint;
     layerPaint.setAlpha(static_cast<unsigned char>(opacity * 255));
     layerPaint.setXfermodeMode(xfermode);
     layerPaint.setColorFilter(WebCoreColorFilterToSkiaColorFilter(colorFilter).get());
     layerPaint.setImageFilter(imageFilter);
 
     if (bounds) {
         SkRect skBounds = WebCoreFloatRectToSKRect(*bounds);
         saveLayer(&skBounds, &layerPaint);
     } else {
-        saveLayer(0, &layerPaint);
+        saveLayer(nullptr, &layerPaint);
     }
 
 #if ENABLE(ASSERT)
     ++m_layerCount;
 #endif
 }
 
 void GraphicsContext::endLayer()
 {
     if (contextDisabled())
@@ skipping 91 matching lines @@
     SkPath path;
     setPathFromPoints(&path, numPoints, points);
 
     SkPaint paint(immutableState()->fillPaint());
     paint.setAntiAlias(shouldAntialias);
     paint.setColor(color.rgb());
 
     drawPath(path, paint);
 }
 
-float GraphicsContext::prepareFocusRingPaint(SkPaint& paint, const Color& color, int width) const
-{
-    paint.setAntiAlias(true);
-    paint.setStyle(SkPaint::kStroke_Style);
-    paint.setColor(color.rgb());
-    paint.setStrokeWidth(focusRingWidth(width));
-
-#if OS(MACOSX)
-    paint.setAlpha(64);
-    return (width - 1) * 0.5f;
-#else
-    return 1;
-#endif
-}
-
 void GraphicsContext::drawFocusRingPath(const SkPath& path, const Color& color, int width)
 {
-    SkPaint paint;
-    float cornerRadius = prepareFocusRingPaint(paint, color, width);
-
-    paint.setPathEffect(SkCornerPathEffect::Create(SkFloatToScalar(cornerRadius)))->unref();
-
-    // Outer path
-    drawPath(path, paint);
-
-#if OS(MACOSX)
-    // Inner path
-    paint.setAlpha(128);
-    paint.setStrokeWidth(paint.getStrokeWidth() * 0.5f);
-    drawPath(path, paint);
-#endif
+    drawPlatformFocusRing(path, m_canvas, color.rgb(), width);
 }
 
 void GraphicsContext::drawFocusRingRect(const SkRect& rect, const Color& color, int width)
 {
-    SkPaint paint;
-    float cornerRadius = prepareFocusRingPaint(paint, color, width);
-
-    SkRRect rrect;
-    rrect.setRectXY(rect, SkFloatToScalar(cornerRadius), SkFloatToScalar(cornerRadius));
-
-    // Outer rect
-    drawRRect(rrect, paint);
-
-#if OS(MACOSX)
-    // Inner rect
-    paint.setAlpha(128);
-    paint.setStrokeWidth(paint.getStrokeWidth() * 0.5f);
-    drawRRect(rrect, paint);
-#endif
+    drawPlatformFocusRing(rect, m_canvas, color.rgb(), width);
 }
 
 void GraphicsContext::drawFocusRing(const Path& focusRingPath, int width, int offset, const Color& color)
 {
     // FIXME: Implement support for offset.
     if (contextDisabled())
         return;
 
     drawFocusRingPath(focusRingPath.skPath(), color, width);
 }
@@ skipping 284 matching lines @@
         int thickness = SkMax32(static_cast<int>(strokeThickness()), 1);
         SkRect r;
         r.fLeft = WebCoreFloatToSkScalar(pt.x());
         // Avoid anti-aliasing lines. Currently, these are always horizontal.
         // Round to nearest pixel to match text and other content.
         r.fTop = WebCoreFloatToSkScalar(floorf(pt.y() + 0.5f));
         r.fRight = r.fLeft + WebCoreFloatToSkScalar(width);
         r.fBottom = r.fTop + SkIntToScalar(thickness);
         paint = immutableState()->fillPaint();
         // Text lines are drawn using the stroke color.
-        paint.setColor(effectiveStrokeColor());
+        paint.setColor(strokeColor().rgb());
         drawRect(r, paint);
         return;
     }
     case DottedStroke:
     case DashedStroke: {
         int y = floorf(pt.y() + std::max<float>(strokeThickness() / 2.0f, 0.5f));
         drawLine(IntPoint(pt.x(), y), IntPoint(pt.x() + width, y));
         return;
     }
     }
@@ skipping 13 matching lines @@
 
     SkRect skRect = rect;
     int fillcolorNotTransparent = immutableState()->fillColor().rgb() & 0xFF000000;
     if (fillcolorNotTransparent)
         drawRect(skRect, immutableState()->fillPaint());
 
     if (immutableState()->strokeData().style() != NoStroke
         && immutableState()->strokeColor().alpha()) {
         // Stroke a width: 1 inset border
         SkPaint paint(immutableState()->fillPaint());
-        paint.setColor(effectiveStrokeColor());
+        paint.setColor(strokeColor().rgb());
         paint.setStyle(SkPaint::kStroke_Style);
         paint.setStrokeWidth(1);
 
         skRect.inset(0.5f, 0.5f);
         drawRect(skRect, paint);
     }
 }
 
 void GraphicsContext::drawText(const Font& font, const TextRunPaintInfo& runInfo, const FloatPoint& point, const SkPaint& paint)
 {
@@ skipping 70 matching lines @@
 {
     if (!image)
         return;
     drawImage(image, FloatRect(r), FloatRect(FloatPoint(), FloatSize(image->size())), op, shouldRespectImageOrientation);
 }
 
 void GraphicsContext::drawImage(Image* image, const FloatRect& dest, const FloatRect& src, SkXfermode::Mode op, RespectImageOrientationEnum shouldRespectImageOrientation)
 {
     if (contextDisabled() || !image)
         return;
-    image->draw(this, dest, src, op, shouldRespectImageOrientation);
+
+    SkPaint imagePaint = immutableState()->fillPaint();
+    imagePaint.setXfermodeMode(op);
+    imagePaint.setColor(SK_ColorBLACK);
+    imagePaint.setFilterQuality(computeFilterQuality(image, dest, src));
+    // Disable anti-aliasing if we're not rotated or skewed.
+    // TODO(junov): crbug.com/492187 This code will disable antialiasing
+    // regardless of whether content is pixel aligned. Is this correct?
+    // For now, just preserving legacy behavior.
+    imagePaint.setAntiAlias(shouldAntialiasImages());
+    image->draw(m_canvas, imagePaint, dest, src, shouldRespectImageOrientation, Image::ClampImageToSourceRect);
+}
+
+SkFilterQuality GraphicsContext::computeFilterQuality(Image* image, const FloatRect& dest, const FloatRect& src) const
+{
+    InterpolationQuality resampling;
+    if (printing()) {
+        resampling = InterpolationNone;
+    } else if (image->isLazyDecodedBitmap()) {
+        resampling = InterpolationHigh;
+    } else {
+        // Take into account scale applied to the canvas when computing sampling mode (e.g. CSS scale or page scale).
+        // FIXME: In slimming paint, we create GCs on the fly when entering a new DisplayItemList
+        // scope, so relying on getTotalMatrix here is not sound.
+        SkRect destRectTarget = dest;
+        SkMatrix totalMatrix = getTotalMatrix();
+        if (!(totalMatrix.getType() & (SkMatrix::kAffine_Mask | SkMatrix::kPerspective_Mask)))
+            totalMatrix.mapRect(&destRectTarget, dest);
+
+        resampling = computeInterpolationQuality(totalMatrix,
+            SkScalarToFloat(src.width()), SkScalarToFloat(src.height()),
+            SkScalarToFloat(destRectTarget.width()), SkScalarToFloat(destRectTarget.height()),
+            image->isImmutableBitmap());
+    }
+
+    if (resampling == InterpolationNone) {
+        // FIXME: This is to not break tests (it results in the filter bitmap flag
+        // being set to true). We need to decide if we respect InterpolationNone
+        // being returned from computeInterpolationQuality.
+        resampling = InterpolationLow;
+    }
+    return static_cast<SkFilterQuality>(limitInterpolationQuality(this, resampling));
 }
 
 void GraphicsContext::drawTiledImage(Image* image, const IntRect& destRect, const IntPoint& srcPoint, const IntSize& tileSize, SkXfermode::Mode op, const IntSize& repeatSpacing)
 {
     if (contextDisabled() || !image)
         return;
     image->drawTiled(this, destRect, srcPoint, tileSize, op, repeatSpacing);
 }
 
 void GraphicsContext::drawTiledImage(Image* image, const IntRect& dest, const IntRect& srcRect,
@@ skipping 22 matching lines @@
 
 void GraphicsContext::writePixels(const SkImageInfo& info, const void* pixels, size_t rowBytes, int x, int y)
 {
     if (contextDisabled())
         return;
     ASSERT(m_canvas);
 
     m_canvas->writePixels(info, pixels, rowBytes, x, y);
 }
 
-void GraphicsContext::drawBitmapRect(const SkBitmap& bitmap, const SkRect* src,
-    const SkRect& dst, const SkPaint* paint)
-{
-    // Textures are bound to the blink main-thread GrContext, which can not be
-    // used on the compositor raster thread.
-    // FIXME: Mailbox support would make this possible in the GPU-raster case.
-    // If we're printing it is safe to access the texture because we are always
-    // on main thread, even if the other conditions are not met.
-    ASSERT(!isRecording() || !bitmap.getTexture() || printing());
-    if (contextDisabled())
-        return;
-
-    SkCanvas::DrawBitmapRectFlags flags =
-        immutableState()->shouldClampToSourceRect() ? SkCanvas::kNone_DrawBitmapRectFlag : SkCanvas::kBleed_DrawBitmapRectFlag;
-
-    ASSERT(m_canvas);
-    m_canvas->drawBitmapRectToRect(bitmap, src, dst, paint, flags);
-}
-
 void GraphicsContext::drawOval(const SkRect& oval, const SkPaint& paint)
 {
     if (contextDisabled())
         return;
     ASSERT(m_canvas);
 
     m_canvas->drawOval(oval, paint);
 }
 
 void GraphicsContext::drawPath(const SkPath& path, const SkPaint& paint)
@@ skipping 46 matching lines @@
         return;
 
     drawRect(rect, immutableState()->fillPaint());
 }
 
 void GraphicsContext::fillRect(const FloatRect& rect, const Color& color, SkXfermode::Mode xferMode)
 {
     if (contextDisabled())
         return;
 
-    if (color == fillColor() && xferMode == compositeOperation()) {
-        drawRect(rect, immutableState()->fillPaint());
-        return;
-    }
-
     SkPaint paint = immutableState()->fillPaint();
     paint.setColor(color.rgb());
     paint.setXfermodeMode(xferMode);
 
     drawRect(rect, paint);
 }
 
 void GraphicsContext::fillRoundedRect(const FloatRoundedRect& rrect, const Color& color)
 {
     if (contextDisabled())
@@ skipping 484 matching lines @@
 {
     static const SkPMColor colors[] = {
         SkPreMultiplyARGB(0x60, 0xFF, 0x00, 0x00), // More transparent red
         SkPreMultiplyARGB(0x60, 0xC0, 0xC0, 0xC0)  // More transparent gray
     };
 
     return colors[index];
 }
 #endif
 
-int GraphicsContext::preparePaintForDrawRectToRect(
-    SkPaint* paint,
-    const SkRect& srcRect,
-    const SkRect& destRect,
-    SkXfermode::Mode compositeOp,
-    bool isBitmapWithAlpha,
-    bool isLazyDecoded,
-    bool isDataComplete) const
-{
-    int initialSaveCount = m_canvas->getSaveCount();
-
-    paint->setColorFilter(this->colorFilter());
-    paint->setAlpha(this->getNormalizedAlpha());
-    bool usingImageFilter = false;
-    if (dropShadowImageFilter() && isBitmapWithAlpha) {
-        SkMatrix ctm = getTotalMatrix();
-        SkMatrix invCtm;
-        if (ctm.invert(&invCtm)) {
-            usingImageFilter = true;
-            // The image filter is meant to ignore tranforms with respect to
-            // the shadow parameters. The matrix tweaks below ensures that the image
-            // filter is applied in post-transform space. We use concat() instead of
-            // setMatrix() in case this goes into a recording canvas which may need to
-            // respect a parent transform at playback time.
-            m_canvas->save();
-            m_canvas->concat(invCtm);
-            SkRect bounds = destRect;
-            ctm.mapRect(&bounds);
-            SkRect filteredBounds;
-            dropShadowImageFilter()->computeFastBounds(bounds, &filteredBounds);
-            SkPaint layerPaint;
-            layerPaint.setXfermodeMode(compositeOp);
-            layerPaint.setImageFilter(dropShadowImageFilter());
-            m_canvas->saveLayer(&filteredBounds, &layerPaint);
-            m_canvas->concat(ctm);
-        }
-    }
-
-    if (!usingImageFilter) {
-        paint->setXfermodeMode(compositeOp);
-        paint->setLooper(this->drawLooper());
-    }
-
-    paint->setAntiAlias(shouldDrawAntiAliased(this, destRect));
-
-    InterpolationQuality resampling;
-    if (this->isAccelerated()) {
-        resampling = InterpolationLow;
-    } else if (this->printing()) {
-        resampling = InterpolationNone;
-    } else if (isLazyDecoded) {
-        resampling = InterpolationHigh;
-    } else {
-        // Take into account scale applied to the canvas when computing sampling mode (e.g. CSS scale or page scale).
-        SkRect destRectTarget = destRect;
-        SkMatrix totalMatrix = this->getTotalMatrix();
-        if (!(totalMatrix.getType() & (SkMatrix::kAffine_Mask | SkMatrix::kPerspective_Mask)))
-            totalMatrix.mapRect(&destRectTarget, destRect);
-
-        resampling = computeInterpolationQuality(totalMatrix,
-            SkScalarToFloat(srcRect.width()), SkScalarToFloat(srcRect.height()),
-            SkScalarToFloat(destRectTarget.width()), SkScalarToFloat(destRectTarget.height()),
-            isDataComplete);
-    }
-
-    if (resampling == InterpolationNone) {
-        // FIXME: This is to not break tests (it results in the filter bitmap flag
-        // being set to true). We need to decide if we respect InterpolationNone
-        // being returned from computeInterpolationQuality.
-        resampling = InterpolationLow;
-    }
-    resampling = limitInterpolationQuality(this, resampling);
-    paint->setFilterQuality(static_cast<SkFilterQuality>(resampling));
-
-    return initialSaveCount;
-}
-
 } // namespace blink