Adds filter support for offscreen canvas

third_party/WebKit/Source/core/css/resolver/FilterOperationResolver.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 2004-2005 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2006, 2007 Nicholas Shanks (webkit@nickshanks.com)
  * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Apple Inc.
  * All rights reserved.
  * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>
  * Copyright (C) 2007, 2008 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved.
  * (http://www.torchmobile.com/)
@@ skipping 99 matching lines @@
       feature = UseCounter::CSSFilterBlur;
       break;
     case FilterOperation::DROP_SHADOW:
       feature = UseCounter::CSSFilterDropShadow;
       break;
   };
   UseCounter::count(document, feature);
 }
 
 FilterOperations FilterOperationResolver::createFilterOperations(
-    StyleResolverState& state,
+    StyleResolverState* state,
     const CSSValue& inValue) {
   FilterOperations operations;
 
   if (inValue.isIdentifierValue()) {
     DCHECK_EQ(toCSSIdentifierValue(inValue).getValueID(), CSSValueNone);
     return operations;
   }
 
-  const CSSToLengthConversionData& conversionData =
-      state.cssToLengthConversionData();
+  const CSSToLengthConversionData* conversionData;
+  if (state) {
+    conversionData = &(state->cssToLengthConversionData());
+  } else {
+    FontDescription fontDescription;
+    Font font(fontDescription);
+    static CSSToLengthConversionData::FontSizes fontSizes(10, 16, &font);

[Justin Novosad, 2016/11/08 20:59:23]

These hard-coded values should be in constants.  Actually we might already have
constants defined somewhere for this already? 

[fserb, 2017/01/17 17:58:44]

Couldn't find it anywhere. The default on CSS Font conversion is 0. Added
constants.

+    static CSSToLengthConversionData::ViewportSize viewportSize(1024, 768);
+    static CSSToLengthConversionData baseData(&ComputedStyle::initialStyle(),

[esprehn, 2016/11/22 01:38:37]

I don't think you can do this, any number of worker threads can come through
here calling FilterOperationResolver::createFilterOperations at the same time,
initializing these structs in parallel doesn't look thread safe.

[fserb, 2017/01/17 17:58:44]

I've removed the statics.

+                                              fontSizes, viewportSize, 1);
+    conversionData = &baseData;
+  }
+
   for (auto& currValue : toCSSValueList(inValue)) {
     if (currValue->isURIValue()) {
-      countFilterUse(FilterOperation::REFERENCE, state.document());
+      if (!state)

[Justin Novosad, 2016/11/08 20:59:23]

Add a comment here to explain the the !state case is for
OffscreenCanvasRenderingContext2D, which does not support reference filters.

[fserb, 2017/01/17 17:58:44]

done.

+        continue;
+      countFilterUse(FilterOperation::REFERENCE, state->document());
 
       const CSSURIValue& urlValue = toCSSURIValue(*currValue);
       SVGElementProxy& elementProxy =
-          state.elementStyleResources().cachedOrPendingFromValue(urlValue);
+          state->elementStyleResources().cachedOrPendingFromValue(urlValue);
       operations.operations().append(
           ReferenceFilterOperation::create(urlValue.value(), elementProxy));
       continue;
     }
 
     const CSSFunctionValue* filterValue = toCSSFunctionValue(currValue.get());
     FilterOperation::OperationType operationType =
         filterOperationForType(filterValue->functionType());
-    countFilterUse(operationType, state.document());
+    if (state)
+      countFilterUse(operationType, state->document());

[esprehn, 2016/11/22 01:38:37]

I think you actually want to take an ExecutionContext argument to this function,
workers can use the UseCounter as well, and what you're doing here means that we
have no use counter coverage for them.

We can fix that in a follow up though.

[fserb, 2017/01/17 17:58:44]

added TODO.

     DCHECK_LE(filterValue->length(), 1u);
 
     const CSSPrimitiveValue* firstValue =
         filterValue->length() && filterValue->item(0).isPrimitiveValue()
             ? &toCSSPrimitiveValue(filterValue->item(0))
             : nullptr;
     switch (filterValue->functionType()) {
       case CSSValueGrayscale:
       case CSSValueSepia:
       case CSSValueSaturate: {
@@ skipping 29 matching lines @@
             amount /= 100;
         }
 
         operations.operations().append(
             BasicComponentTransferFilterOperation::create(amount,
                                                           operationType));
         break;
       }
       case CSSValueBlur: {
         Length stdDeviation = Length(0, Fixed);
-        if (filterValue->length() >= 1)
-          stdDeviation = firstValue->convertToLength(conversionData);
+        if (filterValue->length() >= 1) {
+          stdDeviation = firstValue->convertToLength(*conversionData);
+        }
         operations.operations().append(
             BlurFilterOperation::create(stdDeviation));
         break;
       }
       case CSSValueDropShadow: {
         const CSSShadowValue& item = toCSSShadowValue(filterValue->item(0));
-        IntPoint location(item.x->computeLength<int>(conversionData),
-                          item.y->computeLength<int>(conversionData));
-        int blur =
-            item.blur ? item.blur->computeLength<int>(conversionData) : 0;
+        IntPoint location;
+        int blur;
+
+        location = IntPoint(item.x->computeLength<int>(*conversionData),
+                            item.y->computeLength<int>(*conversionData));
+        blur = item.blur ? item.blur->computeLength<int>(*conversionData) : 0;
         Color shadowColor = Color::black;

[esprehn, 2016/11/22 01:38:37]

This is going to force all shadows to be black, that looks wrong since authors
likely want other colors for shadows. You need to probably pass in a
TextLinkColors instance and use it here, or at least replicate the the logic at
the start that does isColorValue()

[fserb, 2017/01/17 17:58:44]

yep. This code got refactored on StyleBuilderConverter, but I fixed there to do
the proper thing for offscreen (default to black and use the passed color).

-        if (item.color)
-          shadowColor = state.document().textLinkColors().colorFromCSSValue(
-              *item.color, state.style()->color());
+        if (item.color && state) {
+          shadowColor = state->document().textLinkColors().colorFromCSSValue(
+              *item.color, state->style()->color());
+        }
 
         operations.operations().append(
             DropShadowFilterOperation::create(location, blur, shadowColor));
         break;
       }
       default:
         ASSERT_NOT_REACHED();
         break;
     }
   }
 
   return operations;
 }
 
 }  // namespace blink