Pass RenderStyle / RenderObject by reference in more places

Source/core/frame/animation/CompositeAnimation.cpp

 /*
  * Copyright (C) 2007 Apple 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:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 52 matching lines @@
     if (!m_keyframeAnimations.isEmpty()) {
         AnimationNameMap::const_iterator animationsEnd = m_keyframeAnimations.end();
         for (AnimationNameMap::const_iterator it = m_keyframeAnimations.begin(); it != animationsEnd; ++it) {
             KeyframeAnimation* anim = it->value.get();
             animationController()->animationWillBeRemoved(anim);
             anim->clear();
         }
     }
 }
 
-void CompositeAnimation::updateTransitions(RenderObject* renderer, RenderStyle* currentStyle, RenderStyle* targetStyle)
+void CompositeAnimation::updateTransitions(RenderObject& renderer, RenderStyle* currentStyle, RenderStyle& targetStyle)
 {
     // If currentStyle is null or there are no old or new transitions, just skip it
-    if (!currentStyle || (!targetStyle->transitions() && m_transitions.isEmpty()))
+    if (!currentStyle || (!targetStyle.transitions() && m_transitions.isEmpty()))
         return;
 
     // Mark all existing transitions as no longer active. We will mark the still active ones
     // in the next loop and then toss the ones that didn't get marked.
     CSSPropertyTransitionsMap::const_iterator end = m_transitions.end();
     for (CSSPropertyTransitionsMap::const_iterator it = m_transitions.begin(); it != end; ++it)
         it->value->setActive(false);
 
     RefPtr<RenderStyle> modifiedCurrentStyle;
 
     // Check to see if we need to update the active transitions
-    if (targetStyle->transitions()) {
-        for (size_t i = 0; i < targetStyle->transitions()->size(); ++i) {
-            const CSSAnimationData* anim = targetStyle->transitions()->animation(i);
+    if (targetStyle.transitions()) {
+        for (size_t i = 0; i < targetStyle.transitions()->size(); ++i) {
+            const CSSAnimationData* anim = targetStyle.transitions()->animation(i);
             bool isActiveTransition = anim->duration() || anim->delay() > 0;
 
             CSSAnimationData::AnimationMode mode = anim->animationMode();
             if (mode == CSSAnimationData::AnimateNone)
                 continue;
 
             CSSPropertyID prop = anim->property();
 
             bool all = mode == CSSAnimationData::AnimateAll;
 
@@ skipping 29 matching lines @@
 
                     // This might be a transition that is just finishing. That would be the case
                     // if it were postActive. But we still need to check for equality because
                     // it could be just finishing AND changing to a new goal state.
                     //
                     // This implAnim might also not be an already running transition. It might be
                     // newly added to the list in a previous iteration. This would happen if
                     // you have both an explicit transition-property and 'all' in the same
                     // list. In this case, the latter one overrides the earlier one, so we
                     // behave as though this is a running animation being replaced.
-                    if (!implAnim->isTargetPropertyEqual(prop, targetStyle)) {
+                    if (!implAnim->isTargetPropertyEqual(prop, &targetStyle)) {
                         // For accelerated animations we need to return a new RenderStyle with the _current_ value
                         // of the property, so that restarted transitions use the correct starting point.
                         if (CSSPropertyAnimation::animationOfPropertyIsAccelerated(prop) && implAnim->isAccelerated()) {
                             if (!modifiedCurrentStyle)
                                 modifiedCurrentStyle = RenderStyle::clone(currentStyle);
 
                             implAnim->blendPropertyValueInStyle(prop, modifiedCurrentStyle.get());
                         }
                         animationController()->animationWillBeRemoved(implAnim);
                         m_transitions.remove(prop);
                         equal = false;
                     }
                 } else {
                     // We need to start a transition if it is active and the properties don't match
-                    equal = !isActiveTransition || CSSPropertyAnimation::propertiesEqual(prop, fromStyle, targetStyle);
+                    equal = !isActiveTransition || CSSPropertyAnimation::propertiesEqual(prop, fromStyle, &targetStyle);
                 }
 
                 // We can be in this loop with an inactive transition (!isActiveTransition). We need
                 // to do that to check to see if we are canceling a transition. But we don't want to
                 // start one of the inactive transitions. So short circuit that here. (See
                 // <https://bugs.webkit.org/show_bug.cgi?id=24787>
                 if (!equal && isActiveTransition) {
                     // Add the new transition
                     m_transitions.set(prop, ImplicitAnimation::create(const_cast<CSSAnimationData*>(anim), prop, renderer, this, modifiedCurrentStyle ? modifiedCurrentStyle.get() : fromStyle));
                 }
@@ skipping 14 matching lines @@
             animationController()->animationWillBeRemoved(anim);
             toBeRemoved.append(anim->animatingProperty());
         }
     }
 
     // Now remove the transitions from the list
     for (size_t j = 0; j < toBeRemoved.size(); ++j)
         m_transitions.remove(toBeRemoved[j]);
 }
 
-void CompositeAnimation::updateKeyframeAnimations(RenderObject* renderer, RenderStyle* currentStyle, RenderStyle* targetStyle)
+void CompositeAnimation::updateKeyframeAnimations(RenderObject& renderer, RenderStyle* currentStyle, RenderStyle& targetStyle)
 {
     // Nothing to do if we don't have any animations, and didn't have any before
-    if (m_keyframeAnimations.isEmpty() && !targetStyle->hasAnimations())
+    if (m_keyframeAnimations.isEmpty() && !targetStyle.hasAnimations())
         return;
 
     AnimationNameMap::const_iterator kfend = m_keyframeAnimations.end();
 
-    if (currentStyle && currentStyle->hasAnimations() && targetStyle->hasAnimations() && *(currentStyle->animations()) == *(targetStyle->animations())) {
+    if (currentStyle && currentStyle->hasAnimations() && targetStyle.hasAnimations() && *(currentStyle->animations()) == *(targetStyle.animations())) {
         // The current and target animations are the same so we just need to toss any
         // animation which is finished (postActive).
         for (AnimationNameMap::const_iterator it = m_keyframeAnimations.begin(); it != kfend; ++it) {
             if (it->value->postActive())
                 it->value->setIndex(-1);
         }
     } else {
         // Mark all existing animations as no longer active.
         for (AnimationNameMap::const_iterator it = m_keyframeAnimations.begin(); it != kfend; ++it)
             it->value->setIndex(-1);
 
         // Toss the animation order map.
         m_keyframeAnimationOrderList.clear();
 
         DEFINE_STATIC_LOCAL(const AtomicString, none, ("none", AtomicString::ConstructFromLiteral));
 
         // Now mark any still active animations as active and add any new animations.
-        if (targetStyle->animations()) {
-            int numAnims = targetStyle->animations()->size();
+        if (targetStyle.animations()) {
+            int numAnims = targetStyle.animations()->size();
             for (int i = 0; i < numAnims; ++i) {
-                const CSSAnimationData* anim = targetStyle->animations()->animation(i);
+                const CSSAnimationData* anim = targetStyle.animations()->animation(i);
                 if (!anim->isValidAnimation())
                     continue;
 
                 // See if there is a current animation for this name.
                 AtomicString name(anim->name());
                 RefPtr<KeyframeAnimation> keyframeAnim = m_keyframeAnimations.get(name);
                 if (keyframeAnim) {
                     // If this animation is postActive, skip it so it gets removed at the end of this function.
                     if (keyframeAnim->postActive())
                         continue;
@@ skipping 39 matching lines @@
         Vector<AtomicString> newOrderList;
         for (size_t j = 0; j < m_keyframeAnimationOrderList.size(); ++j) {
             AtomicString key = m_keyframeAnimationOrderList[j];
             if (m_keyframeAnimations.contains(key))
                 newOrderList.append(key);
         }
         m_keyframeAnimationOrderList.swap(newOrderList);
     }
 }
 
-PassRefPtr<RenderStyle> CompositeAnimation::animate(RenderObject* renderer, RenderStyle* currentStyle, RenderStyle* targetStyle)
+PassRefPtr<RenderStyle> CompositeAnimation::animate(RenderObject& renderer, RenderStyle* currentStyle, RenderStyle& targetStyle)
 {
     RefPtr<RenderStyle> resultStyle;
 
     // We don't do any transitions if we don't have a currentStyle (on startup).
     updateTransitions(renderer, currentStyle, targetStyle);
     updateKeyframeAnimations(renderer, currentStyle, targetStyle);
 
     if (currentStyle) {
         // Now that we have transition objects ready, let them know about the new goal state.  We want them
         // to fill in a RenderStyle*& only if needed.
         if (!m_transitions.isEmpty()) {
             CSSPropertyTransitionsMap::const_iterator end = m_transitions.end();
             for (CSSPropertyTransitionsMap::const_iterator it = m_transitions.begin(); it != end; ++it) {
                 if (ImplicitAnimation* anim = it->value.get())
-                    anim->animate(this, renderer, currentStyle, targetStyle, resultStyle);
+                    anim->animate(this, &renderer, currentStyle, &targetStyle, resultStyle);
             }
         }
     }
 
     // Now that we have animation objects ready, let them know about the new goal state.  We want them
     // to fill in a RenderStyle*& only if needed.
     for (Vector<AtomicString>::const_iterator it = m_keyframeAnimationOrderList.begin(); it != m_keyframeAnimationOrderList.end(); ++it) {
         RefPtr<KeyframeAnimation> keyframeAnim = m_keyframeAnimations.get(*it);
         ASSERT(keyframeAnim);
-        keyframeAnim->animate(this, renderer, currentStyle, targetStyle, resultStyle);
+        keyframeAnim->animate(this, &renderer, currentStyle, &targetStyle, resultStyle);
     }
 
-    return resultStyle ? resultStyle.release() : targetStyle;
+    return resultStyle ? resultStyle.release() : PassRefPtr<RenderStyle>(targetStyle);
 }
 
 PassRefPtr<RenderStyle> CompositeAnimation::getAnimatedStyle() const
 {
     RefPtr<RenderStyle> resultStyle;
     CSSPropertyTransitionsMap::const_iterator end = m_transitions.end();
     for (CSSPropertyTransitionsMap::const_iterator it = m_transitions.begin(); it != end; ++it) {
         if (ImplicitAnimation* implicitAnimation = it->value.get())
             implicitAnimation->getAnimatedStyle(resultStyle);
     }
@@ skipping 185 matching lines @@
             ImplicitAnimation* anim = it->value.get();
             if (anim->running())
                 ++count;
         }
     }
 
     return count;
 }
 
 } // namespace WebCore