cc: Make the ScopedPtrVector and ScopedPtrDeque containers act like STL vector and deque.

cc/layer_animation_controller.cc

 // Copyright 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/layer_animation_controller.h"
 
+#include <algorithm>
+
 #include "cc/animation.h"
 #include "cc/animation_registrar.h"
 #include "cc/keyframed_animation_curve.h"
 #include "cc/layer_animation_value_observer.h"
+#include "cc/scoped_ptr_algorithm.h"
 #include "ui/gfx/transform.h"
 
 namespace {
 gfx::Transform convertWebTransformationMatrixToTransform(const WebKit::WebTransformationMatrix& matrix)
 {
     gfx::Transform transform;
     transform.matrix().setDouble(0, 0, matrix.m11());
     transform.matrix().setDouble(0, 1, matrix.m21());
     transform.matrix().setDouble(0, 2, matrix.m31());
     transform.matrix().setDouble(0, 3, matrix.m41());
@@ skipping 35 matching lines @@
 }
 
 void LayerAnimationController::pauseAnimation(int animationId, double timeOffset)
 {
     for (size_t i = 0; i < m_activeAnimations.size(); ++i) {
         if (m_activeAnimations[i]->id() == animationId)
             m_activeAnimations[i]->setRunState(Animation::Paused, timeOffset + m_activeAnimations[i]->startTime());
     }
 }
 
+struct HasAnimationId {
+    HasAnimationId(int id) : m_id(id) { }
+    bool operator()(Animation* animation) const { return animation->id() == m_id; }
+private:
+    int m_id;
+};
+
 void LayerAnimationController::removeAnimation(int animationId)
 {
-    for (size_t i = 0; i < m_activeAnimations.size();) {
-        if (m_activeAnimations[i]->id() == animationId)
-            m_activeAnimations.remove(i);
-        else
-            i++;
-    }
+    ScopedPtrVector<Animation>& animations = m_activeAnimations;
+    animations.erase(cc::remove_if(animations, animations.begin(), animations.end(), HasAnimationId(animationId)), animations.end());
     updateActivation();
 }
 
+struct HasAnimationIdAndProperty {
+    HasAnimationIdAndProperty(int id, Animation::TargetProperty targetProperty) : m_id(id), m_targetProperty(targetProperty) { }
+    bool operator()(Animation* animation) const { return animation->id() == m_id && animation->targetProperty() == m_targetProperty; }
+private:
+    int m_id;
+    Animation::TargetProperty m_targetProperty;
+};
+
 void LayerAnimationController::removeAnimation(int animationId, Animation::TargetProperty targetProperty)
 {
-    for (size_t i = 0; i < m_activeAnimations.size();) {
-        if (m_activeAnimations[i]->id() == animationId && m_activeAnimations[i]->targetProperty() == targetProperty)
-            m_activeAnimations.remove(i);
-        else
-            i++;
-    }
+    ScopedPtrVector<Animation>& animations = m_activeAnimations;
+    animations.erase(cc::remove_if(animations, animations.begin(), animations.end(), HasAnimationIdAndProperty(animationId, targetProperty)), animations.end());
     updateActivation();
 }
 
 // According to render layer backing, these are for testing only.
 void LayerAnimationController::suspendAnimations(double monotonicTime)
 {
     for (size_t i = 0; i < m_activeAnimations.size(); ++i) {
         if (!m_activeAnimations[i]->isFinished())
             m_activeAnimations[i]->setRunState(Animation::Paused, monotonicTime);
     }
@@ skipping 41 matching lines @@
     resolveConflicts(monotonicTime);
     tickAnimations(monotonicTime);
     markAnimationsForDeletion(monotonicTime, events);
     startAnimationsWaitingForTargetAvailability(monotonicTime, events);
 
     updateActivation();
 }
 
 void LayerAnimationController::addAnimation(scoped_ptr<Animation> animation)
 {
-    m_activeAnimations.append(animation.Pass());
+    m_activeAnimations.push_back(animation.Pass());
     updateActivation();
 }
 
 Animation* LayerAnimationController::getAnimation(int groupId, Animation::TargetProperty targetProperty) const
 {
     for (size_t i = 0; i < m_activeAnimations.size(); ++i)
         if (m_activeAnimations[i]->group() == groupId && m_activeAnimations[i]->targetProperty() == targetProperty)
             return m_activeAnimations[i];
     return 0;
 }
@@ skipping 81 matching lines @@
 
         // The new animation should be set to run as soon as possible.
         Animation::RunState initialRunState = Animation::WaitingForTargetAvailability;
         double startTime = 0;
         scoped_ptr<Animation> toAdd(m_activeAnimations[i]->cloneAndInitialize(Animation::ControllingInstance, initialRunState, startTime));
         DCHECK(!toAdd->needsSynchronizedStartTime());
         controllerImpl->addAnimation(toAdd.Pass());
     }
 }
 
