cc: Convert non-const reference arguments to pointers.

cc/animation/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/animation/layer_animation_controller.h"
 
 #include <algorithm>
 
 #include "cc/animation/animation.h"
 #include "cc/animation/animation_registrar.h"
@@ skipping 36 matching lines @@
   bool operator()(Animation* animation) const {
     return animation->id() == id_;
   }
 
  private:
   int id_;
 };
 
 void LayerAnimationController::RemoveAnimation(int animation_id) {
   ScopedPtrVector<Animation>& animations = active_animations_;
-  animations.erase(cc::remove_if(animations,
+  animations.erase(cc::remove_if(&animations,
                                  animations.begin(),
                                  animations.end(),
                                  HasAnimationId(animation_id)),
                    animations.end());
   UpdateActivation(NormalActivation);
 }
 
 struct HasAnimationIdAndProperty {
   HasAnimationIdAndProperty(int id, Animation::TargetProperty target_property)
       : id_(id), target_property_(target_property) {}
   bool operator()(Animation* animation) const {
     return animation->id() == id_ &&
         animation->target_property() == target_property_;
   }
 
  private:
   int id_;
   Animation::TargetProperty target_property_;
 };
 
 void LayerAnimationController::RemoveAnimation(
     int animation_id,
     Animation::TargetProperty target_property) {
   ScopedPtrVector<Animation>& animations = active_animations_;
-  animations.erase(cc::remove_if(animations,
+  animations.erase(cc::remove_if(&animations,
                                  animations.begin(),
                                  animations.end(),
                                  HasAnimationIdAndProperty(animation_id,
                                                            target_property)),
                    animations.end());
   UpdateActivation(NormalActivation);
 }
 
 // According to render layer backing, these are for testing only.
 void LayerAnimationController::SuspendAnimations(double monotonic_time) {
@@ skipping 225 matching lines @@
 };
 
 void LayerAnimationController::RemoveAnimationsCompletedOnMainThread(
     LayerAnimationController* controller_impl) const {
   // Delete all impl thread animations for which there is no corresponding
   // main thread animation. Each iteration,
   // controller->active_animations_.size() is decremented or i is incremented
   // guaranteeing progress towards loop termination.
   ScopedPtrVector<Animation>& animations =
       controller_impl->active_animations_;
-  animations.erase(cc::remove_if(animations,
+  animations.erase(cc::remove_if(&animations,
                                  animations.begin(),
                                  animations.end(),
                                  IsCompleted(*this)),
                    animations.end());
 }
 
 void LayerAnimationController::PushPropertiesToImplThread(
     LayerAnimationController* controller_impl) const {
   for (size_t i = 0; i < active_animations_.size(); ++i) {
     Animation* current_impl =
@@ skipping 168 matching lines @@
     }
   }
 }
 
 static bool IsWaitingForDeletion(Animation* animation) {
   return animation->run_state() == Animation::WaitingForDeletion;
 }
 
 void LayerAnimationController::PurgeAnimationsMarkedForDeletion() {
   ScopedPtrVector<Animation>& animations = active_animations_;
-  animations.erase(cc::remove_if(animations,
+  animations.erase(cc::remove_if(&animations,
                                  animations.begin(),
                                  animations.end(),
                                  IsWaitingForDeletion),
                    animations.end());
 }
 
 void LayerAnimationController::ReplaceImplThreadAnimations(
     LayerAnimationController* controller_impl) const {
   controller_impl->active_animations_.clear();
   for (size_t i = 0; i < active_animations_.size(); ++i) {
@@ skipping 89 matching lines @@
     ObserverListBase<LayerAnimationValueObserver>::Iterator it(observers_);
     LayerAnimationValueObserver* obs;
     while ((obs = it.GetNext()) != NULL)
       if (obs->IsActive())
         return true;
   }
   return false;
 }
 
 }  // namespace cc