[poc] curve-filter

third_party/WebKit/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 78 matching lines @@
         ASSERT(!m_layerCount);
         ASSERT(!saveCount());
     }
 #endif
 }
 
 void GraphicsContext::save()
 {
     if (contextDisabled())
         return;
+    ASSERT(m_canvas);
 
     m_paintState->incrementSaveCount();
-
-    ASSERT(m_canvas);
     m_canvas->save();
 }
 
 void GraphicsContext::restore()
 {
     if (contextDisabled())
         return;
+    ASSERT(m_canvas);
 
     if (!m_paintStateIndex && !m_paintState->saveCount()) {
         WTF_LOG_ERROR("ERROR void GraphicsContext::restore() stack is empty");
         return;
     }
 
     if (m_paintState->saveCount()) {
         m_paintState->decrementSaveCount();
     } else {
         m_paintStateIndex--;
         m_paintState = m_paintStateStack[m_paintStateIndex].get();
     }
 
-    ASSERT(m_canvas);
     m_canvas->restore();
 }
 
 #if ENABLE(ASSERT)
 unsigned GraphicsContext::saveCount() const
 {
     // Each m_paintStateStack entry implies an additional save op
     // (on top of its own saveCount), except for the first frame.
     unsigned count = m_paintStateIndex;
     ASSERT(m_paintStateStack.size() > m_paintStateIndex);
     for (unsigned i = 0; i <= m_paintStateIndex; ++i)
         count += m_paintStateStack[i]->saveCount();
 
     return count;
 }
 #endif
 
 void GraphicsContext::saveLayer(const SkRect* bounds, const SkPaint* paint)
 {
     if (contextDisabled())
         return;
-
     ASSERT(m_canvas);
 
     m_canvas->saveLayer(bounds, paint);
 }
 
 void GraphicsContext::restoreLayer()
 {
     if (contextDisabled())
         return;
-
     ASSERT(m_canvas);
 
     m_canvas->restore();
 }
 
 #if ENABLE(ASSERT)
 void GraphicsContext::setInDrawingRecorder(bool val)
 {
     // Nested drawing recorers are not allowed.
     ASSERT(!val || !m_inDrawingRecorder);
     m_inDrawingRecorder = val;
 }
 #endif
 
 void GraphicsContext::setStrokeGradient(PassRefPtr<Gradient> gradient, float alpha)
 {
     if (contextDisabled())
         return;
 
     ASSERT(gradient);
     if (!gradient) {
         setStrokeColor(Color::black);
         return;
     }
+
     mutableState()->setStrokeGradient(gradient, alpha);
 }
 
 void GraphicsContext::setFillGradient(PassRefPtr<Gradient> gradient, float alpha)
 {
     if (contextDisabled())
         return;
 
     ASSERT(gradient);
     if (!gradient) {
@@ skipping 15 matching lines @@
     if (!color.alpha()) {
         if (shadowMode == DrawShadowOnly) {
             // shadow only, but there is no shadow: use an empty draw looper to disable rendering of the source primitive
             setDrawLooper(drawLooperBuilder.release());
             return;
         }
         clearDrawLooper();
         return;
     }
 
-    drawLooperBuilder->addShadow(offset, blur, color, shadowTransformMode, shadowAlphaMode);
+    drawLooperBuilder->addShadow(offset, blur, Color::toDeviceColor(color), shadowTransformMode, shadowAlphaMode);
     if (shadowMode == DrawShadowAndForeground) {
         drawLooperBuilder->addUnmodifiedContent();
     }
     setDrawLooper(drawLooperBuilder.release());
 }
 
 void GraphicsContext::setDrawLooper(PassOwnPtr<DrawLooperBuilder> drawLooperBuilder)
 {
     if (contextDisabled())
         return;
@@ skipping 21 matching lines @@
     // We only support one active color filter at the moment. If (when) this becomes a problem,
     // we should switch to using color filter chains (Skia work in progress).
     ASSERT(!stateToSet->colorFilter());
     stateToSet->setColorFilter(WebCoreColorFilterToSkiaColorFilter(colorFilter));
 }
 
 void GraphicsContext::concat(const SkMatrix& matrix)
 {
     if (contextDisabled())
         return;
-
     ASSERT(m_canvas);
 
     m_canvas->concat(matrix);
 }
 
 void GraphicsContext::beginLayer(float opacity, SkXfermode::Mode xfermode, const FloatRect* bounds, ColorFilter colorFilter, SkImageFilter* imageFilter)
 {
     if (contextDisabled())
         return;
 
@@ skipping 81 matching lines @@
 {
     if (contextDisabled())
         return;
 
     ASSERT(numPoints > 2);
 
     SkPath path;
     setPathFromPoints(&path, numPoints, points);
 
     SkPaint paint(immutableState()->fillPaint());
+    paint.setColor(Color::toDeviceColor(color).rgb());
     paint.setAntiAlias(shouldAntialias);
-    paint.setColor(color.rgb());
 
     drawPath(path, paint);
 }
 
 void GraphicsContext::drawFocusRingPath(const SkPath& path, const Color& color, int width)
 {
-    drawPlatformFocusRing(path, m_canvas, color.rgb(), width);
+    drawPlatformFocusRing(path, m_canvas, Color::toDeviceColor(color).rgb(), width);
 }
 
 void GraphicsContext::drawFocusRingRect(const SkRect& rect, const Color& color, int width)
 {
-    drawPlatformFocusRing(rect, m_canvas, color.rgb(), width);
+    drawPlatformFocusRing(rect, m_canvas, Color::toDeviceColor(color).rgb(), width);
 }
 
 void GraphicsContext::drawFocusRing(const Path& focusRingPath, int width, int offset, const Color& color)
 {
     // FIXME: Implement support for offset.
     if (contextDisabled())
         return;
 
     drawFocusRingPath(focusRingPath.skPath(), color, width);
 }
@@ skipping 81 matching lines @@
         clipRoundedRect(rect);
         if (shadowSpread < 0)
             roundedHole.expandRadii(-shadowSpread);
         else
             roundedHole.shrinkRadii(shadowSpread);
     } else {
         clip(rect.rect());
     }
 
     OwnPtr<DrawLooperBuilder> drawLooperBuilder = DrawLooperBuilder::create();
-    drawLooperBuilder->addShadow(FloatSize(shadowOffset), shadowBlur, shadowColor,
+    drawLooperBuilder->addShadow(FloatSize(shadowOffset), shadowBlur, Color::toDeviceColor(shadowColor),
         DrawLooperBuilder::ShadowRespectsTransforms, DrawLooperBuilder::ShadowIgnoresAlpha);
     setDrawLooper(drawLooperBuilder.release());
+
     fillRectWithRoundedHole(outerRect, roundedHole, fillColor);
 }
 
 void GraphicsContext::drawLine(const IntPoint& point1, const IntPoint& point2)
 {
     if (contextDisabled())
         return;
     ASSERT(m_canvas);
 
     StrokeStyle penStyle = strokeStyle();
@@ skipping 183 matching lines @@
         int thickness = SkMax32(static_cast<int>(strokeThickness()), 1);
         SkRect r;
         r.fLeft = WebCoreFloatToSkScalar(pt.x());
         // Avoid anti-aliasing lines. Currently, these are always horizontal.
         // Round to nearest pixel to match text and other content.
         r.fTop = WebCoreFloatToSkScalar(floorf(pt.y() + 0.5f));
         r.fRight = r.fLeft + WebCoreFloatToSkScalar(width);
         r.fBottom = r.fTop + SkIntToScalar(thickness);
         paint = immutableState()->fillPaint();
         // Text lines are drawn using the stroke color.
-        paint.setColor(strokeColor().rgb());
+        paint.setColor(Color::toDeviceColor(strokeColor()).rgb());
         drawRect(r, paint);
         return;
     }
     case DottedStroke:
     case DashedStroke: {
         int y = floorf(pt.y() + std::max<float>(strokeThickness() / 2.0f, 0.5f));
         drawLine(IntPoint(pt.x(), y), IntPoint(pt.x() + width, y));
         return;
     }
     }
