Pass RenderStyle / RenderObject by reference in more places

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 118 matching lines @@
             timing.direction = Timing::PlaybackDirectionAlternateReverse;
             break;
         default:
             ASSERT_NOT_REACHED();
         }
     }
     isPaused = animationData->isPlayStateSet() && animationData->playState() == AnimPlayStatePaused;
     return animationData->isTimingFunctionSet() ? animationData->timingFunction() : CSSAnimationData::initialAnimationTimingFunction();
 }
 
-void calculateCandidateTransitionForProperty(const CSSAnimationData* anim, CSSPropertyID id, const RenderStyle* oldStyle, const RenderStyle* newStyle, CandidateTransitionMap& candidateMap)
+static void calculateCandidateTransitionForProperty(const CSSAnimationData* anim, CSSPropertyID id, const RenderStyle& oldStyle, const RenderStyle& newStyle, CandidateTransitionMap& candidateMap)
 {
-    if (!CSSPropertyAnimation::propertiesEqual(id, oldStyle, newStyle)) {
+    if (!CSSPropertyAnimation::propertiesEqual(id, &oldStyle, &newStyle)) {
         RefPtr<AnimatableValue> from = CSSAnimatableValueFactory::create(id, oldStyle);
         RefPtr<AnimatableValue> to = CSSAnimatableValueFactory::create(id, newStyle);
         // If we have multiple transitions on the same property, we will use the
         // last one since we iterate over them in order and this will override
         // a previously set CandidateTransition.
         if (from->usesNonDefaultInterpolationWith(to.get()))
             candidateMap.add(id, CandidateTransition(from.release(), to.release(), anim));
     }
 }
 
-void computeCandidateTransitions(const RenderStyle* oldStyle, const RenderStyle* newStyle, CandidateTransitionMap& candidateMap, HashSet<CSSPropertyID>& listedProperties)
+static void computeCandidateTransitions(const RenderStyle& oldStyle, const RenderStyle& newStyle, CandidateTransitionMap& candidateMap, HashSet<CSSPropertyID>& listedProperties)
 {
-    if (!newStyle->transitions())
+    if (!newStyle.transitions())
         return;
 
-    for (size_t i = 0; i < newStyle->transitions()->size(); ++i) {
-        const CSSAnimationData* anim = newStyle->transitions()->animation(i);
+    for (size_t i = 0; i < newStyle.transitions()->size(); ++i) {
+        const CSSAnimationData* anim = newStyle.transitions()->animation(i);
         CSSAnimationData::AnimationMode mode = anim->animationMode();
         if (anim->duration() + anim->delay() <= 0 || mode == CSSAnimationData::AnimateNone)
             continue;
 
         bool animateAll = mode == CSSAnimationData::AnimateAll;
         ASSERT(animateAll || mode == CSSAnimationData::AnimateSingleProperty);
         const StylePropertyShorthand& propertyList = animateAll ? CSSAnimations::animatableProperties() : shorthandForProperty(anim->property());
         if (!propertyList.length()) {
             if (!CSSAnimations::isAnimatableProperty(anim->property()))
                 continue;
@@ skipping 26 matching lines @@
 }
 
 CSSAnimationUpdateScope::~CSSAnimationUpdateScope()
 {
     if (!m_target)
         return;
     if (ActiveAnimations* activeAnimations = m_target->activeAnimations())
         activeAnimations->cssAnimations().maybeApplyPendingUpdate(m_target);
 }
 
-PassOwnPtr<CSSAnimationUpdate> CSSAnimations::calculateUpdate(Element* element, const RenderStyle* style, StyleResolver* resolver)
+PassOwnPtr<CSSAnimationUpdate> CSSAnimations::calculateUpdate(Element* element, const RenderStyle& style, StyleResolver* resolver)
 {
     ASSERT(RuntimeEnabledFeatures::webAnimationsCSSEnabled());
     OwnPtr<CSSAnimationUpdate> update = adoptPtr(new CSSAnimationUpdate());
     calculateAnimationUpdate(update.get(), element, style, resolver);
     calculateAnimationCompositableValues(update.get(), element);
     calculateTransitionUpdate(update.get(), element, style);
     calculateTransitionCompositableValues(update.get(), element);
     return update->isEmpty() ? nullptr : update.release();
 }
 
-void CSSAnimations::calculateAnimationUpdate(CSSAnimationUpdate* update, Element* element, const RenderStyle* style, StyleResolver* resolver)
+void CSSAnimations::calculateAnimationUpdate(CSSAnimationUpdate* update, Element* element, const RenderStyle& style, StyleResolver* resolver)
 {
-    const CSSAnimationDataList* animationDataList = style->animations();
+    const CSSAnimationDataList* animationDataList = style.animations();
     const CSSAnimations* cssAnimations = element->activeAnimations() ? &element->activeAnimations()->cssAnimations() : 0;
 
     HashSet<AtomicString> inactive;
     if (cssAnimations)
         for (AnimationMap::const_iterator iter = cssAnimations->m_animations.begin(); iter != cssAnimations->m_animations.end(); ++iter)
             inactive.add(iter->key);
 
-    if (style->display() != NONE) {
+    if (style.display() != NONE) {
         for (size_t i = 0; animationDataList && i < animationDataList->size(); ++i) {
             const CSSAnimationData* animationData = animationDataList->animation(i);
             if (animationData->isNoneAnimation())
                 continue;
             ASSERT(animationData->isValidAnimation());
             AtomicString animationName(animationData->name());
 
             // Keyframes and animation properties are snapshotted when the
             // animation starts, so we don't need to track changes to these,
             // with the exception of play-state.
@@ skipping 135 matching lines @@
     bool isPaused;
     RefPtr<TimingFunction> timingFunction = timingFromAnimationData(newTransition.anim, timing, isPaused);
     ASSERT(!isPaused);
     timing.timingFunction = timingFunction;
     // Note that the backwards part is required for delay to work.
     timing.fillMode = Timing::FillModeBoth;
 
     update->startTransition(id, newTransition.from.get(), newTransition.to.get(), InertAnimation::create(effect, timing, isPaused));
 }
 
-void CSSAnimations::calculateTransitionUpdate(CSSAnimationUpdate* update, const Element* element, const RenderStyle* style)
+void CSSAnimations::calculateTransitionUpdate(CSSAnimationUpdate* update, const Element* element, const RenderStyle& style)
 {
     ActiveAnimations* activeAnimations = element->activeAnimations();
     const TransitionMap* transitions = activeAnimations ? &activeAnimations->cssAnimations().m_transitions : 0;
 
     HashSet<CSSPropertyID> listedProperties;
-    if (style->display() != NONE && element->renderer() && element->renderer()->style()) {
+    if (style.display() != NONE && element->renderer() && element->renderer()->style()) {
         CandidateTransitionMap candidateMap;
-        computeCandidateTransitions(element->renderer()->style(), style, candidateMap, listedProperties);
+        computeCandidateTransitions(*element->renderer()->style(), style, candidateMap, listedProperties);
         for (CandidateTransitionMap::const_iterator iter = candidateMap.begin(); iter != candidateMap.end(); ++iter) {
             // 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.
             if (!update->compositableValuesForAnimations().contains(iter->key)
                 && (!activeAnimations || !activeAnimations->cssAnimations().m_previousCompositableValuesForAnimations.contains(iter->key)))
                 calculateTransitionUpdateForProperty(update, iter->key, iter->value, transitions);
         }
     }
 
     if (transitions) {
@@ skipping 264 matching lines @@
             CSSPropertyID id = convertToCSSPropertyID(i);
             if (isAnimatableProperty(id))
                 properties.append(id);
         }
         propertyShorthand = StylePropertyShorthand(CSSPropertyInvalid, properties.begin(), properties.size());
     }
     return propertyShorthand;
 }
 
 } // namespace WebCore