Remove CSSCompositing

sky/engine/core/html/canvas/CanvasRenderingContext2D.cpp

 /*
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2008, 2010 Nokia Corporation and/or its subsidiary(-ies)
  * Copyright (C) 2007 Alp Toker <alp@atoker.com>
  * Copyright (C) 2008 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2008 Dirk Schulze <krit@webkit.org>
  * Copyright (C) 2010 Torch Mobile (Beijing) Co. Ltd. All rights reserved.
  * Copyright (C) 2012, 2013 Intel Corporation. All rights reserved.
  * Copyright (C) 2013 Adobe Systems Incorporated. All rights reserved.
  *
@@ skipping 68 matching lines @@
 static const double TryRestoreContextInterval = 0.5;
 static const unsigned MaxTryRestoreContextAttempts = 4;
 
 static bool contextLostRestoredEventsEnabled()
 {
     return RuntimeEnabledFeatures::experimentalCanvasFeaturesEnabled();
 }
 
 CanvasRenderingContext2D::CanvasRenderingContext2D(HTMLCanvasElement* canvas, const Canvas2DContextAttributes* attrs)
     : CanvasRenderingContext(canvas)
-    , m_hasAlpha(!attrs || attrs->alpha())
     , m_isContextLost(false)
     , m_contextRestorable(true)
     , m_storageMode(!attrs ? PersistentStorage : attrs->parsedStorage())
     , m_tryRestoreContextAttemptCount(0)
     , m_dispatchContextLostEventTimer(this, &CanvasRenderingContext2D::dispatchContextLostEvent)
     , m_dispatchContextRestoredEventTimer(this, &CanvasRenderingContext2D::dispatchContextRestoredEvent)
     , m_tryRestoreContextEventTimer(this, &CanvasRenderingContext2D::tryRestoreContextEvent)
 {
     m_stateStack.append(adoptPtr(new State()));
 }
@@ skipping 131 matching lines @@
 CanvasRenderingContext2D::State::State()
     : m_unrealizedSaveCount(0)
     , m_strokeStyle(CanvasStyle::createFromRGBA(Color::black))
     , m_fillStyle(CanvasStyle::createFromRGBA(Color::black))
     , m_lineWidth(1)
     , m_lineCap(ButtCap)
     , m_lineJoin(MiterJoin)
     , m_miterLimit(10)
     , m_shadowBlur(0)
     , m_shadowColor(Color::transparent)
-    , m_globalAlpha(1)
-    , m_globalComposite(CompositeSourceOver)
-    , m_globalBlend(blink::WebBlendModeNormal)
     , m_invertibleCTM(true)
     , m_lineDashOffset(0)
     , m_imageSmoothingEnabled(true)
     , m_textAlign(StartTextAlign)
     , m_textBaseline(AlphabeticTextBaseline)
     , m_direction(DirectionInherit)
     , m_unparsedFont(defaultFont)
     , m_realizedFont(false)
     , m_hasClip(false)
 {
 }
 
 CanvasRenderingContext2D::State::State(const State& other)
     : CSSFontSelectorClient()
     , m_unrealizedSaveCount(other.m_unrealizedSaveCount)
     , m_unparsedStrokeColor(other.m_unparsedStrokeColor)
     , m_unparsedFillColor(other.m_unparsedFillColor)
     , m_strokeStyle(other.m_strokeStyle)
     , m_fillStyle(other.m_fillStyle)
     , m_lineWidth(other.m_lineWidth)
     , m_lineCap(other.m_lineCap)
     , m_lineJoin(other.m_lineJoin)
     , m_miterLimit(other.m_miterLimit)
     , m_shadowOffset(other.m_shadowOffset)
     , m_shadowBlur(other.m_shadowBlur)
     , m_shadowColor(other.m_shadowColor)
-    , m_globalAlpha(other.m_globalAlpha)
-    , m_globalComposite(other.m_globalComposite)
-    , m_globalBlend(other.m_globalBlend)
     , m_transform(other.m_transform)
     , m_invertibleCTM(other.m_invertibleCTM)
     , m_lineDashOffset(other.m_lineDashOffset)
     , m_imageSmoothingEnabled(other.m_imageSmoothingEnabled)
     , m_textAlign(other.m_textAlign)
     , m_textBaseline(other.m_textBaseline)
     , m_direction(other.m_direction)
     , m_unparsedFont(other.m_unparsedFont)
     , m_font(other.m_font)
     , m_realizedFont(other.m_realizedFont)
@@ skipping 18 matching lines @@
     m_unparsedFillColor = other.m_unparsedFillColor;
     m_strokeStyle = other.m_strokeStyle;
     m_fillStyle = other.m_fillStyle;
     m_lineWidth = other.m_lineWidth;
     m_lineCap = other.m_lineCap;
     m_lineJoin = other.m_lineJoin;
     m_miterLimit = other.m_miterLimit;
     m_shadowOffset = other.m_shadowOffset;
     m_shadowBlur = other.m_shadowBlur;
     m_shadowColor = other.m_shadowColor;
-    m_globalAlpha = other.m_globalAlpha;
-    m_globalComposite = other.m_globalComposite;
-    m_globalBlend = other.m_globalBlend;
     m_transform = other.m_transform;
     m_invertibleCTM = other.m_invertibleCTM;
     m_imageSmoothingEnabled = other.m_imageSmoothingEnabled;
     m_textAlign = other.m_textAlign;
     m_textBaseline = other.m_textBaseline;
     m_direction = other.m_direction;
     m_unparsedFont = other.m_unparsedFont;
     m_font = other.m_font;
     m_realizedFont = other.m_realizedFont;
     m_hasClip = other.m_hasClip;
@@ skipping 315 matching lines @@
 {
     GraphicsContext* c = drawingContext();
     if (!c)
         return;
     DashArray convertedLineDash(state().m_lineDash.size());
     for (size_t i = 0; i < state().m_lineDash.size(); ++i)
         convertedLineDash[i] = static_cast<DashArrayElement>(state().m_lineDash[i]);
     c->setLineDash(convertedLineDash, state().m_lineDashOffset);
 }
 
-float CanvasRenderingContext2D::globalAlpha() const
-{
-    return state().m_globalAlpha;
-}
-
-void CanvasRenderingContext2D::setGlobalAlpha(float alpha)
-{
-    if (!(alpha >= 0 && alpha <= 1))
-        return;
-    if (state().m_globalAlpha == alpha)
-        return;
-    GraphicsContext* c = drawingContext();
-    realizeSaves(c);
-    modifiableState().m_globalAlpha = alpha;
-    if (!c)
-        return;
-    c->setAlphaAsFloat(alpha);
-}
-
-String CanvasRenderingContext2D::globalCompositeOperation() const
-{
-    return compositeOperatorName(state().m_globalComposite, state().m_globalBlend);
-}
-
-void CanvasRenderingContext2D::setGlobalCompositeOperation(const String& operation)
-{
-    CompositeOperator op = CompositeSourceOver;
-    blink::WebBlendMode blendMode = blink::WebBlendModeNormal;
-    if (!parseCompositeAndBlendOperator(operation, op, blendMode))
-        return;
-    if ((state().m_globalComposite == op) && (state().m_globalBlend == blendMode))
-        return;
-    GraphicsContext* c = drawingContext();
-    realizeSaves(c);
-    modifiableState().m_globalComposite = op;
-    modifiableState().m_globalBlend = blendMode;
-    if (!c)
-        return;
-    c->setCompositeOperation(op, blendMode);
-}
-
 void CanvasRenderingContext2D::scale(float sx, float sy)
 {
     GraphicsContext* c = drawingContext();
     if (!c)
         return;
     if (!state().m_invertibleCTM)
         return;
 
     if (!std::isfinite(sx) | !std::isfinite(sy))
         return;
@@ skipping 240 matching lines @@
     }
 
     if (height < 0) {
         height = -height;
         y -= height;
     }
 
     return true;
 }
 
-static bool isFullCanvasCompositeMode(CompositeOperator op)
-{
-    // See 4.8.11.1.3 Compositing
-    // CompositeSourceAtop and CompositeDestinationOut are not listed here as the platforms already
-    // implement the specification's behavior.
-    return op == CompositeSourceIn || op == CompositeSourceOut || op == CompositeDestinationIn || op == CompositeDestinationAtop;
-}
-
 static WindRule parseWinding(const String& windingRuleString)
 {
     if (windingRuleString == "nonzero")
         return RULE_NONZERO;
     if (windingRuleString == "evenodd")
         return RULE_EVENODD;
 
     ASSERT_NOT_REACHED();
     return RULE_EVENODD;
 }
@@ skipping 17 matching lines @@
 
     // If gradient size is zero, then paint nothing.
     Gradient* gradient = c->fillGradient();
     if (gradient && gradient->isZeroSize()) {
         return;
     }
 
     WindRule windRule = c->fillRule();
     c->setFillRule(parseWinding(windingRuleString));
 
-    if (isFullCanvasCompositeMode(state().m_globalComposite)) {
-        fullCanvasCompositedFill(path);
-        didDraw(clipBounds);
-    } else if (state().m_globalComposite == CompositeCopy) {
-        clearCanvas();
+    FloatRect dirtyRect;
+    if (computeDirtyRect(path.boundingRect(), clipBounds, &dirtyRect)) {
         c->fillPath(path);
-        didDraw(clipBounds);
-    } else {
-        FloatRect dirtyRect;
-        if (computeDirtyRect(path.boundingRect(), clipBounds, &dirtyRect)) {
-            c->fillPath(path);
-            didDraw(dirtyRect);
-        }
+        didDraw(dirtyRect);
     }
 
     c->setFillRule(windRule);
 }
 
 void CanvasRenderingContext2D::fill(const String& windingRuleString)
 {
     fillInternal(m_path, windingRuleString);
 }
 
@@ skipping 17 matching lines @@
     FloatRect clipBounds;
     if (!c->getTransformedClipBounds(&clipBounds))
         return;
 
     // If gradient size is zero, then paint nothing.
     Gradient* gradient = c->strokeGradient();
     if (gradient && gradient->isZeroSize()) {
         return;
     }
 
-    if (isFullCanvasCompositeMode(state().m_globalComposite)) {
-        fullCanvasCompositedStroke(path);
-        didDraw(clipBounds);
-    } else if (state().m_globalComposite == CompositeCopy) {
-        clearCanvas();
+    FloatRect bounds = path.boundingRect();
+    inflateStrokeRect(bounds);
+    FloatRect dirtyRect;
+    if (computeDirtyRect(bounds, clipBounds, &dirtyRect)) {
         c->strokePath(path);
-        didDraw(clipBounds);
-    } else {
-        FloatRect bounds = path.boundingRect();
-        inflateStrokeRect(bounds);
-        FloatRect dirtyRect;
-        if (computeDirtyRect(bounds, clipBounds, &dirtyRect)) {
-            c->strokePath(path);
-            didDraw(dirtyRect);
-        }
+        didDraw(dirtyRect);
     }
 }
 
 void CanvasRenderingContext2D::stroke()
 {
     strokeInternal(m_path);
 }
 
 void CanvasRenderingContext2D::stroke(Path2D* domPath)
 {
@@ skipping 135 matching lines @@
     FloatRect dirtyRect;
     if (!computeDirtyRect(rect, &dirtyRect))
         return;
 
     bool saved = false;
     if (shouldDrawShadows()) {
         context->save();
         saved = true;
         context->clearShadow();
     }
-    if (state().m_globalAlpha != 1) {
-        if (!saved) {
-            context->save();
-            saved = true;
-        }
-        context->setAlphaAsFloat(1);
-    }
-    if (state().m_globalComposite != CompositeSourceOver) {
-        if (!saved) {
-            context->save();
-            saved = true;
-        }
-        context->setCompositeOperation(CompositeSourceOver);
-    }
     context->clearRect(rect);
     if (m_hitRegionManager)
         m_hitRegionManager->removeHitRegionsInRect(rect, state().m_transform);
     if (saved)
         context->restore();
 
     validateStateStack();
     didDraw(dirtyRect);
 }
 
@@ skipping 15 matching lines @@
     // If x0 = x1 and y0 = y1, then the linear gradient must paint nothing
     // If x0 = x1 and y0 = y1 and r0 = r1, then the radial gradient must paint nothing
     Gradient* gradient = c->fillGradient();
     if (gradient && gradient->isZeroSize())
         return;
 
     FloatRect rect(x, y, width, height);
     if (rectContainsTransformedRect(rect, clipBounds)) {
         c->fillRect(rect);
         didDraw(clipBounds);
-    } else if (isFullCanvasCompositeMode(state().m_globalComposite)) {
-        fullCanvasCompositedFill(rect);
-        didDraw(clipBounds);
-    } else if (state().m_globalComposite == CompositeCopy) {
-        clearCanvas();
-        c->fillRect(rect);
-        didDraw(clipBounds);
     } else {
         FloatRect dirtyRect;
         if (computeDirtyRect(rect, clipBounds, &dirtyRect)) {
             c->fillRect(rect);
             didDraw(dirtyRect);
         }
     }
 }
 
 void CanvasRenderingContext2D::strokeRect(float x, float y, float width, float height)
@@ skipping 13 matching lines @@
     if (!c->getTransformedClipBounds(&clipBounds))
         return;
 
     // If gradient size is zero, then paint nothing.
     Gradient* gradient = c->strokeGradient();
     if (gradient && gradient->isZeroSize())
         return;
 
     FloatRect rect(x, y, width, height);
 
-    if (isFullCanvasCompositeMode(state().m_globalComposite)) {
-        fullCanvasCompositedStroke(rect);
-        didDraw(clipBounds);
-    } else if (state().m_globalComposite == CompositeCopy) {
-        clearCanvas();
+    FloatRect boundingRect = rect;
+    boundingRect.inflate(state().m_lineWidth / 2);
+    FloatRect dirtyRect;
+    if (computeDirtyRect(boundingRect, clipBounds, &dirtyRect)) {
         c->strokeRect(rect);
-        didDraw(clipBounds);
-    } else {
-        FloatRect boundingRect = rect;
-        boundingRect.inflate(state().m_lineWidth / 2);
-        FloatRect dirtyRect;
-        if (computeDirtyRect(boundingRect, clipBounds, &dirtyRect)) {
-            c->strokeRect(rect);
-            didDraw(dirtyRect);
-        }
+        didDraw(dirtyRect);
     }
 }
 
 void CanvasRenderingContext2D::setShadow(float width, float height, float blur)
 {
     setShadow(FloatSize(width, height), blur, Color::transparent);
 }
 
 void CanvasRenderingContext2D::setShadow(float width, float height, float blur, const String& color)
 {
@@ skipping 158 matching lines @@
     clipRectsToImageRect(FloatRect(FloatPoint(), imageSource->sourceSize()), &srcRect, &dstRect);
 
     imageSource->adjustDrawRects(&srcRect, &dstRect);
 
     if (srcRect.isEmpty())
         return;
 
     FloatRect dirtyRect = clipBounds;
     if (rectContainsTransformedRect(dstRect, clipBounds)) {
         c->drawImage(image.get(), dstRect, srcRect, op, blendMode);
-    } else if (isFullCanvasCompositeMode(op)) {
-        fullCanvasCompositedDrawImage(image.get(), dstRect, srcRect, op);
-    } else if (op == CompositeCopy) {
-        clearCanvas();
-        c->drawImage(image.get(), dstRect, srcRect, op, blendMode);
     } else {
         FloatRect dirtyRect;
         computeDirtyRect(dstRect, clipBounds, &dirtyRect);
         c->drawImage(image.get(), dstRect, srcRect, op, blendMode);
     }
 
     if (sourceImageStatus == ExternalSourceImageStatus && isAccelerated() && canvas()->buffer())
         canvas()->buffer()->flush();
 
     didDraw(dirtyRect);
 }
 
 void CanvasRenderingContext2D::drawImageFromRect(HTMLImageElement* image,
     float sx, float sy, float sw, float sh,
     float dx, float dy, float dw, float dh,
     const String& compositeOperation)
 {
     if (!image)
         return;
     CompositeOperator op;
     blink::WebBlendMode blendOp = blink::WebBlendModeNormal;
     if (!parseCompositeAndBlendOperator(compositeOperation, op, blendOp) || blendOp != blink::WebBlendModeNormal)
         op = CompositeSourceOver;
 
     drawImageInternal(image, sx, sy, sw, sh, dx, dy, dw, dh, IGNORE_EXCEPTION, op, blendOp);
 }
 
-void CanvasRenderingContext2D::setAlpha(float alpha)
-{
-    setGlobalAlpha(alpha);
-}
-
-void CanvasRenderingContext2D::setCompositeOperation(const String& operation)
-{
-    setGlobalCompositeOperation(operation);
-}
-
 void CanvasRenderingContext2D::clearCanvas()
 {
     FloatRect canvasRect(0, 0, canvas()->width(), canvas()->height());
     GraphicsContext* c = drawingContext();
     if (!c)
         return;
 
     c->save();
     c->setCTM(canvas()->baseTransform());
     c->clearRect(canvasRect);
     c->restore();
 }
 
 bool CanvasRenderingContext2D::rectContainsTransformedRect(const FloatRect& rect, const FloatRect& transformedRect) const
 {
     FloatQuad quad(rect);
     FloatQuad transformedQuad(transformedRect);
     return state().m_transform.mapQuad(quad).containsQuad(transformedQuad);
 }
 
-static void drawImageToContext(Image* image, GraphicsContext* context, const FloatRect& dest, const FloatRect& src, CompositeOperator op)
-{
-    context->drawImage(image, dest, src, op);
-}
-
-template<class T> void  CanvasRenderingContext2D::fullCanvasCompositedDrawImage(T* image, const FloatRect& dest, const FloatRect& src, CompositeOperator op)
-{
-    ASSERT(isFullCanvasCompositeMode(op));
-
-    GraphicsContext* c = drawingContext();
-    c->beginLayer(1, op);
-    drawImageToContext(image, c, dest, src, CompositeSourceOver);
-    c->endLayer();
-}
-
-static void fillPrimitive(const FloatRect& rect, GraphicsContext* context)
-{
-    context->fillRect(rect);
-}
-
-static void fillPrimitive(const Path& path, GraphicsContext* context)
-{
-    context->fillPath(path);
-}
-
-template<class T> void CanvasRenderingContext2D::fullCanvasCompositedFill(const T& area)
-{
-    ASSERT(isFullCanvasCompositeMode(state().m_globalComposite));
-
-    GraphicsContext* c = drawingContext();
-    ASSERT(c);
-    c->beginLayer(1, state().m_globalComposite);
-    CompositeOperator previousOperator = c->compositeOperation();
-    c->setCompositeOperation(CompositeSourceOver);
-    fillPrimitive(area, c);
-    c->setCompositeOperation(previousOperator);
-    c->endLayer();
-}
-
-static void strokePrimitive(const FloatRect& rect, GraphicsContext* context)
-{
-    context->strokeRect(rect);
-}
-
-static void strokePrimitive(const Path& path, GraphicsContext* context)
-{
-    context->strokePath(path);
-}
-
-template<class T> void CanvasRenderingContext2D::fullCanvasCompositedStroke(const T& area)
-{
-    ASSERT(isFullCanvasCompositeMode(state().m_globalComposite));
-
-    GraphicsContext* c = drawingContext();
-    ASSERT(c);
-    c->beginLayer(1, state().m_globalComposite);
-    CompositeOperator previousOperator = c->compositeOperation();
-    c->setCompositeOperation(CompositeSourceOver);
-    strokePrimitive(area, c);
-    c->setCompositeOperation(previousOperator);
-    c->endLayer();
-}
-
 PassRefPtr<CanvasGradient> CanvasRenderingContext2D::createLinearGradient(float x0, float y0, float x1, float y1)
 {
     RefPtr<CanvasGradient> gradient = CanvasGradient::create(FloatPoint(x0, y0), FloatPoint(x1, y1));
     return gradient.release();
 }
 
 PassRefPtr<CanvasGradient> CanvasRenderingContext2D::createRadialGradient(float x0, float y0, float r0, float x1, float y1, float r1, ExceptionState& exceptionState)
 {
     if (r0 < 0 || r1 < 0) {
         exceptionState.throwDOMException(IndexSizeError, String::format("The %s provided is less than 0.", r0 < 0 ? "r0" : "r1"));
@@ skipping 551 matching lines @@
         // We draw when fontWidth is 0 so compositing operations (eg, a "copy" op) still work.
         c->scale((fontWidth > 0 ? (width / fontWidth) : 0), 1);
         location = FloatPoint();
     }
 
     FloatRect clipBounds;
     if (!c->getTransformedClipBounds(&clipBounds)) {
         return;
     }
 
-    if (isFullCanvasCompositeMode(state().m_globalComposite)) {
-        c->beginLayer(1, state().m_globalComposite);
-        CompositeOperator previousOperator = c->compositeOperation();
-        c->setCompositeOperation(CompositeSourceOver);
+    FloatRect dirtyRect;
+    if (computeDirtyRect(textRunPaintInfo.bounds, clipBounds, &dirtyRect)) {
         c->drawBidiText(font, textRunPaintInfo, location, Font::UseFallbackIfFontNotReady);
-        c->setCompositeOperation(previousOperator);
-        c->endLayer();
-        didDraw(clipBounds);
-    } else if (state().m_globalComposite == CompositeCopy) {
-        clearCanvas();
-        c->drawBidiText(font, textRunPaintInfo, location, Font::UseFallbackIfFontNotReady);
-        didDraw(clipBounds);
-    } else {
-        FloatRect dirtyRect;
-        if (computeDirtyRect(textRunPaintInfo.bounds, clipBounds, &dirtyRect)) {
-            c->drawBidiText(font, textRunPaintInfo, location, Font::UseFallbackIfFontNotReady);
-            didDraw(dirtyRect);
-        }
+        didDraw(dirtyRect);
     }
 }
 
 void CanvasRenderingContext2D::inflateStrokeRect(FloatRect& rect) const
 {
     // Fast approximation of the stroke's bounding rect.
     // This yields a slightly oversized rect but is very fast
     // compared to Path::strokeBoundingRect().
     static const float root2 = sqrtf(2);
     float delta = state().m_lineWidth / 2;
@@ skipping 61 matching lines @@
     GraphicsContext* c = drawingContext();
     realizeSaves(c);
     modifiableState().m_imageSmoothingEnabled = enabled;
     if (c)
         c->setImageInterpolationQuality(enabled ? CanvasDefaultInterpolationQuality : InterpolationNone);
 }
 
 PassRefPtr<Canvas2DContextAttributes> CanvasRenderingContext2D::getContextAttributes() const
 {
     RefPtr<Canvas2DContextAttributes> attributes = Canvas2DContextAttributes::create();
-    attributes->setAlpha(m_hasAlpha);
     return attributes.release();
 }
 
 void CanvasRenderingContext2D::drawFocusIfNeeded(Element* element)
 {
     drawFocusIfNeededInternal(m_path, element);
 }
 
 void CanvasRenderingContext2D::drawFocusIfNeeded(Path2D* path2d, Element* element)
 {
@@ skipping 141 matching lines @@
 
 unsigned CanvasRenderingContext2D::hitRegionsCount() const
 {
     if (m_hitRegionManager)
         return m_hitRegionManager->getHitRegionsCount();
 
     return 0;
 }
 
 } // namespace blink