Replace setCompositeOperation(CompositeOperator, WebBlendMode) with setCompositeOperation(SkXfermod…

Source/core/paint/BoxPainter.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 #include "core/paint/BoxPainter.h"
 
 #include "core/HTMLNames.h"
 #include "core/frame/Settings.h"
 #include "core/html/HTMLFrameOwnerElement.h"
@@ skipping 446 matching lines @@
             if (!boxShadowShouldBeAppliedToBackground)
                 backgroundRect.intersect(paintInfo.rect);
 
             GraphicsContextStateSaver shadowStateSaver(*context, boxShadowShouldBeAppliedToBackground);
             if (boxShadowShouldBeAppliedToBackground)
                 BoxPainter::applyBoxShadowForBackground(context, obj);
 
             if (isOpaqueRoot && !skipBaseColor) {
                 paintRootBackgroundColor(obj, paintInfo, rect, bgColor);
             } else if (bgColor.alpha()) {
-                context->fillRect(backgroundRect, bgColor, context->compositeOperation());
+                context->fillRect(backgroundRect, bgColor, context->compositeOperationDeprecated());
             }
         }
     }
 
     // no progressive loading of the background image
     if (shouldPaintBackgroundImage) {
         BackgroundImageGeometry geometry;
         calculateBackgroundImageGeometry(obj, paintInfo.paintContainer(), bgLayer, scrolledPaintRect, geometry, backgroundObject);
         if (!geometry.destRect().isEmpty()) {
             CompositeOperator compositeOp = op == CompositeSourceOver ? bgLayer.composite() : op;
             RenderObject* clientForBackgroundImage = backgroundObject ? backgroundObject : &obj;
             RefPtr<Image> image = bgImage->image(clientForBackgroundImage, geometry.tileSize());
             InterpolationQuality interpolationQuality = chooseInterpolationQuality(obj, context, image.get(), &bgLayer, LayoutSize(geometry.tileSize()));
             if (bgLayer.maskSourceType() == MaskLuminance)
                 context->setColorFilter(ColorFilterLuminanceToAlpha);
             InterpolationQuality previousInterpolationQuality = context->imageInterpolationQuality();
             context->setImageInterpolationQuality(interpolationQuality);
             TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"), "PaintImage", "data", InspectorPaintImageEvent::data(obj, *bgImage));
             context->drawTiledImage(image.get(), geometry.destRect(), geometry.phase(), geometry.tileSize(),
                 compositeOp, bgLayer.blendMode(), geometry.spaceSize());
             context->setImageInterpolationQuality(previousInterpolationQuality);
         }
     }
 
     if (bgLayer.clip() == TextFillBox) {
         // Create the text mask layer.
-        context->setCompositeOperation(CompositeDestinationIn);
+        context->setCompositeOperation(SkXfermode::kDstIn_Mode);
         context->beginTransparencyLayer(1);
 
         // FIXME: Workaround for https://code.google.com/p/skia/issues/detail?id=1291.
         context->clearRect(maskRect);
 
         // Now draw the text into the mask. We do this by painting using a special paint phase that signals to
         // InlineTextBoxes that they should just add their contents to the clip.
         PaintInfo info(context, maskRect, PaintPhaseTextClip, PaintBehaviorForceBlackText, 0);
-        context->setCompositeOperation(CompositeSourceOver);
+        context->setCompositeOperation(SkXfermode::kSrcOver_Mode);
         if (box) {
             RootInlineBox& root = box->root();
             box->paint(info, LayoutPoint(scrolledPaintRect.x() - box->x(), scrolledPaintRect.y() - box->y()), root.lineTop(), root.lineBottom());
         } else {
             // FIXME: this should only have an effect for the line box list within |obj|. Change this to create a LineBoxListPainter directly.
             LayoutSize localOffset = obj.isBox() ? toRenderBox(&obj)->locationOffset() : LayoutSize();
             obj.paint(info, scrolledPaintRect.location() - localOffset);
         }
 
         context->endLayer();
@@ skipping 12 matching lines @@
 
 void BoxPainter::paintMaskImages(const PaintInfo& paintInfo, const LayoutRect& paintRect)
 {
     // Figure out if we need to push a transparency layer to render our mask.
     bool pushTransparencyLayer = false;
     bool compositedMask = m_renderBox.hasLayer() && m_renderBox.layer()->hasCompositedMask();
     bool flattenCompositingLayers = m_renderBox.view()->frameView() && m_renderBox.view()->frameView()->paintBehavior() & PaintBehaviorFlattenCompositingLayers;
 
     bool allMaskImagesLoaded = true;
 
-    CompositeOperator previousCompositeOperator = paintInfo.context->compositeOperation();
+    SkXfermode::Mode previousCompositeOperation = paintInfo.context->compositeOperation();
 
     if (!compositedMask || flattenCompositingLayers) {
         pushTransparencyLayer = true;
         StyleImage* maskBoxImage = m_renderBox.style()->maskBoxImage().image();
         const FillLayer& maskLayers = m_renderBox.style()->maskLayers();
 
         // Don't render a masked element until all the mask images have loaded, to prevent a flash of unmasked content.
         if (maskBoxImage)
             allMaskImagesLoaded &= maskBoxImage->isLoaded();
 
         allMaskImagesLoaded &= maskLayers.imagesAreLoaded();
 
-        paintInfo.context->setCompositeOperation(CompositeDestinationIn);
+        paintInfo.context->setCompositeOperation(SkXfermode::kDstIn_Mode);
         paintInfo.context->beginTransparencyLayer(1);
     }
 
     if (allMaskImagesLoaded) {
         paintFillLayers(paintInfo, Color::transparent, m_renderBox.style()->maskLayers(), paintRect, BackgroundBleedNone, CompositeSourceOver);
         paintNinePieceImage(m_renderBox, paintInfo.context, paintRect, m_renderBox.style(), m_renderBox.style()->maskBoxImage(), CompositeSourceOver);
     }
 
     if (pushTransparencyLayer) {
         paintInfo.context->endLayer();
-        paintInfo.context->setCompositeOperation(previousCompositeOperator);
+        paintInfo.context->setCompositeOperation(previousCompositeOperation);
     }
 }
 
 void BoxPainter::paintClippingMask(const PaintInfo& paintInfo, const LayoutPoint& paintOffset)
 {
     if (!paintInfo.shouldPaintWithinRoot(&m_renderBox) || m_renderBox.style()->visibility() != VISIBLE || paintInfo.phase != PaintPhaseClippingMask)
         return;
 
     if (!m_renderBox.layer() || m_renderBox.layer()->compositingState() != PaintsIntoOwnBacking)
         return;
 
     LayoutRect paintRect = LayoutRect(paintOffset, m_renderBox.size());
     paintInfo.context->fillRect(pixelSnappedIntRect(paintRect), Color::black);
 }
 
 void BoxPainter::paintRootBackgroundColor(RenderObject& obj, const PaintInfo& paintInfo, const LayoutRect& rect, const Color& bgColor)
 {
     GraphicsContext* context = paintInfo.context;
     if (rect.isEmpty())
         return;
 
     ASSERT(obj.isDocumentElement());
 
     IntRect backgroundRect(pixelSnappedIntRect(rect));
     backgroundRect.intersect(paintInfo.rect);
 
     Color baseColor = obj.view()->frameView()->baseBackgroundColor();
     bool shouldClearDocumentBackground = obj.document().settings() && obj.document().settings()->shouldClearDocumentBackground();
-    CompositeOperator operation = shouldClearDocumentBackground ? CompositeCopy : context->compositeOperation();
+    CompositeOperator operation = shouldClearDocumentBackground ? CompositeCopy : context->compositeOperationDeprecated();
 
     // If we have an alpha go ahead and blend with the base background color.
     if (baseColor.alpha()) {
         if (bgColor.alpha())
             baseColor = baseColor.blend(bgColor);
         context->fillRect(backgroundRect, baseColor, operation);
     } else if (bgColor.alpha()) {
         context->fillRect(backgroundRect, bgColor, operation);
     } else if (shouldClearDocumentBackground) {
         context->clearRect(backgroundRect);
@@ skipping 1602 matching lines @@
 
     FloatPoint secondQuad[4];
     secondQuad[0] = quad[0];
     secondQuad[1] = FloatPoint(quad[0].x() - r1 * cx, quad[0].y() - r1 * cy);
     secondQuad[2] = quad[2];
     secondQuad[3] = quad[3];
     graphicsContext->clipPolygon(4, secondQuad, !secondEdgeMatches);
 }
 
 } // namespace blink