Canvas 2D: Remove CompositeOperator and WebBlendMode parameters in drawImageInternal().

Source/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 236 matching lines @@
     , 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_globalBlend(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)
 {
@@ skipping 423 matching lines @@
 }
 
 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;
+    WebBlendMode blendMode = 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;
@@ skipping 306 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);
+        fullCanvasCompositedDraw<Fill>(path);
         didDraw(clipBounds);
     } else if (state().m_globalComposite == CompositeCopy) {
         clearCanvas();
         c->fillPath(path);
         didDraw(clipBounds);
     } else {
         FloatRect dirtyRect;
         if (computeDirtyRect(path.boundingRect(), clipBounds, &dirtyRect)) {
             c->fillPath(path);
             didDraw(dirtyRect);
@@ skipping 29 matching lines @@
     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);
+        fullCanvasCompositedDraw<Stroke>(path);
         didDraw(clipBounds);
     } else if (state().m_globalComposite == CompositeCopy) {
         clearCanvas();
         c->strokePath(path);
         didDraw(clipBounds);
     } else {
         FloatRect bounds = path.boundingRect();
         inflateStrokeRect(bounds);
         FloatRect dirtyRect;
         if (computeDirtyRect(bounds, clipBounds, &dirtyRect)) {
@@ skipping 198 matching lines @@
     // 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);
+        fullCanvasCompositedDraw<Fill>(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);
@@ 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;
 
     FloatRect rect(x, y, width, height);
-
     if (isFullCanvasCompositeMode(state().m_globalComposite)) {
-        fullCanvasCompositedStroke(rect);
+        fullCanvasCompositedDraw<Stroke>(rect);
         didDraw(clipBounds);
     } else if (state().m_globalComposite == CompositeCopy) {
         clearCanvas();
         c->strokeRect(rect);
         didDraw(clipBounds);
     } else {
         FloatRect boundingRect = rect;
         boundingRect.inflate(state().m_lineWidth / 2);
         FloatRect dirtyRect;
         if (computeDirtyRect(boundingRect, clipBounds, &dirtyRect)) {
@@ skipping 104 matching lines @@
     srcRect->intersect(imageRect);
 
     // To clip the destination rectangle in the same proportion, transform the clipped src rect
     *dstRect = *srcRect;
     dstRect->scale(scale.width(), scale.height());
     dstRect->move(offset);
 }
 
 void CanvasRenderingContext2D::drawImage(CanvasImageSource* imageSource, float x, float y, ExceptionState& exceptionState)
 {
+    FloatSize sourceRectSize = imageSource->sourceSize();
     FloatSize destRectSize = imageSource->defaultDestinationSize();
-    drawImage(imageSource, x, y, destRectSize.width(), destRectSize.height(), exceptionState);
+    drawImageInternal(imageSource, 0, 0, sourceRectSize.width(), sourceRectSize.height(), x, y, destRectSize.width(), destRectSize.height(), exceptionState);
 }
 
 void CanvasRenderingContext2D::drawImage(CanvasImageSource* imageSource,
     float x, float y, float width, float height, ExceptionState& exceptionState)
 {
     FloatSize sourceRectSize = imageSource->sourceSize();
-    drawImage(imageSource, 0, 0, sourceRectSize.width(), sourceRectSize.height(), x, y, width, height, exceptionState);
+    drawImageInternal(imageSource, 0, 0, sourceRectSize.width(), sourceRectSize.height(), x, y, width, height, exceptionState);
 }
 
 void CanvasRenderingContext2D::drawImage(CanvasImageSource* imageSource,
     float sx, float sy, float sw, float sh,
     float dx, float dy, float dw, float dh, ExceptionState& exceptionState)
 {
-    GraphicsContext* c = drawingContext(); // Do not exit yet if !c because we may need to throw exceptions first
-    CompositeOperator op = c ? c->compositeOperation() : CompositeSourceOver;
-    blink::WebBlendMode blendMode = c ? c->blendModeOperation() : blink::WebBlendModeNormal;
-    drawImageInternal(imageSource, sx, sy, sw, sh, dx, dy, dw, dh, exceptionState, op, blendMode, c);
+    drawImageInternal(imageSource, sx, sy, sw, sh, dx, dy, dw, dh, exceptionState);
 }
 
 void CanvasRenderingContext2D::drawImageInternal(CanvasImageSource* imageSource,
     float sx, float sy, float sw, float sh,
-    float dx, float dy, float dw, float dh, ExceptionState& exceptionState,
-    CompositeOperator op, blink::WebBlendMode blendMode, GraphicsContext* c)
+    float dx, float dy, float dw, float dh, ExceptionState& exceptionState)
 {
     RefPtr<Image> image;
     SourceImageStatus sourceImageStatus = InvalidSourceImageStatus;
     if (!imageSource->isVideoElement()) {
         SourceImageMode mode = canvas() == imageSource ? CopySourceImageIfVolatile : DontCopySourceImage; // Thunking for ==
         image = imageSource->getSourceImageForCanvas(mode, &sourceImageStatus);
         if (sourceImageStatus == UndecodableSourceImageStatus)
             exceptionState.throwDOMException(InvalidStateError, "The HTMLImageElement provided is in the 'broken' state.");
         if (!image || !image->width() || !image->height())
             return;
     }
 
-    if (!c)
-        c = drawingContext();
+    GraphicsContext* c = drawingContext();
     if (!c)
         return;
 
     if (!state().m_invertibleCTM)
         return;
 
     if (!std::isfinite(dx) || !std::isfinite(dy) || !std::isfinite(dw) || !std::isfinite(dh)
         || !std::isfinite(sx) || !std::isfinite(sy) || !std::isfinite(sw) || !std::isfinite(sh)
         || !dw || !dh || !sw || !sh)
         return;
 
     FloatRect clipBounds;
     if (!c->getTransformedClipBounds(&clipBounds))
         return;
 
     FloatRect srcRect = normalizeRect(FloatRect(sx, sy, sw, sh));
     FloatRect dstRect = normalizeRect(FloatRect(dx, dy, dw, dh));
 
     clipRectsToImageRect(FloatRect(FloatPoint(), imageSource->sourceSize()), &srcRect, &dstRect);
 
     imageSource->adjustDrawRects(&srcRect, &dstRect);
 
     if (srcRect.isEmpty())
         return;
 
+    CompositeOperator op = state().m_globalComposite;
+    WebBlendMode blendMode = state().m_globalBlend;
     if (rectContainsTransformedRect(dstRect, clipBounds)) {
         if (!imageSource->isVideoElement()) {
             c->drawImage(image.get(), dstRect, srcRect, op, blendMode);
         } else {
             drawVideo(static_cast<HTMLVideoElement*>(imageSource), srcRect, dstRect);
         }
         didDraw(clipBounds);
     } else if (isFullCanvasCompositeMode(op)) {
-        CompositeOperator previousOperator = c->compositeOperation();
-        WebBlendMode previousBlendMode = c->blendModeOperation();
-        c->setCompositeOperation(previousOperator, blendMode);
         // TODO(dshwang): this code is unnecessarily complicated because beginLayer() uses current blendMode slightly.
         c->beginLayer(1, op);
         if (!imageSource->isVideoElement()) {
             c->drawImage(image.get(), dstRect, srcRect, CompositeSourceOver, WebBlendModeNormal);
         } else {
             c->setCompositeOperation(CompositeSourceOver, WebBlendModeNormal);
             drawVideo(static_cast<HTMLVideoElement*>(imageSource), srcRect, dstRect);
         }
+        c->setCompositeOperation(op, blendMode);
         c->endLayer();
-        c->setCompositeOperation(previousOperator, previousBlendMode);
         didDraw(clipBounds);
     } else if (op == CompositeCopy) {
         clearCanvas();
         if (!imageSource->isVideoElement()) {
             c->drawImage(image.get(), dstRect, srcRect, op, blendMode);
         } else {
             drawVideo(static_cast<HTMLVideoElement*>(imageSource), srcRect, dstRect);
         }
         didDraw(clipBounds);
     } else {
@@ skipping 28 matching lines @@
     validateStateStack();
 }
 
 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);
+    save();
+    setGlobalCompositeOperation(compositeOperation);
+    drawImageInternal(image, sx, sy, sw, sh, dx, dy, dw, dh, IGNORE_EXCEPTION);
+    restore();
 }
 
 void CanvasRenderingContext2D::setAlpha(float alpha)
 {
     setGlobalAlpha(alpha);
 }
 
 void CanvasRenderingContext2D::setCompositeOperation(const String& operation)
 {
     setGlobalCompositeOperation(operation);
@@ skipping 22 matching lines @@
 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)
+template<CanvasRenderingContext2D::DrawingType drawingType, class T> void CanvasRenderingContext2D::fullCanvasCompositedDraw(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);
+    if (drawingType == Fill) {
+        fillPrimitive(area, c);
+    } else {
+        strokePrimitive(area, c);
+    }
     c->setCompositeOperation(previousOperator);
     c->endLayer();
 }
 
 PassRefPtrWillBeRawPtr<CanvasGradient> CanvasRenderingContext2D::createLinearGradient(float x0, float y0, float x1, float y1)
 {
     RefPtrWillBeRawPtr<CanvasGradient> gradient = CanvasGradient::create(FloatPoint(x0, y0), FloatPoint(x1, y1));
     return gradient.release();
 }
 
