ImageBuffer-less SVG masking and clipping.

Source/core/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 25 matching lines @@
 #include "core/platform/graphics/skia/SkiaUtils.h"
 #include "core/platform/text/BidiResolver.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/SkDevice.h"
 #include "third_party/skia/include/core/SkRRect.h"
 #include "third_party/skia/include/core/SkRefCnt.h"
 #include "third_party/skia/include/effects/SkBlurMaskFilter.h"
 #include "third_party/skia/include/effects/SkCornerPathEffect.h"
+#include "third_party/skia/include/effects/SkLumaXfermode.h"
 #include "weborigin/KURL.h"
 #include "wtf/Assertions.h"
 #include "wtf/MathExtras.h"
 
 #if OS(DARWIN)
 #include <ApplicationServices/ApplicationServices.h>
 #endif
 
 using namespace std;
 
 namespace WebCore {
 
 struct GraphicsContext::DeferredSaveState {
     DeferredSaveState(unsigned mask, int count) : m_flags(mask), m_restoreCount(count) { }
 
     unsigned m_flags;
     int m_restoreCount;
 };
 
 GraphicsContext::GraphicsContext(SkCanvas* canvas)
     : m_canvas(canvas)
     , m_deferredSaveFlags(0)
     , m_annotationMode(0)
 #if !ASSERT_DISABLED
     , m_annotationCount(0)
-    , m_transparencyCount(0)
+    , m_layerCount(0)
 #endif
     , m_trackOpaqueRegion(false)
     , m_trackTextRegion(false)
     , m_useHighResMarker(false)
     , m_updatingControlTints(false)
     , m_accelerated(false)
     , m_isCertainlyOpaque(true)
     , m_printing(false)
 {
     m_stateStack.append(adoptPtr(new GraphicsContextState()));
     m_state = m_stateStack.last().get();
 }
 
 GraphicsContext::~GraphicsContext()
 {
     ASSERT(m_stateStack.size() == 1);
     ASSERT(!m_annotationCount);
-    ASSERT(!m_transparencyCount);
+    ASSERT(!m_layerCount);
 }
 
 const SkBitmap* GraphicsContext::bitmap() const
 {
     TRACE_EVENT0("skia", "GraphicsContext::bitmap");
     return &m_canvas->getDevice()->accessBitmap(false);
 }
 
 const SkBitmap& GraphicsContext::layerBitmap(AccessMode access) const
 {
@@ skipping 23 matching lines @@
 void GraphicsContext::restore()
 {
     if (paintingDisabled())
         return;
 
     if (m_stateStack.size() == 1) {
         LOG_ERROR("ERROR void GraphicsContext::restore() stack is empty");
         return;
     }
 
-    if (!m_state->m_imageBufferClip.empty()) {
-        applyClipFromImage(m_state->m_clip, m_state->m_imageBufferClip);
-        m_canvas->restore();
-    }
-
     m_stateStack.removeLast();
     m_state = m_stateStack.last().get();
 
     DeferredSaveState savedState = m_saveStateStack.last();
     m_saveStateStack.removeLast();
     m_deferredSaveFlags = savedState.m_flags;
     m_canvas->restoreToCount(savedState.m_restoreCount);
 }
 
 void GraphicsContext::saveLayer(const SkRect* bounds, const SkPaint* paint, SkCanvas::SaveFlags saveFlags)
@@ skipping 215 matching lines @@
     return shouldSmoothFonts();
 }
 
 void GraphicsContext::setCompositeOperation(CompositeOperator compositeOperation, BlendMode blendMode)
 {
     m_state->m_compositeOperator = compositeOperation;
     m_state->m_blendMode = blendMode;
     m_state->m_xferMode = WebCoreCompositeToSkiaComposite(compositeOperation, blendMode);
 }
 
+void GraphicsContext::setColorSpaceConversion(ColorSpace srcColorSpace, ColorSpace dstColorSpace)
+{
+    m_state->m_colorFilter = ImageBuffer::createColorSpaceFilter(srcColorSpace, dstColorSpace);
+}
+
 bool GraphicsContext::readPixels(SkBitmap* bitmap, int x, int y, SkCanvas::Config8888 config8888)
 {
     if (paintingDisabled())
         return false;
 
     return m_canvas->readPixels(bitmap, x, y, config8888);
 }
 
 void GraphicsContext::setMatrix(const SkMatrix& matrix)
 {
     if (paintingDisabled())
         return;
 
     realizeSave(SkCanvas::kMatrix_SaveFlag);
 
     m_canvas->setMatrix(matrix);
 }
 
 bool GraphicsContext::concat(const SkMatrix& matrix)
 {
     if (paintingDisabled())
         return false;
 
     realizeSave(SkCanvas::kMatrix_SaveFlag);
 
     return m_canvas->concat(matrix);
 }
 
-void GraphicsContext::beginTransparencyLayer(float opacity)
+void GraphicsContext::beginTransparencyLayer(float opacity, const FloatRect* bounds)
 {
     if (paintingDisabled())
         return;
 
     // We need the "alpha" layer flag here because the base layer is opaque
     // (the surface of the page) but layers on top may have transparent parts.
     // Without explicitly setting the alpha flag, the layer will inherit the
     // opaque setting of the base and some things won't work properly.
     SkCanvas::SaveFlags saveFlags = static_cast<SkCanvas::SaveFlags>(SkCanvas::kHasAlphaLayer_SaveFlag | SkCanvas::kFullColorLayer_SaveFlag);
 
     SkPaint layerPaint;
     layerPaint.setAlpha(static_cast<unsigned char>(opacity * 255));
     layerPaint.setXfermodeMode(m_state->m_xferMode);
 
-    saveLayer(0, &layerPaint, saveFlags);
+    SkRect* skBounds = 0;
+    SkRect skBoundsStorage;
+
+    if (bounds) {
+        skBoundsStorage = WebCoreFloatRectToSKRect(*bounds);
+        skBounds = &skBoundsStorage;
+    }
+
+    saveLayer(skBounds, &layerPaint, saveFlags);

[Stephen White, 2013/08/28 20:16:12]

As an alternative, this could be:

    if (bounds) {
        SkRect skBounds = WebCoreFloatRectToSKRect(*bounds);
        saveLayer(&skBounds, &layerPaint, saveFlags);
    } else {
        saveLayer(NULL, &layerPaint, saveFlags);
    }
   
Seems a little clearer, but it's your call.

[f(malita), 2013/08/28 20:24:04]

It does look cleaner, will do.

 
 #if !ASSERT_DISABLED
-    ++m_transparencyCount;
+    ++m_layerCount;
 #endif
 }
 
-void GraphicsContext::endTransparencyLayer()
+void GraphicsContext::beginMaskedLayer(const FloatRect& bounds, MaskType maskType)
+{
+    if (paintingDisabled())
+        return;
+
+    SkPaint layerPaint;
+    layerPaint.setXfermode(maskType == AlphaMaskType
+        ? SkXfermode::Create(SkXfermode::kSrcIn_Mode)
+        : SkLumaMaskXfermode::Create(SkXfermode::kSrcIn_Mode));
+
+    SkRect skBounds = WebCoreFloatRectToSKRect(bounds);
+    saveLayer(&skBounds, &layerPaint);
+
+#if !ASSERT_DISABLED
+    ++m_layerCount;
+#endif
+}
+
+void GraphicsContext::endLayer()

[Stephen White, 2013/08/28 20:16:12]

I guess the name change is this because endLayer() can now be used to end a
transparency layer, or a mask layer? Hmm, ok. I guess I found it a bit more
symmetrical the way it was, but OTOH skia has a similar asymmetry
(saveLayer/save/restore).

 {
     if (paintingDisabled())
         return;
 
     restoreLayer();
 
-    ASSERT(m_transparencyCount > 0);
+    ASSERT(m_layerCount > 0);
 #if !ASSERT_DISABLED
-    --m_transparencyCount;
+    --m_layerCount;
 #endif
 }
 
-void GraphicsContext::clipToImageBuffer(const ImageBuffer* imageBuffer, const FloatRect& rect)
-{
-    if (paintingDisabled())
-        return;
-
-    SkRect bounds = WebCoreFloatRectToSKRect(rect);
-
-    if (imageBuffer->internalSize().isEmpty()) {
-        clipRect(bounds);
-        return;
-    }
-
-    // Skia doesn't support clipping to an image, so we create a layer. The next
-    // time restore is invoked the layer and |imageBuffer| are combined to
-    // create the resulting image.
-    m_state->m_clip = bounds;
-
-    // Get the absolute coordinates of the stored clipping rectangle to make it
-    // independent of any transform changes.
-    getTotalMatrix().mapRect(&m_state->m_clip);
-
-    SkCanvas::SaveFlags saveFlags = static_cast<SkCanvas::SaveFlags>(SkCanvas::kHasAlphaLayer_SaveFlag | SkCanvas::kFullColorLayer_SaveFlag);
-    saveLayer(&bounds, 0, saveFlags);
-
-    const SkBitmap* bitmap = imageBuffer->context()->bitmap();
-
-    if (m_trackOpaqueRegion) {
-        SkRect opaqueRect = bitmap->isOpaque() ? m_state->m_clip : SkRect::MakeEmpty();
-        m_opaqueRegion.setImageMask(opaqueRect);
-    }
-
-    // Copy off the image as |imageBuffer| may be deleted before restore is invoked.
-    if (bitmap->isImmutable())
-        m_state->m_imageBufferClip = *bitmap;
-    else {
-        // We need to make a deep-copy of the pixels themselves, so they don't
-        // change on us between now and when we want to apply them in restore()
-        bitmap->copyTo(&m_state->m_imageBufferClip, SkBitmap::kARGB_8888_Config);
-    }
-}
-
 void GraphicsContext::setupPaintForFilling(SkPaint* paint) const
 {
     if (paintingDisabled())
         return;
 
     setupPaintCommon(paint);
 
     setupShader(paint, m_state->m_fillGradient.get(), m_state->m_fillPattern.get(), m_state->m_fillColor.rgb());
 }
 
@@ skipping 1225 matching lines @@
 #if defined(SK_DEBUG)
     {
         SkPaint defaultPaint;
         SkASSERT(*paint == defaultPaint);
     }
 #endif
 
     paint->setAntiAlias(m_state->m_shouldAntialias);
     paint->setXfermodeMode(m_state->m_xferMode);
     paint->setLooper(m_state->m_looper.get());
+    paint->setColorFilter(m_state->m_colorFilter.get());
 }
 
 void GraphicsContext::drawOuterPath(const SkPath& path, SkPaint& paint, int width)
 {
 #if OS(DARWIN)
     paint.setAlpha(64);
     paint.setStrokeWidth(width);
     paint.setPathEffect(new SkCornerPathEffect((width - 1) * 0.5f))->unref();
 #else
     paint.setStrokeWidth(1);
@@ skipping 131 matching lines @@
     } else if (pat) {
         shader = pat->shader();
         color = SK_ColorBLACK;
         paint->setFilterBitmap(imageInterpolationQuality() != InterpolationNone);
     }
 
     paint->setColor(m_state->applyAlpha(color));
     paint->setShader(shader.get());
 }
 
-
-void GraphicsContext::applyClipFromImage(const SkRect& rect, const SkBitmap& imageBuffer)
-{
-    if (paintingDisabled())
-        return;
-
-    // NOTE: this assumes the image mask contains opaque black for the portions that are to be shown, as such we
-    // only look at the alpha when compositing. I'm not 100% sure this is what WebKit expects for image clipping.
-    SkPaint paint;
-    paint.setXfermodeMode(SkXfermode::kDstIn_Mode);
-    realizeSave(SkCanvas::kMatrixClip_SaveFlag);
-    m_canvas->save(SkCanvas::kMatrix_SaveFlag);
-    m_canvas->resetMatrix();
-    m_canvas->drawBitmapRect(imageBuffer, 0, rect, &paint);
-    m_canvas->restore();
-}
-
 void GraphicsContext::didDrawTextInRect(const SkRect& textRect)
 {
     if (m_trackTextRegion) {
         TRACE_EVENT0("skia", "PlatformContextSkia::trackTextRegion");
         m_textRegion.join(textRect);
     }
 }
 
 }