@@ skipping 13 matching lines @@
 
     SkRect skRect = rect;
     int fillcolorNotTransparent = immutableState()->fillColor().rgb() & 0xFF000000;
     if (fillcolorNotTransparent)
         drawRect(skRect, immutableState()->fillPaint());
 
     if (immutableState()->strokeData().style() != NoStroke
         && immutableState()->strokeColor().alpha()) {
         // Stroke a width: 1 inset border
         SkPaint paint(immutableState()->fillPaint());
-        paint.setColor(strokeColor().rgb());
+        paint.setColor(Color::toDeviceColor(strokeColor()).rgb());
         paint.setStyle(SkPaint::kStroke_Style);
         paint.setStrokeWidth(1);
 
         skRect.inset(0.5f, 0.5f);
         drawRect(skRect, paint);
     }
 }
 
 void GraphicsContext::drawText(const Font& font, const TextRunPaintInfo& runInfo, const FloatPoint& point, const SkPaint& paint)
 {
@@ skipping 69 matching lines @@
     drawImage(image, FloatRect(r), FloatRect(FloatPoint(), FloatSize(image->size())), op, shouldRespectImageOrientation);
 }
 
 void GraphicsContext::drawImage(Image* image, const FloatRect& dest, const FloatRect& src, SkXfermode::Mode op, RespectImageOrientationEnum shouldRespectImageOrientation)
 {
     if (contextDisabled() || !image)
         return;
 
     SkPaint imagePaint = immutableState()->fillPaint();
     imagePaint.setXfermodeMode(op);
-    imagePaint.setColor(SK_ColorBLACK);
+    imagePaint.setColor(SK_ColorBLACK); // FIXME: not color correct.
     imagePaint.setFilterQuality(computeFilterQuality(image, dest, src));
     imagePaint.setAntiAlias(shouldAntialias());
     image->draw(m_canvas, imagePaint, dest, src, shouldRespectImageOrientation, Image::ClampImageToSourceRect);
     m_paintController.setImagePainted();
 }
 
 SkFilterQuality GraphicsContext::computeFilterQuality(Image* image, const FloatRect& dest, const FloatRect& src) const
 {
     InterpolationQuality resampling;
     if (printing()) {
@@ skipping 96 matching lines @@
 
     drawRect(rect, immutableState()->fillPaint());
 }
 
 void GraphicsContext::fillRect(const FloatRect& rect, const Color& color, SkXfermode::Mode xferMode)
 {
     if (contextDisabled())
         return;
 
     SkPaint paint = immutableState()->fillPaint();
-    paint.setColor(color.rgb());
+    paint.setColor(Color::toDeviceColor(color).rgb());
     paint.setXfermodeMode(xferMode);
-
     drawRect(rect, paint);
 }
 
 void GraphicsContext::fillRoundedRect(const FloatRoundedRect& rrect, const Color& color)
 {
     if (contextDisabled())
         return;
 
     if (!rrect.isRounded() || !rrect.isRenderable()) {
         fillRect(rrect.rect(), color);
         return;
     }
 
     if (color == fillColor()) {
         drawRRect(rrect, immutableState()->fillPaint());
         return;
     }
 
     SkPaint paint = immutableState()->fillPaint();
-    paint.setColor(color.rgb());
+    paint.setColor(Color::toDeviceColor(color).rgb());
 
     drawRRect(rrect, paint);
 }
 
 namespace {
 
 bool isSimpleDRRect(const FloatRoundedRect& outer, const FloatRoundedRect& inner)
 {
     // A DRRect is "simple" (i.e. can be drawn as a rrect stroke) if
     //   1) all sides have the same width
@@ skipping 35 matching lines @@
 {
     if (contextDisabled())
         return;
     ASSERT(m_canvas);
 
     if (!isSimpleDRRect(outer, inner)) {
         if (color == fillColor()) {
             m_canvas->drawDRRect(outer, inner, immutableState()->fillPaint());
         } else {
             SkPaint paint(immutableState()->fillPaint());
-            paint.setColor(color.rgb());
+            paint.setColor(Color::toDeviceColor(color).rgb());
             m_canvas->drawDRRect(outer, inner, paint);
         }
 
         return;
     }
 
     // We can draw this as a stroked rrect.
     float strokeWidth = inner.rect().x() - outer.rect().x();
     SkRRect strokeRRect = outer;
     strokeRRect.inset(strokeWidth / 2, strokeWidth / 2);
 
     SkPaint strokePaint(immutableState()->fillPaint());
-    strokePaint.setColor(color.rgb());
+    strokePaint.setColor(Color::toDeviceColor(color).rgb());
     strokePaint.setStyle(SkPaint::kStroke_Style);
     strokePaint.setStrokeWidth(strokeWidth);
 
     m_canvas->drawRRect(strokeRRect, strokePaint);
 }
 
 void GraphicsContext::fillEllipse(const FloatRect& ellipse)
 {
     if (contextDisabled())
         return;
@@ skipping 181 matching lines @@
 {
     concat(affineTransformToSkMatrix(affine));
 }
 
 void GraphicsContext::fillRectWithRoundedHole(const FloatRect& rect, const FloatRoundedRect& roundedHoleRect, const Color& color)
 {
     if (contextDisabled())
         return;
 
     SkPaint paint(immutableState()->fillPaint());
-    paint.setColor(color.rgb());
+    paint.setColor(Color::toDeviceColor(color).rgb());
     m_canvas->drawDRRect(SkRRect::MakeRect(rect), roundedHoleRect, paint);
 }
 
 void GraphicsContext::adjustLineToPixelBoundaries(FloatPoint& p1, FloatPoint& p2, float strokeWidth, StrokeStyle penStyle)
 {
     // For odd widths, we add in 0.5 to the appropriate x/y so that the float arithmetic
     // works out.  For example, with a border width of 3, WebKit will pass us (y1+y2)/2, e.g.,
     // (50+53)/2 = 103/2 = 51 when we want 51.5.  It is always true that an even width gave
     // us a perfect position, but an odd width gave us a position that is off by exactly 0.5.
     if (penStyle == DottedStroke || penStyle == DashedStroke) {
@@ skipping 135 matching lines @@
     static const SkPMColor colors[] = {
         SkPreMultiplyARGB(0x60, 0xFF, 0x00, 0x00), // More transparent red
         SkPreMultiplyARGB(0x60, 0xC0, 0xC0, 0xC0)  // More transparent gray
     };
 
     return colors[index];
 }
 #endif
 
 } // namespace blink