Adds filter support for offscreen canvas

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

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
  * copyright notice, this list of conditions and the following disclaimer
  * in the documentation and/or other materials provided with the
  * distribution.
  *     * Neither the name of Google Inc. nor the names of its
@@ skipping 10 matching lines @@
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "core/css/resolver/StyleBuilderConverter.h"
 
 #include "core/css/BasicShapeFunctions.h"
 #include "core/css/CSSBasicShapeValues.h"
+#include "core/css/CSSColorValue.h"
 #include "core/css/CSSContentDistributionValue.h"
 #include "core/css/CSSCustomIdentValue.h"
 #include "core/css/CSSFontFamilyValue.h"
 #include "core/css/CSSFontFeatureValue.h"
 #include "core/css/CSSFontVariationValue.h"
 #include "core/css/CSSFunctionValue.h"
 #include "core/css/CSSGridAutoRepeatValue.h"
 #include "core/css/CSSGridLineNamesValue.h"
 #include "core/css/CSSIdentifierValue.h"
 #include "core/css/CSSPathValue.h"
@@ skipping 108 matching lines @@
          toCSSIdentifierValue(value).getValueID() == CSSValueNone);
   return nullptr;
 }
 
 FilterOperations StyleBuilderConverter::convertFilterOperations(
     StyleResolverState& state,
     const CSSValue& value) {
   return FilterOperationResolver::createFilterOperations(state, value);
 }
 
