Adds filter support for offscreen canvas

third_party/WebKit/Source/modules/canvas2d/CanvasRenderingContext2DState.cpp

 // Copyright 2015 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 "modules/canvas2d/CanvasRenderingContext2DState.h"
 
 #include "core/css/CSSFontSelector.h"
 #include "core/css/resolver/FilterOperationResolver.h"
 #include "core/css/resolver/StyleBuilder.h"
 #include "core/css/resolver/StyleResolverState.h"
@@ skipping 254 matching lines @@
     const AffineTransform& transform) {
   m_isTransformInvertible = transform.isInvertible();
   m_transform = transform;
 }
 
 void CanvasRenderingContext2DState::resetTransform() {
   m_transform.makeIdentity();
   m_isTransformInvertible = true;
 }
 
+sk_sp<SkImageFilter> CanvasRenderingContext2DState::getFilterForOffscreenCanvas(
+    IntSize canvasSize) const {
+  if (!m_filterValue)
+    return nullptr;
+
+  if (m_resolvedFilter)
+    return m_resolvedFilter;
+
+  FilterOperations operations =
+      FilterOperationResolver::createOffscreenFilterOperations(*m_filterValue);
+
+  // We can't reuse m_fillPaint and m_strokePaint for the filter, since these
+  // incorporate the global alpha, which isn't applicable here.
+  SkPaint fillPaintForFilter;
+  m_fillStyle->applyToPaint(fillPaintForFilter);
+  fillPaintForFilter.setColor(m_fillStyle->paintColor());
+  SkPaint strokePaintForFilter;
+  m_strokeStyle->applyToPaint(strokePaintForFilter);
+  strokePaintForFilter.setColor(m_strokeStyle->paintColor());
+
+  FilterEffectBuilder filterEffectBuilder(
+      FloatRect((FloatPoint()), FloatSize(canvasSize)),
+      1.0f,  // Deliberately ignore zoom on the canvas element.
+      &fillPaintForFilter, &strokePaintForFilter);
+
+  FilterEffect* lastEffect = filterEffectBuilder.buildFilterEffect(operations);
+  if (lastEffect) {
+    m_resolvedFilter =
+        SkiaImageFilterBuilder::build(lastEffect, ColorSpaceDeviceRGB);
+  }
+
+  return m_resolvedFilter;
+}
+
 sk_sp<SkImageFilter> CanvasRenderingContext2DState::getFilter(
     Element* styleResolutionHost,
     IntSize canvasSize,
     CanvasRenderingContext2D* context) const {
   if (!m_filterValue)
     return nullptr;
 
   // StyleResolverState cannot be used in frame-less documents.
   if (!styleResolutionHost->document().frame())
     return nullptr;
@@ skipping 37 matching lines @@
         context->updateFilterReferences(filterStyle->filter());
         if (lastEffect->originTainted())
           context->setOriginTainted();
       }
     }
   }
 
   return m_resolvedFilter;
 }
 
+bool CanvasRenderingContext2DState::hasFilterForOffscreenCanvas(
+    IntSize canvasSize) const {
+  // Checking for a non-null m_filterValue isn't sufficient, since this value
+  // might refer to a non-existent filter.
+  return !!getFilterForOffscreenCanvas(canvasSize);

[esprehn, 2017/01/27 19:44:39]

This is super wasteful since you do all the work to create the filter and then
throw it away. I see the non-off screen canvas one does this too though.

[fserb, 2017/01/27 19:54:47]

The problem is there's no way to know if you actually have a proper filter
unless you try to compute it. I can create a bug to investigate this and try to
come up with a better architecture.

+}
+
 bool CanvasRenderingContext2DState::hasFilter(
     Element* styleResolutionHost,
     IntSize canvasSize,
     CanvasRenderingContext2D* context) const {
   // Checking for a non-null m_filterValue isn't sufficient, since this value
   // might refer to a non-existent filter.
   return !!getFilter(styleResolutionHost, canvasSize, context);
 }
 
 void CanvasRenderingContext2DState::clearResolvedFilter() const {
@@ skipping 207 matching lines @@
     paint->setLooper(0);
     paint->setImageFilter(shadowAndForegroundImageFilter());
     return paint;
   }
   paint->setLooper(sk_ref_sp(shadowAndForegroundDrawLooper()));
   paint->setImageFilter(0);
   return paint;
 }
 
 }  // namespace blink