Web Animations CSS: Support animation of background-position and background-image

Source/core/animation/css/CSSAnimatableValueFactory.cpp

 /*
  * 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:
  *
  *     * 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
@@ skipping 21 matching lines @@
 #include "core/animation/css/CSSAnimatableValueFactory.h"
 
 #include "CSSValueKeywords.h"
 #include "core/animation/AnimatableClipPathOperation.h"
 #include "core/animation/AnimatableColor.h"
 #include "core/animation/AnimatableDouble.h"
 #include "core/animation/AnimatableImage.h"
 #include "core/animation/AnimatableLength.h"
 #include "core/animation/AnimatableLengthBox.h"
 #include "core/animation/AnimatableLengthSize.h"
+#include "core/animation/AnimatableRepeatable.h"
 #include "core/animation/AnimatableSVGLength.h"
 #include "core/animation/AnimatableSVGPaint.h"
 #include "core/animation/AnimatableShapeValue.h"
 #include "core/animation/AnimatableTransform.h"
 #include "core/animation/AnimatableUnknown.h"
 #include "core/animation/AnimatableVisibility.h"
 #include "core/animation/css/CSSAnimations.h"
 #include "core/css/CSSPrimitiveValue.h"
 #include "core/platform/Length.h"
 #include "core/platform/LengthBox.h"
@@ skipping 54 matching lines @@
         createFromLength(lengthBox.bottom(), style));
 }
 
 inline static PassRefPtr<AnimatableValue> createFromLengthSize(const LengthSize lengthSize, const RenderStyle* style)
 {
     return AnimatableLengthSize::create(
         createFromLength(lengthSize.width(), style),
         createFromLength(lengthSize.height(), style));
 }
 
+template<typename T>
+static inline PassRefPtr<AnimatableValue> createFrom(T, const RenderStyle*);
+
+template <>
+PassRefPtr<AnimatableValue> createFrom<Length>(Length length, const RenderStyle* style)
+{
+    return createFromLength(length, style);
+}
+
+template <>
+PassRefPtr<AnimatableValue> createFrom<StyleImage*>(StyleImage* image, const RenderStyle*)
+{
+    return AnimatableImage::create(image);
+}
+
+template<typename T>
+inline static PassRefPtr<AnimatableValue> createFromFillLayers(const FillLayer* fillLayer, T getter, bool (FillLayer::*isSet)() const, const RenderStyle* style)

[dstockwell, 2013/10/08 23:02:46]

This seems a bit yuck. Couldn't this just be a single method templated on
CSSPropertyID? No need for function pointers...

[alancutter (OOO until 2018), 2013/10/09 07:20:55]

I agree that function pointers and code duplication aren't very pretty but IMO
the templated switch solution is even uglier. I'd added it to the patch for you
to see. Perhaps I'm doing it in an ugly way but it's not entirely clear to me
how to make it succinct without function pointers.

+{
+    Vector<RefPtr<AnimatableValue> > values;
+    while (fillLayer && (fillLayer->*isSet)()) {
+        values.append(createFrom((fillLayer->*getter)(), style));
+        fillLayer = fillLayer->next();
+    }
+    return AnimatableRepeatable::create(values);
+}
+
 PassRefPtr<AnimatableValue> CSSAnimatableValueFactory::createFromColor(CSSPropertyID property, const RenderStyle* style)
 {
     Color color = style->colorIncludingFallback(property, false);
     Color visitedLinkColor = style->colorIncludingFallback(property, true);
     Color fallbackColor = style->color();
     Color fallbackVisitedLinkColor = style->visitedLinkColor();
     Color resolvedColor;
     if (color.isValid())
         resolvedColor = color;
     else
         resolvedColor = fallbackColor;
     Color resolvedVisitedLinkColor;
     if (visitedLinkColor.isValid())
         resolvedVisitedLinkColor = visitedLinkColor;
     else
         resolvedVisitedLinkColor = fallbackVisitedLinkColor;
     return AnimatableColor::create(resolvedColor, resolvedVisitedLinkColor);
 }
 
 // FIXME: Generate this function.
 PassRefPtr<AnimatableValue> CSSAnimatableValueFactory::create(CSSPropertyID property, const RenderStyle* style)
 {
     switch (property) {
     case CSSPropertyBackgroundColor:
         return createFromColor(property, style);
+    case CSSPropertyBackgroundImage:
+        return createFromFillLayers(style->backgroundLayers(), &FillLayer::image, &FillLayer::isImageSet, style);
+    case CSSPropertyBackgroundPositionX:
+        return createFromFillLayers(style->backgroundLayers(), &FillLayer::xPosition, &FillLayer::isXPositionSet, style);
+    case CSSPropertyBackgroundPositionY:
+        return createFromFillLayers(style->backgroundLayers(), &FillLayer::yPosition, &FillLayer::isYPositionSet, style);
     case CSSPropertyBaselineShift:
         return AnimatableSVGLength::create(style->baselineShiftValue());
     case CSSPropertyBorderBottomColor:
         return createFromColor(property, style);
     case CSSPropertyBorderBottomLeftRadius:
         return createFromLengthSize(style->borderBottomLeftRadius(), style);
     case CSSPropertyBorderBottomRightRadius:
         return createFromLengthSize(style->borderBottomRightRadius(), style);
     case CSSPropertyBorderBottomWidth:
         return createFromDouble(style->borderBottomWidth());
@@ skipping 150 matching lines @@
     case CSSPropertyZoom:
         return createFromDouble(style->zoom());
     default:
         RELEASE_ASSERT_WITH_MESSAGE(!CSSAnimations::isAnimatableProperty(property), "Web Animations not yet implemented: Create AnimatableValue from render style: %s", getPropertyNameString(property).utf8().data());
         ASSERT_NOT_REACHED();
         return 0;
     }
 }
 
 } // namespace WebCore