[poc] curve-filter

third_party/WebKit/Source/modules/canvas2d/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 40 matching lines @@
 #include "core/layout/LayoutBox.h"
 #include "core/layout/LayoutTheme.h"
 #include "modules/canvas2d/CanvasGradient.h"
 #include "modules/canvas2d/CanvasPattern.h"
 #include "modules/canvas2d/CanvasRenderingContext2DState.h"
 #include "modules/canvas2d/CanvasStyle.h"
 #include "modules/canvas2d/HitRegion.h"
 #include "modules/canvas2d/Path2D.h"
 #include "platform/fonts/FontCache.h"
 #include "platform/geometry/FloatQuad.h"
+#include "platform/graphics/BitmapImage.h"
 #include "platform/graphics/DrawLooperBuilder.h"
 #include "platform/graphics/ExpensiveCanvasHeuristicParameters.h"
+#include "platform/graphics/GraphicsScreen.h"
 #include "platform/graphics/ImageBuffer.h"
 #include "platform/graphics/StrokeData.h"
 #include "platform/graphics/skia/SkiaUtils.h"
 #include "platform/text/BidiTextRun.h"
 #include "public/platform/Platform.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkImageFilter.h"
 #include "wtf/ArrayBufferContents.h"
 #include "wtf/CheckedArithmetic.h"
 #include "wtf/MathExtras.h"
@@ skipping 856 matching lines @@
     SkPath skPath = path.skPath();
     FloatRect bounds = path.boundingRect();
     skPath.setFillType(fillType);
 
     if (paintType == CanvasRenderingContext2DState::StrokePaintType)
         inflateStrokeRect(bounds);
 
     if (!drawingCanvas())
         return;
 