+struct IsCompleted {
+    IsCompleted(const LayerAnimationController& mainThreadController) : m_mainThreadController(mainThreadController) { }
+    bool operator()(Animation* animation) const { return !m_mainThreadController.getAnimation(animation->group(), animation->targetProperty()); }
+private:
+    const LayerAnimationController& m_mainThreadController;
+};
+
 void LayerAnimationController::removeAnimationsCompletedOnMainThread(LayerAnimationController* controllerImpl) const
 {
     // Delete all impl thread animations for which there is no corresponding main thread animation.
     // Each iteration, controller->m_activeAnimations.size() is decremented or i is incremented
     // guaranteeing progress towards loop termination.
-    for (size_t i = 0; i < controllerImpl->m_activeAnimations.size();) {
-        Animation* current = getAnimation(controllerImpl->m_activeAnimations[i]->group(), controllerImpl->m_activeAnimations[i]->targetProperty());
-        if (!current)
-            controllerImpl->m_activeAnimations.remove(i);
-        else
-            i++;
-    }
+    ScopedPtrVector<Animation>& animations = controllerImpl->m_activeAnimations;
+    animations.erase(cc::remove_if(animations, animations.begin(), animations.end(), IsCompleted(*this)), animations.end());
 }
 
 void LayerAnimationController::pushPropertiesToImplThread(LayerAnimationController* controllerImpl) const
 {
     for (size_t i = 0; i < m_activeAnimations.size(); ++i) {
         Animation* currentImpl = controllerImpl->getAnimation(m_activeAnimations[i]->group(), m_activeAnimations[i]->targetProperty());
         if (currentImpl)
             m_activeAnimations[i]->pushPropertiesTo(currentImpl);
     }
 }
@@ skipping 113 matching lines @@
                 if (groupId == m_activeAnimations[j]->group()) {
                     if (events)
                         events->push_back(AnimationEvent(AnimationEvent::Finished, m_id, m_activeAnimations[j]->group(), m_activeAnimations[j]->targetProperty(), monotonicTime));
                     m_activeAnimations[j]->setRunState(Animation::WaitingForDeletion, monotonicTime);
                 }
             }
         }
     }
 }
 
+static bool isWaitingForDeletion(Animation* animation) { return animation->runState() == Animation::WaitingForDeletion; }
+
 void LayerAnimationController::purgeAnimationsMarkedForDeletion()
 {
-    for (size_t i = 0; i < m_activeAnimations.size();) {
-        if (m_activeAnimations[i]->runState() == Animation::WaitingForDeletion)
-            m_activeAnimations.remove(i);
-        else
-            i++;
-    }
+    ScopedPtrVector<Animation>& animations = m_activeAnimations;
+    animations.erase(cc::remove_if(animations, animations.begin(), animations.end(), isWaitingForDeletion), animations.end());
 }
 
 void LayerAnimationController::replaceImplThreadAnimations(LayerAnimationController* controllerImpl) const
 {
     controllerImpl->m_activeAnimations.clear();
     for (size_t i = 0; i < m_activeAnimations.size(); ++i) {
         scoped_ptr<Animation> toAdd;
         if (m_activeAnimations[i]->needsSynchronizedStartTime()) {
             // We haven't received an animation started notification yet, so it
             // is important that we add it in a 'waiting' and not 'running' state.
@@ skipping 44 matching lines @@
             case Animation::TargetPropertyEnumSize:
                 NOTREACHED();
             }
         }
     }
 }
 
 void LayerAnimationController::updateActivation(bool force)
 {
     if (m_registrar) {
-        if (!m_activeAnimations.isEmpty() && (!m_isActive || force))
+        if (!m_activeAnimations.empty() && (!m_isActive || force))
             m_registrar->DidActivateAnimationController(this);
-        else if (m_activeAnimations.isEmpty() && (m_isActive || force))
+        else if (m_activeAnimations.empty() && (m_isActive || force))
             m_registrar->DidDeactivateAnimationController(this);
-        m_isActive = !m_activeAnimations.isEmpty();
+        m_isActive = !m_activeAnimations.empty();
     }
 }
 
 void LayerAnimationController::notifyObserversOpacityAnimated(float opacity)
 {
     FOR_EACH_OBSERVER(LayerAnimationValueObserver,
                       m_observers,
                       OnOpacityAnimated(opacity));
 }
 
@@ skipping 10 matching lines @@
         ObserverListBase<LayerAnimationValueObserver>::Iterator it(m_observers);
         LayerAnimationValueObserver* obs;
         while ((obs = it.GetNext()) != NULL)
             if (obs->IsActive())
                 return true;
     }
     return false;
 }
 
 }  // namespace cc