Maintain SkPaint in GraphicsContextState.

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 120 matching lines @@
 {
     // 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();
 }
 
 GraphicsContext::~GraphicsContext()
 {
     ASSERT(!m_paintStateIndex);
-    ASSERT(!m_paintState->m_saveCount);
+    ASSERT(!m_paintState->saveCount());
     ASSERT(!m_annotationCount);
     ASSERT(!m_layerCount);
     ASSERT(m_recordingStateStack.isEmpty());
 }
 
 const SkBitmap* GraphicsContext::bitmap() const
 {
     TRACE_EVENT0("skia", "GraphicsContext::bitmap");
     return &m_canvas->getDevice()->accessBitmap(false);
 }
 
 const SkBitmap& GraphicsContext::layerBitmap(AccessMode access) const
 {
     return m_canvas->getTopDevice()->accessBitmap(access == ReadWrite);
 }
 
 void GraphicsContext::save()
 {
     if (paintingDisabled())
         return;
 
-    m_paintState->m_saveCount++;
+    m_paintState->incrementSaveCount();
 
     m_canvasStateStack.append(CanvasSaveState(m_canvasSaveFlags, m_canvas->getSaveCount()));
     m_canvasSaveFlags |= SkCanvas::kMatrixClip_SaveFlag;
 }
 
 void GraphicsContext::restore()
 {
     if (paintingDisabled())
         return;
 
-    if (!m_paintStateIndex && !m_paintState->m_saveCount) {
+    if (!m_paintStateIndex && !m_paintState->saveCount()) {
         WTF_LOG_ERROR("ERROR void GraphicsContext::restore() stack is empty");
         return;
     }
 
-    if (m_paintState->m_saveCount) {
-        m_paintState->m_saveCount--;
+    if (m_paintState->saveCount()) {
+        m_paintState->decrementSaveCount();
     } else {
         m_paintStateIndex--;
         m_paintState = m_paintStateStack[m_paintStateIndex].get();
     }
 
     CanvasSaveState savedState = m_canvasStateStack.last();
     m_canvasStateStack.removeLast();
     m_canvasSaveFlags = savedState.m_flags;
     m_canvas->restoreToCount(savedState.m_restoreCount);
 }
@@ skipping 49 matching lines @@
         return;
 
     canvas()->endCommentGroup();
 
     ASSERT(m_annotationCount > 0);
 #if !ASSERT_DISABLED
     --m_annotationCount;
 #endif
 }
 
-void GraphicsContext::setStrokeColor(const Color& color)
-{
-    GraphicsContextState* stateToSet = mutableState();
-    stateToSet->m_strokeData.setColor(color);
-    stateToSet->m_strokeData.clearGradient();
-    stateToSet->m_strokeData.clearPattern();
-}
-
 void GraphicsContext::setStrokePattern(PassRefPtr<Pattern> pattern)
 {
     if (paintingDisabled())
         return;
 
     ASSERT(pattern);
     if (!pattern) {
         setStrokeColor(Color::black);
         return;
     }
-    GraphicsContextState* stateToSet = mutableState();
-    stateToSet->m_strokeData.clearGradient();
-    stateToSet->m_strokeData.setPattern(pattern);
+    mutableState()->setStrokePattern(pattern);
 }
 
 void GraphicsContext::setStrokeGradient(PassRefPtr<Gradient> gradient)
 {
     if (paintingDisabled())
         return;
 
     ASSERT(gradient);
     if (!gradient) {
         setStrokeColor(Color::black);
         return;
     }
-    GraphicsContextState* stateToSet = mutableState();
-    stateToSet->m_strokeData.setGradient(gradient);
-    stateToSet->m_strokeData.clearPattern();
-}
-
-void GraphicsContext::setFillColor(const Color& color)
-{
-    GraphicsContextState* stateToSet = mutableState();
-    stateToSet->m_fillColor = color;
-    stateToSet->m_fillGradient.clear();
-    stateToSet->m_fillPattern.clear();
+    mutableState()->setStrokeGradient(gradient);
 }
 
 void GraphicsContext::setFillPattern(PassRefPtr<Pattern> pattern)
 {
     if (paintingDisabled())
         return;
 
     ASSERT(pattern);
     if (!pattern) {
         setFillColor(Color::black);
         return;
     }
 
-    GraphicsContextState* stateToSet = mutableState();
-    stateToSet->m_fillGradient.clear();
-    stateToSet->m_fillPattern = pattern;
+    mutableState()->setFillPattern(pattern);
 }
 
 void GraphicsContext::setFillGradient(PassRefPtr<Gradient> gradient)
 {
     if (paintingDisabled())
         return;
 
     ASSERT(gradient);
     if (!gradient) {
         setFillColor(Color::black);
         return;
     }
 
-    GraphicsContextState* stateToSet = mutableState();
-    stateToSet->m_fillGradient = gradient;
-    stateToSet->m_fillPattern.clear();
+    mutableState()->setFillGradient(gradient);
 }
 
 void GraphicsContext::setShadow(const FloatSize& offset, float blur, const Color& color,
     DrawLooperBuilder::ShadowTransformMode shadowTransformMode,
     DrawLooperBuilder::ShadowAlphaMode shadowAlphaMode)
 {
     if (paintingDisabled())
         return;
 
     if (!color.alpha() || (!offset.width() && !offset.height() && !blur)) {
         clearShadow();
         return;
     }
 
     OwnPtr<DrawLooperBuilder> drawLooperBuilder = DrawLooperBuilder::create();
     drawLooperBuilder->addShadow(offset, blur, color, shadowTransformMode, shadowAlphaMode);
     drawLooperBuilder->addUnmodifiedContent();
     setDrawLooper(drawLooperBuilder.release());
 }
 
 void GraphicsContext::setDrawLooper(PassOwnPtr<DrawLooperBuilder> drawLooperBuilder)
 {
     if (paintingDisabled())
         return;
 
-    mutableState()->m_looper = drawLooperBuilder->detachDrawLooper();
+    mutableState()->setDrawLooper(drawLooperBuilder->detachDrawLooper());
 }
 
 void GraphicsContext::clearDrawLooper()
 {
     if (paintingDisabled())
         return;
 
-    mutableState()->m_looper.clear();
+    mutableState()->clearDrawLooper();
 }
 
 bool GraphicsContext::hasShadow() const
 {
-    return !!immutableState()->m_looper;
-}
-
-int GraphicsContext::getNormalizedAlpha() const
-{
-    int alpha = roundf(immutableState()->m_alpha * 256);
-    if (alpha > 255)
-        alpha = 255;
-    else if (alpha < 0)
-        alpha = 0;
-    return alpha;
+    return !!immutableState()->drawLooper();
 }
 
 FloatRect GraphicsContext::getClipBounds() const
 {
     if (paintingDisabled())
         return FloatRect();
     SkRect rect;
     if (!m_canvas->getClipBounds(&rect))
         return FloatRect();
     return FloatRect(rect);
@@ skipping 51 matching lines @@
     // collapsed. Therefore, subpixel text is disabled when we are drawing
     // onto a layer.
     if (paintingDisabled() || isDrawingToLayer() || !isCertainlyOpaque())
         return false;
 
     return shouldSmoothFonts();
 }
 
 void GraphicsContext::setCompositeOperation(CompositeOperator compositeOperation, WebBlendMode blendMode)
 {
-    GraphicsContextState* stateToSet = mutableState();
-    stateToSet->m_compositeOperator = compositeOperation;
-    stateToSet->m_blendMode = blendMode;
-    stateToSet->m_xferMode = WebCoreCompositeToSkiaComposite(compositeOperation, blendMode);
+    mutableState()->setCompositeOperation(compositeOperation, blendMode);
 }
 
 SkColorFilter* GraphicsContext::colorFilter()
 {
-    return immutableState()->m_colorFilter.get();
+    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,
     // we should switch to using color filter chains (Skia work in progress).
-    ASSERT(!stateToSet->m_colorFilter);
-    stateToSet->m_colorFilter = WebCoreColorFilterToSkiaColorFilter(colorFilter);
+    ASSERT(!stateToSet->colorFilter());
+    stateToSet->setColorFilter(WebCoreColorFilterToSkiaColorFilter(colorFilter));
 }
 
 bool GraphicsContext::readPixels(SkBitmap* bitmap, int x, int y, SkCanvas::Config8888 config8888)
 {
     if (paintingDisabled())
         return false;
 
     return m_canvas->readPixels(bitmap, x, y, config8888);
 }
 
@@ skipping 16 matching lines @@
     if (matrix.isIdentity())
         return true;
 
     realizeCanvasSave(SkCanvas::kMatrix_SaveFlag);
 
     return m_canvas->concat(matrix);
 }
 
 void GraphicsContext::beginTransparencyLayer(float opacity, const FloatRect* bounds)
 {
-    beginLayer(opacity, immutableState()->m_compositeOperator, bounds);
+    beginLayer(opacity, immutableState()->compositeOperator(), bounds);
 }
 
 void GraphicsContext::beginLayer(float opacity, CompositeOperator op, const FloatRect* bounds, ColorFilter colorFilter, ImageFilter* imageFilter)
 {
     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.setXfermode(WebCoreCompositeToSkiaComposite(op, m_paintState->m_blendMode).get());
+    layerPaint.setXfermode(WebCoreCompositeToSkiaComposite(op, m_paintState->blendMode()).get());
     layerPaint.setColorFilter(WebCoreColorFilterToSkiaColorFilter(colorFilter).get());
     layerPaint.setImageFilter(imageFilter);
 
     // Filters will adjust the clip to accomodate for filter bounds, but
     // need the kClipToLayer_SaveFlag to do so. We also save the clip here, so
     // it is restored back before the filtered layer is drawn in restore().
     // The matrix also needs to be saved, in order to be correctly passed to
     // the filter CTM during restore().
     if (imageFilter)
         saveFlags = SkCanvas::kARGB_ClipLayer_SaveFlag;
@@ skipping 82 matching lines @@
 
     if (bounds.x() || bounds.y())
         m_canvas->translate(-bounds.x(), -bounds.y());
 }
 
 void GraphicsContext::setupPaintForFilling(SkPaint* paint) const
 {
     if (paintingDisabled())
         return;
 
-    setupPaintCommon(paint);
-
-    setupShader(paint, immutableState()->m_fillGradient.get(), immutableState()->m_fillPattern.get(), immutableState()->m_fillColor.rgb());
+    *paint = immutableState()->fillPaint();
 }
 
