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 53 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<CSSPropertyID property>
+inline static PassRefPtr<AnimatableValue> createFromFillLayers(const FillLayer* fillLayer, const RenderStyle* style)
+{
+    ASSERT(fillLayer);
+    Vector<RefPtr<AnimatableValue> > values;
+    while (fillLayer) {

[dstockwell, 2013/10/09 23:15:07]

Hmm, yeah I guess there's a bit too much going on here.

Can we end up in a situation like this? [x-set, x-not-set, x-set]

If not, seems OK to not terminate the loop early. Otherwise I think there are
still a few ways to merge the switch statements and still exit, but its still
not going to be so great. I don't hate the function pointer version...

[alancutter (OOO until 2018), 2013/10/10 00:58:38]

Merged the switch statements using an if chain.

+        bool isSet;
+        switch (property) {
+        case CSSPropertyBackgroundImage:
+            isSet = fillLayer->isImageSet();
+            break;
+        case CSSPropertyBackgroundPositionX:
+            isSet = fillLayer->isXPositionSet();
+            break;
+        case CSSPropertyBackgroundPositionY:
+            isSet = fillLayer->isYPositionSet();
+            break;
+        default:
+            ASSERT_NOT_REACHED();
+        }
+        if (!isSet)
+            break;
+        switch (property) {
+        case CSSPropertyBackgroundImage:
+            values.append(AnimatableImage::create(fillLayer->image()));
+            break;
+        case CSSPropertyBackgroundPositionX:
+            values.append(createFromLength(fillLayer->xPosition(), style));
+            break;
+        case CSSPropertyBackgroundPositionY:
+            values.append(createFromLength(fillLayer->yPosition(), style));
+            break;
+        default:
+            ASSERT_NOT_REACHED();
+        }
+        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<CSSPropertyBackgroundImage>(style->backgroundLayers(), style);
+    case CSSPropertyBackgroundPositionX:
+        return createFromFillLayers<CSSPropertyBackgroundPositionX>(style->backgroundLayers(), style);
+    case CSSPropertyBackgroundPositionY:
+        return createFromFillLayers<CSSPropertyBackgroundPositionY>(style->backgroundLayers(), 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 152 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