Revert of cc: Remove use of PassAs() and constructor-casting with scoped_ptr.

cc/test/animation_test_common.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/test/animation_test_common.h"
 
 #include "cc/animation/animation_id_provider.h"
 #include "cc/animation/keyframed_animation_curve.h"
 #include "cc/animation/layer_animation_controller.h"
 #include "cc/animation/transform_operations.h"
@@ skipping 23 matching lines @@
   scoped_ptr<TimingFunction> func;
   if (!use_timing_function)
     func = EaseTimingFunction::Create();
   if (duration > 0.0)
     curve->AddKeyframe(FloatKeyframe::Create(0.0, start_opacity, func.Pass()));
   curve->AddKeyframe(FloatKeyframe::Create(
       duration, end_opacity, scoped_ptr<TimingFunction>()));
 
   int id = AnimationIdProvider::NextAnimationId();
 
-  scoped_ptr<Animation> animation(
-      Animation::Create(curve.Pass(),
-                        id,
-                        AnimationIdProvider::NextGroupId(),
-                        Animation::Opacity));
+  scoped_ptr<Animation> animation(Animation::Create(
+      curve.PassAs<AnimationCurve>(),
+      id,
+      AnimationIdProvider::NextGroupId(),
+      Animation::Opacity));
   animation->set_needs_synchronized_start_time(true);
 
   target->AddAnimation(animation.Pass());
   return id;
 }
 
 template <class Target>
 int AddAnimatedTransform(Target* target,
                          double duration,
                          TransformOperations start_operations,
                          TransformOperations operations) {
   scoped_ptr<KeyframedTransformAnimationCurve>
       curve(KeyframedTransformAnimationCurve::Create());
 
   if (duration > 0.0) {
     curve->AddKeyframe(TransformKeyframe::Create(
         0.0, start_operations, scoped_ptr<TimingFunction>()));
   }
 
   curve->AddKeyframe(TransformKeyframe::Create(
       duration, operations, scoped_ptr<TimingFunction>()));
 
   int id = AnimationIdProvider::NextAnimationId();
 
-  scoped_ptr<Animation> animation(
-      Animation::Create(curve.Pass(),
-                        id,
-                        AnimationIdProvider::NextGroupId(),
-                        Animation::Transform));
+  scoped_ptr<Animation> animation(Animation::Create(
+      curve.PassAs<AnimationCurve>(),
+      id,
+      AnimationIdProvider::NextGroupId(),
+      Animation::Transform));
   animation->set_needs_synchronized_start_time(true);
 
   target->AddAnimation(animation.Pass());
   return id;
 }
 
 template <class Target>
 int AddAnimatedTransform(Target* target,
                          double duration,
                          int delta_x,
@@ skipping 25 matching lines @@
   }
 
   FilterOperations filters;
   filters.Append(FilterOperation::CreateBrightnessFilter(end_brightness));
   curve->AddKeyframe(
       FilterKeyframe::Create(duration, filters, scoped_ptr<TimingFunction>()));
 
   int id = AnimationIdProvider::NextAnimationId();
 
   scoped_ptr<Animation> animation(Animation::Create(
-      curve.Pass(), id, AnimationIdProvider::NextGroupId(), Animation::Filter));
+      curve.PassAs<AnimationCurve>(),
+      id,
+      AnimationIdProvider::NextGroupId(),
+      Animation::Filter));
   animation->set_needs_synchronized_start_time(true);
 
   target->AddAnimation(animation.Pass());
   return id;
 }
 
 FakeFloatAnimationCurve::FakeFloatAnimationCurve()
     : duration_(1.0) {}
 
 FakeFloatAnimationCurve::FakeFloatAnimationCurve(double duration)
     : duration_(duration) {}
 
 FakeFloatAnimationCurve::~FakeFloatAnimationCurve() {}
 
 double FakeFloatAnimationCurve::Duration() const {
   return duration_;
 }
 
 float FakeFloatAnimationCurve::GetValue(double now) const {
   return 0.0f;
 }
 
 scoped_ptr<AnimationCurve> FakeFloatAnimationCurve::Clone() const {
-  return make_scoped_ptr(new FakeFloatAnimationCurve);
+  return make_scoped_ptr(new FakeFloatAnimationCurve).PassAs<AnimationCurve>();
 }
 
 FakeTransformTransition::FakeTransformTransition(double duration)
     : duration_(duration) {}
 
 FakeTransformTransition::~FakeTransformTransition() {}
 
 double FakeTransformTransition::Duration() const {
   return duration_;
 }
@@ skipping 10 matching lines @@
 bool FakeTransformTransition::AffectsScale() const { return false; }
 
 bool FakeTransformTransition::IsTranslation() const { return true; }
 
 bool FakeTransformTransition::MaximumScale(float* max_scale) const {
   *max_scale = 1.f;
   return true;
 }
 
 scoped_ptr<AnimationCurve> FakeTransformTransition::Clone() const {
-  return make_scoped_ptr(new FakeTransformTransition(*this));
+  return make_scoped_ptr(new FakeTransformTransition(*this))
+      .PassAs<AnimationCurve>();
 }
 
 
 FakeFloatTransition::FakeFloatTransition(double duration, float from, float to)
     : duration_(duration), from_(from), to_(to) {}
 
 FakeFloatTransition::~FakeFloatTransition() {}
 
 double FakeFloatTransition::Duration() const {
   return duration_;
@@ skipping 42 matching lines @@
 bool FakeInactiveLayerAnimationValueObserver::IsActive() const {
   return false;
 }
 
 gfx::Vector2dF FakeLayerAnimationValueProvider::ScrollOffsetForAnimation()
     const {
   return scroll_offset_;
 }
 
 scoped_ptr<AnimationCurve> FakeFloatTransition::Clone() const {
-  return make_scoped_ptr(new FakeFloatTransition(*this));
+  return make_scoped_ptr(new FakeFloatTransition(*this))
+      .PassAs<AnimationCurve>();
 }
 
 int AddOpacityTransitionToController(LayerAnimationController* controller,
                                      double duration,
                                      float start_opacity,
                                      float end_opacity,
                                      bool use_timing_function) {
   return AddOpacityTransition(controller,
                               duration,
                               start_opacity,
@@ skipping 88 matching lines @@
                              double duration,
                              float start_brightness,
                              float end_brightness) {
   return AddAnimatedFilter(layer->layer_animation_controller(),
                            duration,
                            start_brightness,
                            end_brightness);
 }
 
 }  // namespace cc