Make a function to query whether a CSSPropertyID is valid and whether it has a name.

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 54 matching lines @@
 
 using PropertySet = HashSet<CSSPropertyID>;
 
 namespace {
 
 static StringKeyframeEffectModel* createKeyframeEffectModel(StyleResolver* resolver, const Element* animatingElement, Element& element, const ComputedStyle* style, const ComputedStyle* parentStyle, const AtomicString& name, TimingFunction* defaultTimingFunction, size_t animationIndex)
 {
     // When the animating element is null, use its parent for scoping purposes.
     const Element* elementForScoping = animatingElement ? animatingElement : &element;
     const StyleRuleKeyframes* keyframesRule = resolver->findKeyframesRule(elementForScoping, name);
-    ASSERT(keyframesRule);
+    DCHECK(keyframesRule);
 
     StringKeyframeVector keyframes;
     const HeapVector<Member<StyleRuleKeyframe>>& styleKeyframes = keyframesRule->keyframes();
 
     // Construct and populate the style for each keyframe
     PropertySet specifiedPropertiesForUseCounter;
     for (size_t i = 0; i < styleKeyframes.size(); ++i) {
         const StyleRuleKeyframe* styleKeyframe = styleKeyframes[i].get();
         RefPtr<StringKeyframe> keyframe = StringKeyframe::create();
         const Vector<double>& offsets = styleKeyframe->keys();
-        ASSERT(!offsets.isEmpty());
+        DCHECK(!offsets.isEmpty());
         keyframe->setOffset(offsets[0]);
         keyframe->setEasing(defaultTimingFunction);
         const StylePropertySet& properties = styleKeyframe->properties();
         for (unsigned j = 0; j < properties.propertyCount(); j++) {
             CSSPropertyID property = properties.propertyAt(j).id();
             specifiedPropertiesForUseCounter.add(property);
             if (property == CSSPropertyAnimationTimingFunction) {
                 const CSSValue& value = properties.propertyAt(j).value();
                 RefPtr<TimingFunction> timingFunction;
                 if (value.isInheritedValue() && parentStyle->animations()) {
@@ skipping 11 matching lines @@
         }
         keyframes.append(keyframe);
         // The last keyframe specified at a given offset is used.
         for (size_t j = 1; j < offsets.size(); ++j) {
             keyframes.append(toStringKeyframe(keyframe->cloneWithOffset(offsets[j]).get()));
         }
     }
 
     DEFINE_STATIC_LOCAL(SparseHistogram, propertyHistogram, ("WebCore.Animation.CSSProperties"));
     for (CSSPropertyID property : specifiedPropertiesForUseCounter) {
-        ASSERT(property != CSSPropertyInvalid);
+        DCHECK_NE(property, CSSPropertyInvalid);

[sashab, 2016/08/15 07:23:13]

Maybe this could use propertyHasName() too? Should we have a isValidPropertyId()
method?

[meade_UTC10, 2016/09/29 07:39:56]

Done.

         propertyHistogram.sample(UseCounter::mapCSSPropertyIdToCSSSampleIdForHistogram(property));
     }
 
     // Merge duplicate keyframes.
     std::stable_sort(keyframes.begin(), keyframes.end(), Keyframe::compareOffsets);
     size_t targetIndex = 0;
     for (size_t i = 1; i < keyframes.size(); i++) {
         if (keyframes[i]->offset() == keyframes[targetIndex]->offset()) {
             for (const auto& property : keyframes[i]->properties())
                 keyframes[targetIndex]->setCSSPropertyValue(property.cssProperty(), keyframes[i]->cssPropertyValue(property.cssProperty()));
@@ skipping 13 matching lines @@
         startKeyframe->setEasing(defaultTimingFunction);
         keyframes.prepend(startKeyframe);
     }
     RefPtr<StringKeyframe> endKeyframe = keyframes[keyframes.size() - 1];
     if (endKeyframe->offset() != 1) {
         endKeyframe = StringKeyframe::create();
         endKeyframe->setOffset(1);
         endKeyframe->setEasing(defaultTimingFunction);
         keyframes.append(endKeyframe);
     }
-    ASSERT(keyframes.size() >= 2);
-    ASSERT(!keyframes.first()->offset());
-    ASSERT(keyframes.last()->offset() == 1);
+    DCHECK_GE(keyframes.size(), 2UL);
+    DCHECK(!keyframes.first()->offset());
+    DCHECK_EQ(keyframes.last()->offset(), 1);
 
     // FIXME: This is only used for use counting neutral keyframes running on the compositor.
     PropertySet allProperties;
     for (const auto& keyframe : keyframes) {
         for (const auto& property : keyframe->properties())
             allProperties.add(property.cssProperty());
     }
     const PropertyHandleSet& startKeyframeProperties = startKeyframe->properties();
     const PropertyHandleSet& endKeyframeProperties = endKeyframe->properties();
     bool missingStartValues = startKeyframeProperties.size() < allProperties.size();
@@ skipping 97 matching lines @@
             update.updateCompositorKeyframes(&animation);
     }
 }
 
 void CSSAnimations::calculateAnimationUpdate(CSSAnimationUpdate& update, const Element* animatingElement, Element& element, const ComputedStyle& style, ComputedStyle* parentStyle, StyleResolver* resolver)
 {
     const ElementAnimations* elementAnimations = animatingElement ? animatingElement->elementAnimations() : nullptr;
 
     bool isAnimationStyleChange = elementAnimations && elementAnimations->isAnimationStyleChange();
 
-#if !ENABLE(ASSERT)
+#if DCHECK_IS_ON()
     // If we're in an animation style change, no animations can have started, been cancelled or changed play state.
-    // When ASSERT is enabled, we verify this optimization.
+    // When DCHECK is enabled, we verify this optimization.
     if (isAnimationStyleChange)
         return;
 #endif
 
     const CSSAnimationData* animationData = style.animations();
     const CSSAnimations* cssAnimations = elementAnimations ? &elementAnimations->cssAnimations() : nullptr;
     const Element* elementForScoping = animatingElement ? animatingElement : &element;
 
     Vector<bool> cancelRunningAnimationFlags(cssAnimations ? cssAnimations->m_runningAnimations.size() : 0);
     for (bool& flag : cancelRunningAnimationFlags)
@@ skipping 39 matching lines @@
                     }
                 }
             }
 
             if (existingAnimation) {
                 cancelRunningAnimationFlags[existingAnimationIndex] = false;
 
                 Animation* animation = existingAnimation->animation.get();
 
                 if (keyframesRule != existingAnimation->styleRule || keyframesRule->version() != existingAnimation->styleRuleVersion || existingAnimation->specifiedTiming != specifiedTiming) {
-                    ASSERT(!isAnimationStyleChange);
+                    DCHECK(!isAnimationStyleChange);
                     update.updateAnimation(existingAnimationIndex, animation, *InertEffect::create(
                         createKeyframeEffectModel(resolver, animatingElement, element, &style, parentStyle, name, keyframeTimingFunction.get(), i),
                         timing, isPaused, animation->unlimitedCurrentTimeInternal()), specifiedTiming, keyframesRule);
                 }
 
                 if (isPaused != animation->paused()) {
-                    ASSERT(!isAnimationStyleChange);
+                    DCHECK(!isAnimationStyleChange);
                     update.toggleAnimationIndexPaused(existingAnimationIndex);
                 }
             } else {
-                ASSERT(!isAnimationStyleChange);
+                DCHECK(!isAnimationStyleChange);
                 update.startAnimation(name, nameIndex, *InertEffect::create(
                     createKeyframeEffectModel(resolver, animatingElement, element, &style, parentStyle, name, keyframeTimingFunction.get(), i),
                     timing, isPaused, 0), specifiedTiming, keyframesRule);
             }
         }
     }
 
     for (size_t i = 0; i < cancelRunningAnimationFlags.size(); i++) {
         if (cancelRunningAnimationFlags[i]) {
-            ASSERT(cssAnimations && !isAnimationStyleChange);
+            DCHECK(cssAnimations && !isAnimationStyleChange);
             update.cancelAnimation(i, *cssAnimations->m_runningAnimations[i]->animation);
         }
     }
 }
 
 void CSSAnimations::snapshotCompositorKeyframes(Element& element, CSSAnimationUpdate& update, const ComputedStyle& style, const ComputedStyle* parentStyle)
 {
     const auto& snapshot = [&element, &style, parentStyle](const AnimationEffect* effect)
     {
         const KeyframeEffectModelBase* keyframeEffect = getKeyframeEffectModelBase(effect);
@@ skipping 47 matching lines @@
         KeyframeEffect* effect = toKeyframeEffect(entry.animation->effect());
 
         effect->setModel(entry.effect->model());
         effect->updateSpecifiedTiming(entry.effect->specifiedTiming());
 
         m_runningAnimations[entry.index]->update(entry);
     }
 
     const Vector<size_t>& cancelledIndices = m_pendingUpdate.cancelledAnimationIndices();
     for (size_t i = cancelledIndices.size(); i-- > 0;) {
-        ASSERT(i == cancelledIndices.size() - 1 || cancelledIndices[i] < cancelledIndices[i + 1]);
+        DCHECK(i == cancelledIndices.size() - 1 || cancelledIndices[i] < cancelledIndices[i + 1]);
         Animation& animation = *m_runningAnimations[cancelledIndices[i]]->animation;
         animation.cancel();
         animation.update(TimingUpdateOnDemand);
         m_runningAnimations.remove(cancelledIndices[i]);
     }
 
     for (const auto& entry : m_pendingUpdate.newAnimations()) {
         const InertEffect* inertAnimation = entry.effect.get();
         AnimationEventDelegate* eventDelegate = new AnimationEventDelegate(element, entry.name);
         KeyframeEffect* effect = KeyframeEffect::create(element, inertAnimation->model(), inertAnimation->specifiedTiming(), KeyframeEffect::DefaultPriority, eventDelegate);
         Animation* animation = element->document().timeline().play(effect);
         animation->setId(entry.name);
         if (inertAnimation->paused())
             animation->pause();
         animation->update(TimingUpdateOnDemand);
 
         m_runningAnimations.append(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<KeyframeEffect>, double>> retargetedCompositorTransitions;
     for (CSSPropertyID id : m_pendingUpdate.cancelledTransitions()) {
-        ASSERT(m_transitions.contains(id));
+        DCHECK(m_transitions.contains(id));
 
         Animation* animation = m_transitions.take(id).animation;
         KeyframeEffect* effect = toKeyframeEffect(animation->effect());
         if (effect->hasActiveAnimationsOnCompositor(id) && m_pendingUpdate.newTransitions().find(id) != m_pendingUpdate.newTransitions().end() && !animation->limited())
             retargetedCompositorTransitions.add(id, std::pair<KeyframeEffect*, 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()->isKeyframeEffect())
@@ skipping 54 matching lines @@
 
         KeyframeEffect* transition = KeyframeEffect::create(element, model, inertAnimation->specifiedTiming(), KeyframeEffect::TransitionPriority, eventDelegate);
         Animation* animation = element->document().timeline().play(transition);
         animation->setId(getPropertyName(newTransition.id));
         // Set the current time as the start time for retargeted transitions
         if (retargetedCompositorTransitions.contains(id))
             animation->setStartTime(element->document().timeline().currentTime());
         animation->update(TimingUpdateOnDemand);
         runningTransition.animation = animation;
         m_transitions.set(id, runningTransition);
-        ASSERT(id != CSSPropertyInvalid);
+        DCHECK_NE(id, CSSPropertyInvalid);

[sashab, 2016/08/15 07:23:13]

Same comment as above

[meade_UTC10, 2016/09/29 07:39:56]

Done.

 
         DEFINE_STATIC_LOCAL(SparseHistogram, propertyHistogram, ("WebCore.Animation.CSSProperties"));
         propertyHistogram.sample(UseCounter::mapCSSPropertyIdToCSSSampleIdForHistogram(id));
     }
     clearPendingUpdate();
 }
 
 void CSSAnimations::calculateTransitionUpdateForProperty(CSSPropertyID id, 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);
         if (activeTransitionIter != activeTransitions->end()) {
             const RunningTransition* runningTransition = &activeTransitionIter->value;
             to = CSSAnimatableValueFactory::create(id, style);
             const AnimatableValue* activeTo = runningTransition->to;
             if (to->equals(activeTo))
                 return;
             update.cancelTransition(id);
-            ASSERT(!element->elementAnimations() || !element->elementAnimations()->isAnimationStyleChange());
+            DCHECK(!element->elementAnimations() || !element->elementAnimations()->isAnimationStyleChange());
 
             if (to->equals(runningTransition->reversingAdjustedStartValue.get()))
                 interruptedTransition = runningTransition;
         }
     }
 
     if (CSSPropertyEquality::propertiesEqual(id, oldStyle, style))
         return;
     if (!to)
         to = CSSAnimatableValueFactory::create(id, style);
@@ skipping 48 matching lines @@
 
     RefPtr<AnimatableValueKeyframe> endKeyframe = AnimatableValueKeyframe::create();
     endKeyframe->setPropertyValue(id, to.get());
     endKeyframe->setOffset(1);
     keyframes.append(endKeyframe);
 
     AnimatableValueKeyframeEffectModel* model = AnimatableValueKeyframeEffectModel::create(keyframes);
     update.startTransition(
         id, from.get(), to.get(), reversingAdjustedStartValue, reversingShorteningFactor,
         *InertEffect::create(model, timing, false, 0));
-    ASSERT(!element->elementAnimations() || !element->elementAnimations()->isAnimationStyleChange());
+    DCHECK(!element->elementAnimations() || !element->elementAnimations()->isAnimationStyleChange());
 }
 
 void CSSAnimations::calculateTransitionUpdate(CSSAnimationUpdate& update, const Element* animatingElement, const ComputedStyle& style)
 {
     if (!animatingElement)
         return;
 
     if (animatingElement->document().printing() || animatingElement->document().wasPrinting())
         return;
 
     ElementAnimations* elementAnimations = animatingElement->elementAnimations();
     const TransitionMap* activeTransitions = elementAnimations ? &elementAnimations->cssAnimations().m_transitions : nullptr;
     const CSSTransitionData* transitionData = style.transitions();
 
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
     // In debug builds we verify that it would have been safe to avoid populating and testing listedProperties if the style recalc is due to animation.
     const bool animationStyleRecalc = false;
 #else
     // In release builds we avoid the cost of checking for new and interrupted transitions if the style recalc is due to animation.
     const bool animationStyleRecalc = elementAnimations && elementAnimations->isAnimationStyleChange();
 #endif
 
     std::bitset<numCSSProperties> listedProperties;
     bool anyTransitionHadTransitionAll = false;
     const LayoutObject* layoutObject = animatingElement->layoutObject();
     if (!animationStyleRecalc && style.display() != NONE && layoutObject && layoutObject->style() && transitionData) {
         const ComputedStyle& oldStyle = *layoutObject->style();
 
         for (size_t i = 0; i < transitionData->propertyList().size(); ++i) {
             const CSSTransitionData::TransitionProperty& transitionProperty = transitionData->propertyList()[i];
             if (transitionProperty.propertyType != CSSTransitionData::TransitionKnownProperty)
                 continue;
 
             CSSPropertyID property = resolveCSSPropertyID(transitionProperty.unresolvedProperty);
             bool animateAll = property == CSSPropertyAll;
             if (animateAll)
                 anyTransitionHadTransitionAll = true;
             const StylePropertyShorthand& propertyList = animateAll ? CSSAnimations::propertiesForTransitionAll() : shorthandForProperty(property);
             // If not a shorthand we only execute one iteration of this loop, and refer to the property directly.
             for (unsigned j = 0; !j || j < propertyList.length(); ++j) {
                 CSSPropertyID id = propertyList.length() ? propertyList.properties()[j] : property;
-                ASSERT(id >= firstCSSProperty);
+                DCHECK(propertyHasName(id));
 
                 if (!animateAll) {
                     if (CSSPropertyMetadata::isInterpolableProperty(id))
                         listedProperties.set(id - firstCSSProperty);
                     else
                         continue;
                 }
 
                 // 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);
                 }
             }
         }
     }
 
     if (activeTransitions) {
         for (const auto& entry : *activeTransitions) {
             CSSPropertyID id = entry.key;
             if (!anyTransitionHadTransitionAll && !animationStyleRecalc && !listedProperties.test(id - firstCSSProperty)) {
                 // TODO: Figure out why this fails on Chrome OS login page. crbug.com/365507
-                // ASSERT(animation.playStateInternal() == Animation::Finished || !(elementAnimations && elementAnimations->isAnimationStyleChange()));
+                // DCHECK(animation.playStateInternal() == Animation::Finished || !(elementAnimations && elementAnimations->isAnimationStyleChange()));
                 update.cancelTransition(id);
             } else if (entry.value.animation->finishedInternal()) {
                 update.finishTransition(id);
             }
         }
     }
 }
 
 void CSSAnimations::cancel()
 {
@@ skipping 46 matching lines @@
     ActiveInterpolationsMap activeInterpolationsForTransitions;
     if (update.newTransitions().isEmpty() && update.cancelledTransitions().isEmpty()) {
         activeInterpolationsForTransitions = AnimationStack::activeInterpolations(animationStack, nullptr, nullptr, KeyframeEffect::TransitionPriority, isStylePropertyHandle);
     } else {
         HeapVector<Member<const InertEffect>> newTransitions;
         for (const auto& entry : update.newTransitions())
             newTransitions.append(entry.value.effect.get());
 
         HeapHashSet<Member<const Animation>> cancelledAnimations;
         if (!update.cancelledTransitions().isEmpty()) {
-            ASSERT(elementAnimations);
+            DCHECK(elementAnimations);
             const TransitionMap& transitionMap = elementAnimations->cssAnimations().m_transitions;
             for (CSSPropertyID id : update.cancelledTransitions()) {
-                ASSERT(transitionMap.contains(id));
+                DCHECK(transitionMap.contains(id));
                 cancelledAnimations.add(transitionMap.get(id).animation.get());
             }
         }
 
         activeInterpolationsForTransitions = AnimationStack::activeInterpolations(animationStack, &newTransitions, &cancelledAnimations, KeyframeEffect::TransitionPriority, isStylePropertyHandle);
     }
 
     // Properties being animated by animations don't get values from transitions applied.
     if (!update.activeInterpolationsForAnimations().isEmpty() && !activeInterpolationsForTransitions.isEmpty()) {
         for (const auto& entry : update.activeInterpolationsForAnimations())
@@ skipping 32 matching lines @@
         const double startDelay = animationNode.specifiedTiming().startDelay;
         const double elapsedTime = startDelay < 0 ? -startDelay : 0;
         maybeDispatch(Document::ANIMATIONSTART_LISTENER, EventTypeNames::animationstart, elapsedTime);
     }
 
     if (currentPhase == AnimationEffect::PhaseActive && m_previousPhase == currentPhase && m_previousIteration != currentIteration) {
         // We fire only a single event for all iterations thast terminate
         // between a single pair of samples. See http://crbug.com/275263. For
         // compatibility with the existing implementation, this event uses
         // the elapsedTime for the first iteration in question.
-        ASSERT(!std::isnan(animationNode.specifiedTiming().iterationDuration));
+        DCHECK(!std::isnan(animationNode.specifiedTiming().iterationDuration));
         const double elapsedTime = animationNode.specifiedTiming().iterationDuration * (m_previousIteration + 1);
         maybeDispatch(Document::ANIMATIONITERATION_LISTENER, EventTypeNames::animationiteration, elapsedTime);
     }
 
     if (currentPhase == AnimationEffect::PhaseAfter && m_previousPhase != AnimationEffect::PhaseAfter)
         maybeDispatch(Document::ANIMATIONEND_LISTENER, EventTypeNames::animationend, animationNode.activeDurationInternal());
 
     m_previousPhase = currentPhase;
     m_previousIteration = currentIteration;
 }
@@ skipping 81 matching lines @@
 }
 
 DEFINE_TRACE(CSSAnimations)
 {
     visitor->trace(m_transitions);
     visitor->trace(m_pendingUpdate);
     visitor->trace(m_runningAnimations);
 }
 
 } // namespace blink