+FilterOperations StyleBuilderConverter::convertOffscreenFilterOperations(
+    const CSSValue& value) {
+  return FilterOperationResolver::createOffscreenFilterOperations(value);
+}
+
 static FontDescription::GenericFamilyType convertGenericFamily(
     CSSValueID valueID) {
   switch (valueID) {
     case CSSValueWebkitBody:
       return FontDescription::StandardFamily;
     case CSSValueSerif:
       return FontDescription::SerifFamily;
     case CSSValueSansSerif:
       return FontDescription::SansSerifFamily;
     case CSSValueCursive:
@@ skipping 152 matching lines @@
                                                    const CSSValue& value) {
   if (value.isIdentifierValue() &&
       toCSSIdentifierValue(value).getValueID() == CSSValueNone)
     return FontBuilder::initialSizeAdjust();
 
   const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
   ASSERT(primitiveValue.isNumber());
   return primitiveValue.getFloatValue();
 }
 
+double StyleBuilderConverter::convertValueToNumber(
+    const CSSFunctionValue* filter,
+    const CSSPrimitiveValue* value) {
+  switch (filter->functionType()) {
+    case CSSValueGrayscale:
+    case CSSValueSepia:
+    case CSSValueSaturate:
+    case CSSValueInvert:
+    case CSSValueBrightness:
+    case CSSValueContrast:
+    case CSSValueOpacity: {
+      double amount = (filter->functionType() == CSSValueBrightness) ? 0 : 1;
+      if (filter->length() == 1) {
+        amount = value->getDoubleValue();
+        if (value->isPercentage())
+          amount /= 100;
+      }
+      return amount;
+    }
+    case CSSValueHueRotate: {
+      double angle = 0;
+      if (filter->length() == 1)
+        angle = value->computeDegrees();
+      return angle;
+    }
+    default:
+      return 0;
+  }
+}
+
 FontWeight StyleBuilderConverter::convertFontWeight(StyleResolverState& state,
                                                     const CSSValue& value) {
   const CSSIdentifierValue& identifierValue = toCSSIdentifierValue(value);
   switch (identifierValue.getValueID()) {
     case CSSValueBolder:
       return FontDescription::bolderWeight(
           state.parentStyle()->getFontDescription().weight());
     case CSSValueLighter:
       return FontDescription::lighterWeight(
           state.parentStyle()->getFontDescription().weight());
@@ skipping 652 matching lines @@
 LengthSize StyleBuilderConverter::convertRadius(StyleResolverState& state,
                                                 const CSSValue& value) {
   const CSSValuePair& pair = toCSSValuePair(value);
   Length radiusWidth = toCSSPrimitiveValue(pair.first())
                            .convertToLength(state.cssToLengthConversionData());
   Length radiusHeight = toCSSPrimitiveValue(pair.second())
                             .convertToLength(state.cssToLengthConversionData());
   return LengthSize(radiusWidth, radiusHeight);
 }
 
-ShadowData StyleBuilderConverter::convertShadow(StyleResolverState& state,
-                                                const CSSValue& value) {
+ShadowData StyleBuilderConverter::convertShadow(
+    const CSSToLengthConversionData& conversionData,
+    StyleResolverState* state,
+    const CSSValue& value) {
   const CSSShadowValue& shadow = toCSSShadowValue(value);
-  float x = shadow.x->computeLength<float>(state.cssToLengthConversionData());
-  float y = shadow.y->computeLength<float>(state.cssToLengthConversionData());
+  float x = shadow.x->computeLength<float>(conversionData);
+  float y = shadow.y->computeLength<float>(conversionData);
   float blur =
-      shadow.blur
-          ? shadow.blur->computeLength<float>(state.cssToLengthConversionData())
-          : 0;
-  float spread = shadow.spread
-                     ? shadow.spread->computeLength<float>(
-                           state.cssToLengthConversionData())
-                     : 0;
+      shadow.blur ? shadow.blur->computeLength<float>(conversionData) : 0;
+  float spread =
+      shadow.spread ? shadow.spread->computeLength<float>(conversionData) : 0;
   ShadowStyle shadowStyle =
       shadow.style && shadow.style->getValueID() == CSSValueInset ? Inset
                                                                   : Normal;
   StyleColor color = StyleColor::currentColor();
-  if (shadow.color)
-    color = convertStyleColor(state, *shadow.color);
+  if (shadow.color) {
+    if (state) {
+      color = convertStyleColor(*state, *shadow.color);
+    } else {
+      // For OffScreen canvas, we default to black and only parse non
+      // Document dependent CSS colors.
+      color = StyleColor(Color::black);
+      if (shadow.color->isColorValue()) {
+        color = toCSSColorValue(*shadow.color).value();
+      } else {
+        CSSValueID valueID = toCSSIdentifierValue(*shadow.color).getValueID();
+        switch (valueID) {
+          case CSSValueInvalid:
+            NOTREACHED();
+          case CSSValueInternalQuirkInherit:
+          case CSSValueWebkitLink:
+          case CSSValueWebkitActivelink:
+          case CSSValueWebkitFocusRingColor:
+          case CSSValueCurrentcolor:
+            break;
+          default:
+            color = StyleColor::colorFromKeyword(valueID);
+        }
+      }
+    }
+  }
+
   return ShadowData(FloatPoint(x, y), blur, spread, shadowStyle, color);
 }
 
 PassRefPtr<ShadowList> StyleBuilderConverter::convertShadowList(
     StyleResolverState& state,
     const CSSValue& value) {
   if (value.isIdentifierValue()) {
     DCHECK_EQ(toCSSIdentifierValue(value).getValueID(), CSSValueNone);
     return PassRefPtr<ShadowList>();
   }
 
   ShadowDataVector shadows;
-  for (const auto& item : toCSSValueList(value))
-    shadows.push_back(convertShadow(state, *item));
+  for (const auto& item : toCSSValueList(value)) {
+    shadows.push_back(
+        convertShadow(state.cssToLengthConversionData(), &state, *item));
+  }
 
   return ShadowList::adopt(shadows);
 }
 
 ShapeValue* StyleBuilderConverter::convertShapeValue(StyleResolverState& state,
                                                      const CSSValue& value) {
   if (value.isIdentifierValue()) {
     DCHECK_EQ(toCSSIdentifierValue(value).getValueID(), CSSValueNone);
     return nullptr;
   }
@@ skipping 278 matching lines @@
 }
 
 const CSSValue& StyleBuilderConverter::convertRegisteredPropertyValue(
     const StyleResolverState& state,
     const CSSValue& value) {
   return computeRegisteredPropertyValue(state.cssToLengthConversionData(),
                                         value);
 }
 
 }  // namespace blink