@@ skipping 614 matching lines @@
     return 0;
 }
 
 void CanvasRenderingContext2D::setIsHidden(bool hidden)
 {
     ImageBuffer* buffer = canvas()->buffer();
     if (buffer)
         buffer->setIsHidden(hidden);
 }
 
-blink::WebLayer* CanvasRenderingContext2D::platformLayer() const
+WebLayer* CanvasRenderingContext2D::platformLayer() const
 {
     return canvas()->buffer() ? canvas()->buffer()->platformLayer() : 0;
 }
 
 bool CanvasRenderingContext2D::imageSmoothingEnabled() const
 {
     return state().m_imageSmoothingEnabled;
 }
 
 void CanvasRenderingContext2D::setImageSmoothingEnabled(bool enabled)
@@ skipping 65 matching lines @@
     StrokeData strokeData;
     strokeData.setThickness(focusRingWidth);
 
     FloatRect dirtyRect;
     if (!computeDirtyRect(path.strokeBoundingRect(strokeData), &dirtyRect))
         return;
 
     c->save();
     c->setAlphaAsFloat(1.0);
     c->clearShadow();
-    c->setCompositeOperation(CompositeSourceOver, blink::WebBlendModeNormal);
+    c->setCompositeOperation(CompositeSourceOver, WebBlendModeNormal);
     c->drawFocusRing(path, focusRingWidth, focusRingOutline, focusRingColor);
     c->restore();
     validateStateStack();
     didDraw(dirtyRect);
 }
 
 void CanvasRenderingContext2D::addHitRegion(const HitRegionOptions& options, ExceptionState& exceptionState)
 {
     if (options.id().isEmpty() && !options.control()) {
         exceptionState.throwDOMException(NotSupportedError, "Both id and control are null.");
@@ skipping 55 matching lines @@
 
 unsigned CanvasRenderingContext2D::hitRegionsCount() const
 {
     if (m_hitRegionManager)
         return m_hitRegionManager->getHitRegionsCount();
 
     return 0;
 }
 
 } // namespace blink