[cc] Use base ptr types for cc's CSS animation classes

cc/CCLayerAnimationController.cpp

 // 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 "config.h"
 
 #include "CCLayerAnimationController.h"
 
 #include "CCActiveAnimation.h"
 #include "CCKeyframedAnimationCurve.h"
 #include <public/WebTransformationMatrix.h>
 #include <wtf/CurrentTime.h>
 #include <wtf/HashMap.h>
 
 using WebKit::WebTransformationMatrix;
 
 namespace cc {
 
 CCLayerAnimationController::CCLayerAnimationController(CCLayerAnimationControllerClient* client)
     : m_forceSync(false)
     , m_client(client)
 {
 }
 
 CCLayerAnimationController::~CCLayerAnimationController()
 {
 }
 
-PassOwnPtr<CCLayerAnimationController> CCLayerAnimationController::create(CCLayerAnimationControllerClient* client)
+scoped_ptr<CCLayerAnimationController> CCLayerAnimationController::create(CCLayerAnimationControllerClient* client)
 {
-    return adoptPtr(new CCLayerAnimationController(client));
+    return make_scoped_ptr(new CCLayerAnimationController(client));
 }
 
 void CCLayerAnimationController::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(CCActiveAnimation::Paused, timeOffset + m_activeAnimations[i]->startTime());
     }
 }
 
@@ skipping 59 matching lines @@
 {
     startAnimationsWaitingForNextTick(monotonicTime, events);
     startAnimationsWaitingForStartTime(monotonicTime, events);
     startAnimationsWaitingForTargetAvailability(monotonicTime, events);
     resolveConflicts(monotonicTime);
     tickAnimations(monotonicTime);
     markAnimationsForDeletion(monotonicTime, events);
     startAnimationsWaitingForTargetAvailability(monotonicTime, events);
 }
 
-void CCLayerAnimationController::addAnimation(PassOwnPtr<CCActiveAnimation> animation)
+void CCLayerAnimationController::addAnimation(scoped_ptr<CCActiveAnimation> animation)
 {
-    m_activeAnimations.append(animation);
+    m_activeAnimations.append(animation.Pass());
 }
 
 CCActiveAnimation* CCLayerAnimationController::getActiveAnimation(int groupId, CCActiveAnimation::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 52 matching lines @@
         // If the animation is not running on the impl thread, it does not necessarily mean that it needs
         // to be copied over and started; it may have already finished. In this case, the impl thread animation
         // will have already notified that it has started and the main thread animation will no longer need
         // a synchronized start time.
         if (!m_activeAnimations[i]->needsSynchronizedStartTime())
             continue;
 
         // The new animation should be set to run as soon as possible.
         CCActiveAnimation::RunState initialRunState = CCActiveAnimation::WaitingForTargetAvailability;
         double startTime = 0;
-        OwnPtr<CCActiveAnimation> toAdd(m_activeAnimations[i]->cloneAndInitialize(CCActiveAnimation::ControllingInstance, initialRunState, startTime));
+        scoped_ptr<CCActiveAnimation> toAdd(m_activeAnimations[i]->cloneAndInitialize(CCActiveAnimation::ControllingInstance, initialRunState, startTime));
         ASSERT(!toAdd->needsSynchronizedStartTime());
-        controllerImpl->addAnimation(toAdd.release());
+        controllerImpl->addAnimation(toAdd.Pass());
     }
 }
 
 void CCLayerAnimationController::removeAnimationsCompletedOnMainThread(CCLayerAnimationController* 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();) {
         CCActiveAnimation* current = getActiveAnimation(controllerImpl->m_activeAnimations[i]->group(), controllerImpl->m_activeAnimations[i]->targetProperty());
@@ skipping 142 matching lines @@
             m_activeAnimations.remove(i);
         else
             i++;
     }
 }
 
 void CCLayerAnimationController::replaceImplThreadAnimations(CCLayerAnimationController* controllerImpl) const
 {
     controllerImpl->m_activeAnimations.clear();
     for (size_t i = 0; i < m_activeAnimations.size(); ++i) {
-        OwnPtr<CCActiveAnimation> toAdd;
+        scoped_ptr<CCActiveAnimation> 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.
             CCActiveAnimation::RunState initialRunState = CCActiveAnimation::WaitingForTargetAvailability;
             double startTime = 0;
-            toAdd = m_activeAnimations[i]->cloneAndInitialize(CCActiveAnimation::ControllingInstance, initialRunState, startTime);
+            toAdd = m_activeAnimations[i]->cloneAndInitialize(CCActiveAnimation::ControllingInstance, initialRunState, startTime).Pass();
         } else
-            toAdd = m_activeAnimations[i]->clone(CCActiveAnimation::ControllingInstance);
+            toAdd = m_activeAnimations[i]->clone(CCActiveAnimation::ControllingInstance).Pass();
 
-        controllerImpl->addAnimation(toAdd.release());
+        controllerImpl->addAnimation(toAdd.Pass());
     }
 }
 
 void CCLayerAnimationController::tickAnimations(double monotonicTime)
 {
     for (size_t i = 0; i < m_activeAnimations.size(); ++i) {
         if (m_activeAnimations[i]->runState() == CCActiveAnimation::Running || m_activeAnimations[i]->runState() == CCActiveAnimation::Paused) {
             double trimmed = m_activeAnimations[i]->trimTimeToCurrentIteration(monotonicTime);
 
             // Animation assumes its initial value until it gets the synchronized start time
@@ skipping 26 matching lines @@
             // Do nothing for sentinel value.
             case CCActiveAnimation::TargetPropertyEnumSize:
                 ASSERT_NOT_REACHED();
 
             }
         }
     }
 }
 
 }  // namespace cc