Use PropertyHandle instead of CSSPropertyID to identify CSS Transitions

third_party/WebKit/Source/core/animation/css/CSSAnimations.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 475 matching lines @@
     animation->update(TimingUpdateOnDemand);
 
     m_runningAnimations.push_back(new RunningAnimation(animation, entry));
   }
 
   // Transitions that are run on the compositor only update main-thread state
   // lazily. However, we need the new state to know what the from state shoud
   // be when transitions are retargeted. Instead of triggering complete style
   // recalculation, we find these cases by searching for new transitions that
   // have matching cancelled animation property IDs on the compositor.
-  HeapHashMap<CSSPropertyID, std::pair<Member<KeyframeEffectReadOnly>, double>>
+  HeapHashMap<PropertyHandle, std::pair<Member<KeyframeEffectReadOnly>, double>>
       retargetedCompositorTransitions;
-  for (CSSPropertyID id : m_pendingUpdate.cancelledTransitions()) {
-    DCHECK(m_transitions.contains(id));
+  for (const PropertyHandle& property :
+       m_pendingUpdate.cancelledTransitions()) {
+    DCHECK(m_transitions.contains(property));
 
-    Animation* animation = m_transitions.take(id).animation;
+    Animation* animation = m_transitions.take(property).animation;
     KeyframeEffectReadOnly* effect =
         toKeyframeEffectReadOnly(animation->effect());
-    if (effect->hasActiveAnimationsOnCompositor(id) &&
-        m_pendingUpdate.newTransitions().find(id) !=
+    if (effect->hasActiveAnimationsOnCompositor(property) &&
+        m_pendingUpdate.newTransitions().find(property) !=
             m_pendingUpdate.newTransitions().end() &&
-        !animation->limited())
+        !animation->limited()) {
       retargetedCompositorTransitions.insert(
-          id, std::pair<KeyframeEffectReadOnly*, double>(
-                  effect, animation->startTimeInternal()));
+          property,
+          std::pair<KeyframeEffectReadOnly*, double>(
+              effect, animation->startTimeInternal()));
+    }
     animation->cancel();
     // after cancelation, transitions must be downgraded or they'll fail
     // to be considered when retriggering themselves. This can happen if
     // the transition is captured through getAnimations then played.
     if (animation->effect() && animation->effect()->isKeyframeEffectReadOnly())
       toKeyframeEffectReadOnly(animation->effect())->downgradeToNormal();
     animation->update(TimingUpdateOnDemand);
   }
 