+    WillPaintForDevice device(ScreenDevice::sRGBCanvas); // FIXME: color correct.
+
     if (draw(
         [&skPath, this](SkCanvas* c, const SkPaint* paint) // draw lambda
         {
             c->drawPath(skPath, *paint);
         },
         [](const SkIRect& rect) // overdraw test lambda
         {
             return false;
         }, bounds, paintType)) {
         if (isPathExpensive(path)) {
@@ skipping 36 matching lines @@
 }
 
 void CanvasRenderingContext2D::fillRect(double x, double y, double width, double height)
 {
     if (!validateRectForCanvas(x, y, width, height))
         return;
 
     if (!drawingCanvas())
         return;
 
+    WillPaintForDevice device(ScreenDevice::sRGBCanvas); // FIXME: color correct.
+
     SkRect rect = SkRect::MakeXYWH(x, y, width, height);
     draw(
         [&rect, this](SkCanvas* c, const SkPaint* paint) // draw lambda
         {
             c->drawRect(rect, *paint);
         },
         [&rect, this](const SkIRect& clipBounds) // overdraw test lambda
         {
             return rectContainsTransformedRect(rect, clipBounds);
         }, rect, CanvasRenderingContext2DState::FillPaintType);
@@ skipping 15 matching lines @@
 }
 
 void CanvasRenderingContext2D::strokeRect(double x, double y, double width, double height)
 {
     if (!validateRectForCanvas(x, y, width, height))
         return;
 
     if (!drawingCanvas())
         return;
 
+    WillPaintForDevice device(ScreenDevice::sRGBCanvas); // FIXME: color correct.
+
     SkRect rect = SkRect::MakeXYWH(x, y, width, height);
     FloatRect bounds = rect;
     inflateStrokeRect(bounds);
     draw(
         [&rect, this](SkCanvas* c, const SkPaint* paint) // draw lambda
         {
             strokeRectOnCanvas(rect, c, paint);
         },
         [](const SkIRect& clipBounds) // overdraw test lambda
         {
@@ skipping 139 matching lines @@
     SkCanvas* c = drawingCanvas();
     if (!c)
         return;
     if (!state().isTransformInvertible())
         return;
 
     SkIRect clipBounds;
     if (!c->getClipDeviceBounds(&clipBounds))
         return;
 
+    WillPaintForDevice device(ScreenDevice::sRGBCanvas);
+
     SkPaint clearPaint;
     clearPaint.setXfermodeMode(SkXfermode::kClear_Mode);
     clearPaint.setStyle(SkPaint::kFill_Style);
     FloatRect rect(x, y, width, height);
 
     if (rectContainsTransformedRect(rect, clipBounds)) {
         checkOverdraw(rect, &clearPaint, CanvasRenderingContext2DState::NoImage, ClipFill);
         if (drawingCanvas())
             drawingCanvas()->drawRect(rect, clearPaint);
         didDraw(clipBounds);
@@ skipping 129 matching lines @@
     if (!imageSource->isVideoElement()) {
         imagePaint.setAntiAlias(shouldDrawImageAntialiased(dstRect));
         image->draw(c, imagePaint, dstRect, srcRect, DoNotRespectImageOrientation, Image::DoNotClampImageToSourceRect);
     } else {
         c->save();
         c->clipRect(dstRect);
         c->translate(dstRect.x(), dstRect.y());
         c->scale(dstRect.width() / srcRect.width(), dstRect.height() / srcRect.height());
         c->translate(-srcRect.x(), -srcRect.y());
         HTMLVideoElement* video = static_cast<HTMLVideoElement*>(imageSource);
-        video->paintCurrentFrame(c, IntRect(IntPoint(), IntSize(video->videoWidth(), video->videoHeight())), &imagePaint);
+        video->paintCurrentFrame(c, IntRect(IntPoint(), IntSize(video->videoWidth(), video->videoHeight())), &imagePaint, nullptr);
     }
 
     c->restoreToCount(initialSaveCount);
 }
 
 bool shouldDisableDeferral(CanvasImageSource* imageSource)
 {
     if (imageSource->isVideoElement())
         return true;
     if (imageSource->isCanvasElement()) {
@@ skipping 33 matching lines @@
     FloatRect srcRect = normalizeRect(FloatRect(sx, sy, sw, sh));
     FloatRect dstRect = normalizeRect(FloatRect(dx, dy, dw, dh));
 
     clipRectsToImageRect(FloatRect(FloatPoint(), imageSource->elementSize()), &srcRect, &dstRect);
 
     imageSource->adjustDrawRects(&srcRect, &dstRect);
 
     if (srcRect.isEmpty())
         return;
 
+    WillPaintForDevice device(ScreenDevice::sRGBCanvas);
+
     if (shouldDisableDeferral(imageSource) || image->isTextureBacked())
         canvas()->disableDeferral();
 
     validateStateStack();
 
     draw(
         [this, &imageSource, &image, &srcRect, dstRect](SkCanvas* c, const SkPaint* paint) // draw lambda
         {
             drawImageInternal(c, imageSource, image.get(), srcRect, dstRect, paint);
         },
@@ skipping 40 matching lines @@
 
 bool CanvasRenderingContext2D::rectContainsTransformedRect(const FloatRect& rect, const SkIRect& transformedRect) const
 {
     FloatQuad quad(rect);
     FloatQuad transformedQuad(FloatRect(transformedRect.x(), transformedRect.y(), transformedRect.width(), transformedRect.height()));
     return state().transform().mapQuad(quad).containsQuad(transformedQuad);
 }
 
 CanvasGradient* CanvasRenderingContext2D::createLinearGradient(double x0, double y0, double x1, double y1)
 {
+    WillPaintForDevice device(ScreenDevice::sRGBCanvas);
+
     CanvasGradient* gradient = CanvasGradient::create(FloatPoint(x0, y0), FloatPoint(x1, y1));
     return gradient;
 }
 
 CanvasGradient* CanvasRenderingContext2D::createRadialGradient(double x0, double y0, double r0, double x1, double y1, double r1, ExceptionState& exceptionState)
 {
+    WillPaintForDevice device(ScreenDevice::sRGBCanvas);
+
     if (r0 < 0 || r1 < 0) {
         exceptionState.throwDOMException(IndexSizeError, String::format("The %s provided is less than 0.", r0 < 0 ? "r0" : "r1"));
         return nullptr;
     }
 
     CanvasGradient* gradient = CanvasGradient::create(FloatPoint(x0, y0), r0, FloatPoint(x1, y1), r1);
     return gradient;
 }
 
 CanvasPattern* CanvasRenderingContext2D::createPattern(const CanvasImageSourceUnion& imageSource, const String& repetitionType, ExceptionState& exceptionState)
 {
     Pattern::RepeatMode repeatMode = CanvasPattern::parseRepetitionType(repetitionType, exceptionState);
     if (exceptionState.hadException())
         return nullptr;
 
     SourceImageStatus status;
     CanvasImageSource* imageSourceInternal = toImageSourceInternal(imageSource);
     RefPtr<Image> imageForRendering = imageSourceInternal->getSourceImageForCanvas(&status, PreferNoAcceleration);
 
+    WillPaintForDevice device(ScreenDevice::sRGBCanvas);
+
     switch (status) {
     case NormalSourceImageStatus:
         break;
     case ZeroSizeCanvasSourceImageStatus:
         exceptionState.throwDOMException(InvalidStateError, String::format("The canvas %s is 0.", imageSourceInternal->elementSize().width() ? "height" : "width"));
         return nullptr;
     case UndecodableSourceImageStatus:
         exceptionState.throwDOMException(InvalidStateError, "Source image is in the 'broken' state.");
         return nullptr;
     case InvalidSourceImageStatus:
@@ skipping 461 matching lines @@
 
     SkCanvas* c = drawingCanvas();
     if (!c)
         return;
 
     if (!std::isfinite(x) || !std::isfinite(y))
         return;
     if (maxWidth && (!std::isfinite(*maxWidth) || *maxWidth <= 0))
         return;
 
+    WillPaintForDevice device(ScreenDevice::sRGBCanvas);
+
     const Font& font = accessFont();
     const FontMetrics& fontMetrics = font.fontMetrics();
 
     // FIXME: Need to turn off font smoothing.
 
     const ComputedStyle* computedStyle = 0;
     TextDirection direction = toTextDirection(state().direction(), canvas(), &computedStyle);
     bool isRTL = direction == RTL;
     bool override = computedStyle ? isOverride(computedStyle->unicodeBidi()) : false;
 
@@ skipping 186 matching lines @@
         return false;
 
     return true;
 }
 
 void CanvasRenderingContext2D::drawFocusRing(const Path& path)
 {
     if (!drawingCanvas())
         return;
 
+    WillPaintForDevice device(ScreenDevice::sRGBCanvas);
+
     SkColor color = LayoutTheme::theme().focusRingColor().rgb();
     const int focusRingWidth = 5;
 
-    drawPlatformFocusRing(path.skPath(), drawingCanvas(), color, focusRingWidth);
+    drawPlatformFocusRing(path.skPath(), drawingCanvas(), Color::toDeviceColor(color).rgb(), focusRingWidth);
 
     // We need to add focusRingWidth to dirtyRect.
     StrokeData strokeData;
     strokeData.setThickness(focusRingWidth);
 
     SkIRect dirtyRect;
     if (!computeDirtyRect(path.strokeBoundingRect(strokeData), &dirtyRect))
         return;
 
     didDraw(dirtyRect);
@@ skipping 150 matching lines @@
         if (imageType == CanvasRenderingContext2DState::NonOpaqueImage)
             return;
         if (alpha < 0xFF)
             return;
     }
 
     canvas()->buffer()->willOverwriteCanvas();
 }
 
 } // namespace blink