Use SkXfermode::Mode in code related to Image.

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 17 matching lines @@
 #include "platform/graphics/GraphicsContext.h"
 
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/TraceEvent.h"
 #include "platform/geometry/IntRect.h"
 #include "platform/graphics/BitmapImage.h"
 #include "platform/graphics/Gradient.h"
 #include "platform/graphics/GraphicsContextClient.h"
 #include "platform/graphics/ImageBuffer.h"
 #include "platform/graphics/UnacceleratedImageBufferSurface.h"
-#include "platform/graphics/skia/SkiaUtils.h"
 #include "platform/text/BidiResolver.h"
 #include "platform/text/TextRunIterator.h"
 #include "platform/weborigin/KURL.h"
 #include "third_party/skia/include/core/SkAnnotation.h"
 #include "third_party/skia/include/core/SkClipStack.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/SkPicture.h"
 #include "third_party/skia/include/core/SkPictureRecorder.h"
@@ skipping 383 matching lines @@
 SkXfermode::Mode GraphicsContext::compositeOperation() const
 {
     return immutableState()->compositeOperation();
 }
 
 CompositeOperator GraphicsContext::compositeOperationDeprecated() const
 {
     return compositeOperatorFromSkia(immutableState()->compositeOperation());
 }
 
-WebBlendMode GraphicsContext::blendModeOperation() const
-{
-    return blendModeFromSkia(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 609 matching lines @@
 }
 
 void GraphicsContext::drawHighlightForText(const Font& font, const TextRun& run, const FloatPoint& point, int h, const Color& backgroundColor, int from, int to)
 {
     if (contextDisabled())
         return;
 
     fillRect(font.selectionRectForText(run, point, h, from, to), backgroundColor);
 }
 
-void GraphicsContext::drawImage(Image* image, const IntPoint& p, CompositeOperator op, RespectImageOrientationEnum shouldRespectImageOrientation)
+void GraphicsContext::drawImage(Image* image, const IntPoint& p, SkXfermode::Mode op, RespectImageOrientationEnum shouldRespectImageOrientation)
 {
     if (!image)
         return;
     drawImage(image, FloatRect(IntRect(p, image->size())), FloatRect(FloatPoint(), FloatSize(image->size())), op, shouldRespectImageOrientation);
 }
 
-void GraphicsContext::drawImage(Image* image, const IntRect& r, CompositeOperator op, RespectImageOrientationEnum shouldRespectImageOrientation)
+void GraphicsContext::drawImage(Image* image, const IntRect& r, SkXfermode::Mode op, RespectImageOrientationEnum shouldRespectImageOrientation)
 {
     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, CompositeOperator op, RespectImageOrientationEnum shouldRespectImageOrientation)
-{
-    drawImage(image, dest, src, op, WebBlendModeNormal, shouldRespectImageOrientation);
-}
-
 void GraphicsContext::drawImage(Image* image, const FloatRect& dest)
 {
     if (!image)
         return;
     drawImage(image, dest, FloatRect(IntRect(IntPoint(), image->size())));
 }
 
-void GraphicsContext::drawImage(Image* image, const FloatRect& dest, const FloatRect& src, CompositeOperator op, WebBlendMode blendMode, RespectImageOrientationEnum 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, blendMode, shouldRespectImageOrientation);
+    image->draw(this, dest, src, op, shouldRespectImageOrientation);
 }
 
-void GraphicsContext::drawTiledImage(Image* image, const IntRect& destRect, const IntPoint& srcPoint, const IntSize& tileSize, CompositeOperator op, WebBlendMode blendMode, const IntSize& repeatSpacing)
+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, blendMode, repeatSpacing);
+    image->drawTiled(this, destRect, srcPoint, tileSize, op, repeatSpacing);
 }
 
 void GraphicsContext::drawTiledImage(Image* image, const IntRect& dest, const IntRect& srcRect,
-    const FloatSize& tileScaleFactor, Image::TileRule hRule, Image::TileRule vRule, CompositeOperator op)
+    const FloatSize& tileScaleFactor, Image::TileRule hRule, Image::TileRule vRule, SkXfermode::Mode op)
 {
     if (contextDisabled() || !image)
         return;
 
     if (hRule == Image::StretchTile && vRule == Image::StretchTile) {
         // Just do a scale.
         drawImage(image, dest, srcRect, op);
         return;
     }
 
@@ skipping 732 matching lines @@
     if (m_trackTextRegion) {
         TRACE_EVENT0("skia", "GraphicsContext::didDrawTextInRect");
         m_textRegion.join(textRect);
     }
 }
 
 int GraphicsContext::preparePaintForDrawRectToRect(
     SkPaint* paint,
     const SkRect& srcRect,
     const SkRect& destRect,
-    CompositeOperator compositeOp,
-    WebBlendMode blendMode,
+    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(WebCoreCompositeToSkiaComposite(compositeOp, blendMode));
+            layerPaint.setXfermodeMode(compositeOp);
             layerPaint.setImageFilter(dropShadowImageFilter());
             m_canvas->saveLayer(&filteredBounds, &layerPaint);
             m_canvas->concat(ctm);
         }
     }
 
     if (!usingImageFilter) {
-        paint->setXfermodeMode(WebCoreCompositeToSkiaComposite(compositeOp, blendMode));
+        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;
@@ skipping 24 matching lines @@
     return initialSaveCount;
 }
 
 void GraphicsContext::setClient(GraphicsContextClient* client)
 {
     ASSERT(client == 0 || m_client == 0); // No clobbering
     m_client = client;
 }
 
 } // namespace blink