-  for (CSSPropertyID id : m_pendingUpdate.finishedTransitions()) {
+  for (const PropertyHandle& property : m_pendingUpdate.finishedTransitions()) {
     // This transition can also be cancelled and finished at the same time
-    if (m_transitions.contains(id)) {
-      Animation* animation = m_transitions.take(id).animation;
+    if (m_transitions.contains(property)) {
+      Animation* animation = m_transitions.take(property).animation;
       // Transition must be downgraded
       if (animation->effect() &&
           animation->effect()->isKeyframeEffectReadOnly())
         toKeyframeEffectReadOnly(animation->effect())->downgradeToNormal();
     }
   }
 
   for (const auto& entry : m_pendingUpdate.newTransitions()) {
     const CSSAnimationUpdate::NewTransition& newTransition = entry.value;
 
     RunningTransition runningTransition;
     runningTransition.from = newTransition.from;
     runningTransition.to = newTransition.to;
     runningTransition.reversingAdjustedStartValue =
         newTransition.reversingAdjustedStartValue;
     runningTransition.reversingShorteningFactor =
         newTransition.reversingShorteningFactor;
 
-    CSSPropertyID id = newTransition.id;
+    const PropertyHandle& property = newTransition.property;
     const InertEffect* inertAnimation = newTransition.effect.get();
     TransitionEventDelegate* eventDelegate =
-        new TransitionEventDelegate(element, id);
+        new TransitionEventDelegate(element, property);
 
     EffectModel* model = inertAnimation->model();
 
-    if (retargetedCompositorTransitions.contains(id)) {
+    if (retargetedCompositorTransitions.contains(property)) {
       const std::pair<Member<KeyframeEffectReadOnly>, double>& oldTransition =
-          retargetedCompositorTransitions.get(id);
+          retargetedCompositorTransitions.get(property);
       KeyframeEffectReadOnly* oldAnimation = oldTransition.first;
       double oldStartTime = oldTransition.second;
       double inheritedTime =
           isNull(oldStartTime)
               ? 0
               : element->document().timeline().currentTimeInternal() -
                     oldStartTime;
 
       TransitionKeyframeEffectModel* oldEffect =
           toTransitionKeyframeEffectModel(inertAnimation->model());
@@ skipping 19 matching lines @@
         newFrames[1]->setCompositorValue(
             interpolation.getInterpolatedCompositorValue());
         model = TransitionKeyframeEffectModel::create(newFrames);
       }
     }
 
     KeyframeEffect* transition = KeyframeEffect::create(
         element, model, inertAnimation->specifiedTiming(),
         KeyframeEffectReadOnly::TransitionPriority, eventDelegate);
     Animation* animation = element->document().timeline().play(transition);
-    animation->setId(getPropertyName(newTransition.id));
+    if (property.isCSSCustomProperty()) {

[Eric Willigers, 2017/03/01 02:33:35]

braces optional

[alancutter (OOO until 2018), 2017/03/01 02:36:25]

I prefer always braces under 2 space indentation.

+      animation->setId(property.customPropertyName());
+    } else {
+      animation->setId(getPropertyName(property.cssProperty()));
+    }
     // Set the current time as the start time for retargeted transitions
-    if (retargetedCompositorTransitions.contains(id))
+    if (retargetedCompositorTransitions.contains(property))
       animation->setStartTime(element->document().timeline().currentTime());
     animation->update(TimingUpdateOnDemand);
     runningTransition.animation = animation;
-    m_transitions.set(id, runningTransition);
-    DCHECK(isValidCSSPropertyID(id));
+    m_transitions.set(property, runningTransition);
+    DCHECK(isValidCSSPropertyID(property.cssProperty()));
 
     DEFINE_STATIC_LOCAL(SparseHistogram, propertyHistogram,
                         ("WebCore.Animation.CSSProperties"));
     propertyHistogram.sample(
-        UseCounter::mapCSSPropertyIdToCSSSampleIdForHistogram(id));
+        UseCounter::mapCSSPropertyIdToCSSSampleIdForHistogram(
+            property.cssProperty()));
   }
   clearPendingUpdate();
 }
 
 void CSSAnimations::calculateTransitionUpdateForProperty(
-    CSSPropertyID id,
+    const PropertyHandle& property,
     const CSSTransitionData& transitionData,
     size_t transitionIndex,
     const ComputedStyle& oldStyle,
     const ComputedStyle& style,
     const TransitionMap* activeTransitions,
     CSSAnimationUpdate& update,
     const Element* element) {
   RefPtr<AnimatableValue> to = nullptr;
   const RunningTransition* interruptedTransition = nullptr;
   if (activeTransitions) {
     TransitionMap::const_iterator activeTransitionIter =
-        activeTransitions->find(id);
+        activeTransitions->find(property);
     if (activeTransitionIter != activeTransitions->end()) {
       const RunningTransition* runningTransition = &activeTransitionIter->value;
-      to = CSSAnimatableValueFactory::create(id, style);
+      to = CSSAnimatableValueFactory::create(property.cssProperty(), style);
       const AnimatableValue* activeTo = runningTransition->to.get();
       if (to->equals(activeTo))
         return;
-      update.cancelTransition(id);
+      update.cancelTransition(property);
       DCHECK(!element->elementAnimations() ||
              !element->elementAnimations()->isAnimationStyleChange());
 
       if (to->equals(runningTransition->reversingAdjustedStartValue.get()))
         interruptedTransition = runningTransition;
     }
   }
 
-  if (CSSPropertyEquality::propertiesEqual(id, oldStyle, style))
+  if (CSSPropertyEquality::propertiesEqual(property.cssProperty(), oldStyle,
+                                           style))
     return;
 
   if (!to)
-    to = CSSAnimatableValueFactory::create(id, style);
+    to = CSSAnimatableValueFactory::create(property.cssProperty(), style);
   RefPtr<AnimatableValue> from =
-      CSSAnimatableValueFactory::create(id, oldStyle);
+      CSSAnimatableValueFactory::create(property.cssProperty(), oldStyle);
 
   // TODO(alancutter): Support transitions on registered custom properties and
   // give the map a PropertyRegistry.
   CSSInterpolationTypesMap map(nullptr);
   InterpolationEnvironment oldEnvironment(map, oldStyle);
   InterpolationEnvironment newEnvironment(map, style);
   InterpolationValue start = nullptr;
   InterpolationValue end = nullptr;
   const InterpolationType* transitionType = nullptr;
-  PropertyHandle property(id);
   for (const auto& interpolationType : map.get(property)) {
     start = interpolationType->maybeConvertUnderlyingValue(oldEnvironment);
     if (!start) {
       continue;
     }
     end = interpolationType->maybeConvertUnderlyingValue(newEnvironment);
     if (!end) {
       continue;
     }
     // Merge will only succeed if the two values are considered interpolable.
@@ skipping 62 matching lines @@
   timing.timingFunction = LinearTimingFunction::shared();
   keyframes.push_back(startKeyframe);
 
   RefPtr<TransitionKeyframe> endKeyframe = TransitionKeyframe::create(property);
   endKeyframe->setValue(TypedInterpolationValue::create(
       *transitionType, end.interpolableValue->clone(),
       end.nonInterpolableValue));
   endKeyframe->setOffset(1);
   keyframes.push_back(endKeyframe);
 
-  if (CompositorAnimations::isCompositableProperty(id)) {
+  if (CompositorAnimations::isCompositableProperty(property.cssProperty())) {
     delayKeyframe->setCompositorValue(from);
     startKeyframe->setCompositorValue(from);
     endKeyframe->setCompositorValue(to);
   }
 
   TransitionKeyframeEffectModel* model =
       TransitionKeyframeEffectModel::create(keyframes);
-  update.startTransition(id, from.get(), to.get(), reversingAdjustedStartValue,
-                         reversingShorteningFactor,
+  update.startTransition(property, from.get(), to.get(),
+                         reversingAdjustedStartValue, reversingShorteningFactor,
                          *InertEffect::create(model, timing, false, 0));
   DCHECK(!element->elementAnimations() ||
          !element->elementAnimations()->isAnimationStyleChange());
 }
 
 void CSSAnimations::calculateTransitionUpdate(CSSAnimationUpdate& update,
                                               const Element* animatingElement,
                                               const ComputedStyle& style) {
   if (!animatingElement)
     return;
@@ skipping 48 matching lines @@
 
         // FIXME: We should transition if an !important property changes even
         // when an animation is running, but this is a bit hard to do with the
         // current applyMatchedProperties system.
         PropertyHandle property = PropertyHandle(id);
         if (!update.activeInterpolationsForAnimations().contains(property) &&
             (!elementAnimations ||
              !elementAnimations->cssAnimations()
                   .m_previousActiveInterpolationsForAnimations.contains(
                       property))) {
-          calculateTransitionUpdateForProperty(id, *transitionData, i, oldStyle,
-                                               style, activeTransitions, update,
-                                               animatingElement);
+          calculateTransitionUpdateForProperty(
+              property, *transitionData, i, oldStyle, style, activeTransitions,
+              update, animatingElement);
         }
       }
     }
   }
 
   if (activeTransitions) {
     for (const auto& entry : *activeTransitions) {
-      CSSPropertyID id = entry.key;
+      const PropertyHandle& property = entry.key;
+      // TODO(alancutter): Handle transitions on custom properties.
+      DCHECK(!property.isCSSCustomProperty());
+      CSSPropertyID id = property.cssProperty();
       if (!anyTransitionHadTransitionAll && !animationStyleRecalc &&
           !listedProperties.test(id - firstCSSProperty)) {
-        update.cancelTransition(id);
+        update.cancelTransition(property);
       } else if (entry.value.animation->finishedInternal()) {
-        update.finishTransition(id);
+        update.finishTransition(property);
       }
     }
   }
   calculateTransitionActiveInterpolations(update, animatingElement);
 }
 
 void CSSAnimations::cancel() {
   for (const auto& runningAnimation : m_runningAnimations) {
     runningAnimation->animation->cancel();
     runningAnimation->animation->update(TimingUpdateOnDemand);
@@ skipping 73 matching lines @@
   } else {
     HeapVector<Member<const InertEffect>> newTransitions;
     for (const auto& entry : update.newTransitions())
       newTransitions.push_back(entry.value.effect.get());
 
     HeapHashSet<Member<const Animation>> cancelledAnimations;
     if (!update.cancelledTransitions().isEmpty()) {
       DCHECK(elementAnimations);
       const TransitionMap& transitionMap =
           elementAnimations->cssAnimations().m_transitions;
-      for (CSSPropertyID id : update.cancelledTransitions()) {
-        DCHECK(transitionMap.contains(id));
-        cancelledAnimations.insert(transitionMap.get(id).animation.get());
+      for (const PropertyHandle& property : update.cancelledTransitions()) {
+        DCHECK(transitionMap.contains(property));
+        cancelledAnimations.insert(transitionMap.get(property).animation.get());
       }
     }
 
     activeInterpolationsForTransitions = EffectStack::activeInterpolations(
         effectStack, &newTransitions, &cancelledAnimations,
         KeyframeEffectReadOnly::TransitionPriority, isStylePropertyHandle);
   }
 
   // Properties being animated by animations don't get values from transitions
   // applied.
@@ skipping 75 matching lines @@
 EventTarget* CSSAnimations::TransitionEventDelegate::eventTarget() const {
   return EventPath::eventTargetRespectingTargetRules(*m_transitionTarget);
 }
 
 void CSSAnimations::TransitionEventDelegate::onEventCondition(
     const AnimationEffectReadOnly& animationNode) {
   const AnimationEffectReadOnly::Phase currentPhase = animationNode.getPhase();
   if (currentPhase == AnimationEffectReadOnly::PhaseAfter &&
       currentPhase != m_previousPhase &&
       document().hasListenerType(Document::TRANSITIONEND_LISTENER)) {
-    String propertyName = getPropertyNameString(m_property);
+    String propertyName = m_property.isCSSCustomProperty()
+                              ? m_property.customPropertyName()
+                              : getPropertyNameString(m_property.cssProperty());
     const Timing& timing = animationNode.specifiedTiming();
     double elapsedTime = timing.iterationDuration;
     const AtomicString& eventType = EventTypeNames::transitionend;
     String pseudoElement =
         PseudoElement::pseudoElementNameForEvents(getPseudoId());
     TransitionEvent* event = TransitionEvent::create(
         eventType, propertyName, elapsedTime, pseudoElement);
     event->setTarget(eventTarget());
     document().enqueueAnimationFrameEvent(event);
   }
@@ skipping 79 matching lines @@
              isCustomPropertyHandle);
 }
 
 DEFINE_TRACE(CSSAnimations) {
   visitor->trace(m_transitions);
   visitor->trace(m_pendingUpdate);
   visitor->trace(m_runningAnimations);
 }
 
 }  // namespace blink