-float GraphicsContext::setupPaintForStroking(SkPaint* paint, int length) const
+void GraphicsContext::setupPaintForStroking(SkPaint* paint, int length) const
 {
     if (paintingDisabled())
-        return 0.0f;
+        return;
 
-    setupPaintCommon(paint);
-
-    setupShader(paint, immutableState()->m_strokeData.gradient(), immutableState()->m_strokeData.pattern(),
-        immutableState()->m_strokeData.color().rgb());
-
-    return immutableState()->m_strokeData.setupPaint(paint, length);
+    *paint = immutableState()->strokePaint();
+    immutableState()->strokeData().setupPaintDashPathEffect(paint, length);

[Stephen White, 2014/03/04 15:24:13]

Seems a little surprising not to handle this automatically (see below).

 }
 
 void GraphicsContext::drawConvexPolygon(size_t numPoints, const FloatPoint* points, bool shouldAntialias)
 {
     if (paintingDisabled())
         return;
 
     if (numPoints <= 1)
         return;
 
@@ skipping 357 matching lines @@
 void GraphicsContext::drawRect(const IntRect& rect)
 {
     if (paintingDisabled())
         return;
 
     ASSERT(!rect.isEmpty());
     if (rect.isEmpty())
         return;
 
     SkRect skRect = rect;
-    SkPaint paint;
-    int fillcolorNotTransparent = m_paintState->m_fillColor.rgb() & 0xFF000000;
-    if (fillcolorNotTransparent) {
-        setupPaintForFilling(&paint);
-        drawRect(skRect, paint);
-    }
+    int fillcolorNotTransparent = immutableState()->fillColor().rgb() & 0xFF000000;
+    if (fillcolorNotTransparent)
+        drawRect(skRect, immutableState()->fillPaint());
 
-    if (m_paintState->m_strokeData.style() != NoStroke && (m_paintState->m_strokeData.color().rgb() & 0xFF000000)) {
+    if (immutableState()->strokeData().style() != NoStroke && (immutableState()->strokeData().color().rgb() & 0xFF000000)) {
         // We do a fill of four rects to simulate the stroke of a border.
-        paint.reset();
+        SkPaint paint;
         setupPaintForFilling(&paint);

[Stephen White, 2014/03/04 15:24:13]

IIRC, Florin's patch should get rid of this one; maybe we can get rid of
setupPaintForFilling altogether after that? (Or at least the calls from
GraphicsContext.)

         // need to jam in the strokeColor
-        paint.setColor(this->effectiveStrokeColor());
+        paint.setColor(immutableState()->effectiveStrokeColor());
 
         SkRect topBorder = { skRect.fLeft, skRect.fTop, skRect.fRight, skRect.fTop + 1 };
         drawRect(topBorder, paint);
         SkRect bottomBorder = { skRect.fLeft, skRect.fBottom - 1, skRect.fRight, skRect.fBottom };
         drawRect(bottomBorder, paint);
         SkRect leftBorder = { skRect.fLeft, skRect.fTop + 1, skRect.fLeft + 1, skRect.fBottom - 1 };
         drawRect(leftBorder, paint);
         SkRect rightBorder = { skRect.fRight - 1, skRect.fTop + 1, skRect.fRight, skRect.fBottom - 1 };
         drawRect(rightBorder, paint);
     }
@@ skipping 222 matching lines @@
         m_opaqueRegion.didDrawRect(this, rect, *paint, &bitmap);
     }
 }
 
 void GraphicsContext::drawBitmapRect(const SkBitmap& bitmap, const SkRect* src,
     const SkRect& dst, const SkPaint* paint)
 {
     if (paintingDisabled())
         return;
 
-    SkCanvas::DrawBitmapRectFlags flags = m_paintState->m_shouldClampToSourceRect ? SkCanvas::kNone_DrawBitmapRectFlag : SkCanvas::kBleed_DrawBitmapRectFlag;
+    SkCanvas::DrawBitmapRectFlags flags =
+        immutableState()->shouldClampToSourceRect() ? SkCanvas::kNone_DrawBitmapRectFlag : SkCanvas::kBleed_DrawBitmapRectFlag;
 
     m_canvas->drawBitmapRectToRect(bitmap, src, dst, paint, flags);
 
     if (m_trackOpaqueRegion)
         m_opaqueRegion.didDrawRect(this, dst, *paint, &bitmap);
 }
 
 void GraphicsContext::drawOval(const SkRect& oval, const SkPaint& paint)
 {
     if (paintingDisabled())
@@ skipping 77 matching lines @@
 
 void GraphicsContext::fillPath(const Path& pathToFill)
 {
     if (paintingDisabled() || pathToFill.isEmpty())
         return;
 
     // Use const_cast and temporarily modify the fill type instead of copying the path.
     SkPath& path = const_cast<SkPath&>(pathToFill.skPath());
     SkPath::FillType previousFillType = path.getFillType();
 
-    SkPath::FillType temporaryFillType = m_paintState->m_fillRule == RULE_EVENODD ? SkPath::kEvenOdd_FillType : SkPath::kWinding_FillType;
+    SkPath::FillType temporaryFillType =
+        immutableState()->fillRule() == RULE_EVENODD ? SkPath::kEvenOdd_FillType : SkPath::kWinding_FillType;
     path.setFillType(temporaryFillType);
 
-    SkPaint paint;
-    setupPaintForFilling(&paint);
-    drawPath(path, paint);
+    drawPath(path, immutableState()->fillPaint());
 
     path.setFillType(previousFillType);
 }
 
 void GraphicsContext::fillRect(const FloatRect& rect)
 {
     if (paintingDisabled())
         return;
 
     SkRect r = rect;
 
-    SkPaint paint;
-    setupPaintForFilling(&paint);
-    drawRect(r, paint);
+    drawRect(r, immutableState()->fillPaint());
 }
 
 void GraphicsContext::fillRect(const FloatRect& rect, const Color& color)
 {
     if (paintingDisabled())
         return;
 
     SkRect r = rect;
     SkPaint paint;
-    setupPaintCommon(&paint);
+    paint.setAntiAlias(immutableState()->shouldAntialias());
+    if (!SkXfermode::IsMode(immutableState()->xferMode(), SkXfermode::kSrcOver_Mode))
+        paint.setXfermode(immutableState()->xferMode());
+    if (immutableState()->drawLooper())
+        paint.setLooper(immutableState()->drawLooper());
+    paint.setColorFilter(immutableState()->colorFilter());

[f(malita), 2014/03/03 22:46:21]

Why does this paint need special handling? (why not just use fillPaint?)

[Stephen Chennney, 2014/03/04 13:20:36]

It doesn't (apart from the color at the end). I must have overlooked it.

[Stephen Chennney, 2014/03/04 14:47:10]

Done.

     paint.setColor(color.rgb());
     drawRect(r, paint);
 }
 
 void GraphicsContext::fillRoundedRect(const IntRect& rect, const IntSize& topLeft, const IntSize& topRight,
     const IntSize& bottomLeft, const IntSize& bottomRight, const Color& color)
 {
     if (paintingDisabled())
         return;
 
@@ skipping 23 matching lines @@
     if (m_trackOpaqueRegion)
         m_opaqueRegion.didDrawBounded(this, rr.getBounds(), paint);
 }
 
 void GraphicsContext::fillEllipse(const FloatRect& ellipse)
 {
     if (paintingDisabled())
         return;
 
     SkRect rect = ellipse;
-    SkPaint paint;
-    setupPaintForFilling(&paint);
-    drawOval(rect, paint);
+    drawOval(rect, immutableState()->fillPaint());
 }
 
 void GraphicsContext::strokePath(const Path& pathToStroke)
 {
     if (paintingDisabled() || pathToStroke.isEmpty())
         return;
 
     const SkPath& path = pathToStroke.skPath();
     SkPaint paint;
     setupPaintForStroking(&paint);
@@ skipping 381 matching lines @@
         But webkit can sometimes send us non-convex 4-point values, so we mark the path's
         convexity as unknown, so it will get computed by skia at draw time.
         See crbug.com 108605
     */
     SkPath::Convexity convexity = SkPath::kConvex_Convexity;
     if (numPoints == 4)
         convexity = SkPath::kUnknown_Convexity;
     path->setConvexity(convexity);
 }
 
-void GraphicsContext::setupPaintCommon(SkPaint* paint) const
-{
-#if defined(SK_DEBUG)
-    {
-        SkPaint defaultPaint;
-        SkASSERT(*paint == defaultPaint);
-    }
-#endif
-
-    paint->setAntiAlias(m_paintState->m_shouldAntialias);
-
-    if (!SkXfermode::IsMode(m_paintState->m_xferMode.get(), SkXfermode::kSrcOver_Mode))
-        paint->setXfermode(m_paintState->m_xferMode.get());
-
-    if (m_paintState->m_looper)
-        paint->setLooper(m_paintState->m_looper.get());
-
-    paint->setColorFilter(m_paintState->m_colorFilter.get());
-}
-
 void GraphicsContext::drawOuterPath(const SkPath& path, SkPaint& paint, int width)
 {
 #if OS(MACOSX)
     paint.setAlpha(64);
     paint.setStrokeWidth(width);
     paint.setPathEffect(new SkCornerPathEffect((width - 1) * 0.5f))->unref();
 #else
     paint.setStrokeWidth(1);
     paint.setPathEffect(new SkCornerPathEffect(1))->unref();
 #endif
@@ skipping 131 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
 
-void GraphicsContext::setupShader(SkPaint* paint, Gradient* grad, Pattern* pat, SkColor color) const
-{
-    RefPtr<SkShader> shader;
-
-    if (grad) {
-        shader = grad->shader();
-        color = SK_ColorBLACK;
-    } else if (pat) {
-        shader = pat->shader();
-        color = SK_ColorBLACK;
-        paint->setFilterBitmap(imageInterpolationQuality() != InterpolationNone);
-    }
-
-    paint->setColor(m_paintState->applyAlpha(color));
-
-    if (!shader)
-        return;
-
-    paint->setShader(shader.get());
-}
-
 void GraphicsContext::didDrawTextInRect(const SkRect& textRect)
 {
     if (m_trackTextRegion) {
         TRACE_EVENT0("skia", "PlatformContextSkia::trackTextRegion");
         m_textRegion.join(textRect);
     }
 }
 
 }