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

cc/animation/keyframed_animation_curve.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 <algorithm>
 
 #include "cc/animation/keyframed_animation_curve.h"
 #include "ui/gfx/animation/tween.h"
 #include "ui/gfx/box_f.h"
 
 namespace cc {
 
 namespace {
 
 template <class Keyframe>
 void InsertKeyframe(scoped_ptr<Keyframe> keyframe,
-                    ScopedPtrVector<Keyframe>& keyframes) {
+                    ScopedPtrVector<Keyframe>* keyframes) {
   // Usually, the keyframes will be added in order, so this loop would be
   // unnecessary and we should skip it if possible.
-  if (!keyframes.empty() && keyframe->Time() < keyframes.back()->Time()) {
-    for (size_t i = 0; i < keyframes.size(); ++i) {
-      if (keyframe->Time() < keyframes[i]->Time()) {
-        keyframes.insert(keyframes.begin() + i, keyframe.Pass());
+  if (!keyframes->empty() && keyframe->Time() < keyframes->back()->Time()) {
+    for (size_t i = 0; i < keyframes->size(); ++i) {
+      if (keyframe->Time() < keyframes->at(i)->Time()) {
+        keyframes->insert(keyframes->begin() + i, keyframe.Pass());
         return;
       }
     }
   }
 
-  keyframes.push_back(keyframe.Pass());
+  keyframes->push_back(keyframe.Pass());
 }
 
 template <class Keyframes>
 float GetProgress(double t, size_t i, const Keyframes& keyframes) {
   float progress =
       static_cast<float>((t - keyframes[i]->Time()) /
                          (keyframes[i + 1]->Time() - keyframes[i]->Time()));
 
   if (keyframes[i]->timing_function())
     progress = keyframes[i]->timing_function()->GetValue(progress);
@@ skipping 122 matching lines @@
     Create() {
   return make_scoped_ptr(new KeyframedColorAnimationCurve);
 }
 
 KeyframedColorAnimationCurve::KeyframedColorAnimationCurve() {}
 
 KeyframedColorAnimationCurve::~KeyframedColorAnimationCurve() {}
 
 void KeyframedColorAnimationCurve::AddKeyframe(
     scoped_ptr<ColorKeyframe> keyframe) {
-  InsertKeyframe(keyframe.Pass(), keyframes_);
+  InsertKeyframe(keyframe.Pass(), &keyframes_);
 }
 
 double KeyframedColorAnimationCurve::Duration() const {
   return keyframes_.back()->Time() - keyframes_.front()->Time();
 }
 
 scoped_ptr<AnimationCurve> KeyframedColorAnimationCurve::Clone() const {
-  scoped_ptr<KeyframedColorAnimationCurve> to_return(
-      KeyframedColorAnimationCurve::Create());
+  scoped_ptr<KeyframedColorAnimationCurve> to_return =
+      KeyframedColorAnimationCurve::Create();
   for (size_t i = 0; i < keyframes_.size(); ++i)
     to_return->AddKeyframe(keyframes_[i]->Clone());
-  return to_return.PassAs<AnimationCurve>();
+  return to_return.Pass();
 }
 
 SkColor KeyframedColorAnimationCurve::GetValue(double t) const {
   if (t <= keyframes_.front()->Time())
     return keyframes_.front()->Value();
 
   if (t >= keyframes_.back()->Time())
     return keyframes_.back()->Value();
 
   size_t i = 0;
@@ skipping 14 matching lines @@
     Create() {
   return make_scoped_ptr(new KeyframedFloatAnimationCurve);
 }
 
 KeyframedFloatAnimationCurve::KeyframedFloatAnimationCurve() {}
 
 KeyframedFloatAnimationCurve::~KeyframedFloatAnimationCurve() {}
 
 void KeyframedFloatAnimationCurve::AddKeyframe(
     scoped_ptr<FloatKeyframe> keyframe) {
-  InsertKeyframe(keyframe.Pass(), keyframes_);
+  InsertKeyframe(keyframe.Pass(), &keyframes_);
 }
 
 double KeyframedFloatAnimationCurve::Duration() const {
   return keyframes_.back()->Time() - keyframes_.front()->Time();
 }
 
 scoped_ptr<AnimationCurve> KeyframedFloatAnimationCurve::Clone() const {
-  scoped_ptr<KeyframedFloatAnimationCurve> to_return(
-      KeyframedFloatAnimationCurve::Create());
+  scoped_ptr<KeyframedFloatAnimationCurve> to_return =
+      KeyframedFloatAnimationCurve::Create();
   for (size_t i = 0; i < keyframes_.size(); ++i)
     to_return->AddKeyframe(keyframes_[i]->Clone());
-  return to_return.PassAs<AnimationCurve>();
+  return to_return.Pass();
 }
 
 float KeyframedFloatAnimationCurve::GetValue(double t) const {
   if (t <= keyframes_.front()->Time())
     return keyframes_.front()->Value();
 
   if (t >= keyframes_.back()->Time())
     return keyframes_.back()->Value();
 
   size_t i = 0;
@@ skipping 12 matching lines @@
     Create() {
   return make_scoped_ptr(new KeyframedTransformAnimationCurve);
 }
 
 KeyframedTransformAnimationCurve::KeyframedTransformAnimationCurve() {}
 
 KeyframedTransformAnimationCurve::~KeyframedTransformAnimationCurve() {}
 
 void KeyframedTransformAnimationCurve::AddKeyframe(
     scoped_ptr<TransformKeyframe> keyframe) {
-  InsertKeyframe(keyframe.Pass(), keyframes_);
+  InsertKeyframe(keyframe.Pass(), &keyframes_);
 }
 
 double KeyframedTransformAnimationCurve::Duration() const {
   return keyframes_.back()->Time() - keyframes_.front()->Time();
 }
 
 scoped_ptr<AnimationCurve> KeyframedTransformAnimationCurve::Clone() const {
-  scoped_ptr<KeyframedTransformAnimationCurve> to_return(

[vmpstr, 2014/09/26 16:44:23]

Are we not allowing this type of constructor either?

[danakj, 2014/09/26 16:56:44]

No, it's fine, I just think following matching () across lines is a bit more
annoying than following a = across a line break. So I instinctively changed it,
heh.

-      KeyframedTransformAnimationCurve::Create());
+  scoped_ptr<KeyframedTransformAnimationCurve> to_return =
+      KeyframedTransformAnimationCurve::Create();
   for (size_t i = 0; i < keyframes_.size(); ++i)
     to_return->AddKeyframe(keyframes_[i]->Clone());
-  return to_return.PassAs<AnimationCurve>();
+  return to_return.Pass();
 }
 
 // Assumes that (*keyframes).front()->Time() < t < (*keyframes).back()-Time().
 template<typename ValueType, typename KeyframeType>
 static ValueType GetCurveValue(const ScopedPtrVector<KeyframeType>* keyframes,
                                double t) {
   size_t i = 0;
   for (; i < keyframes->size() - 1; ++i) {
     if (t < (*keyframes)[i+1]->Time())
       break;
@@ skipping 82 matching lines @@
     Create() {
   return make_scoped_ptr(new KeyframedFilterAnimationCurve);
 }
 
 KeyframedFilterAnimationCurve::KeyframedFilterAnimationCurve() {}
 
 KeyframedFilterAnimationCurve::~KeyframedFilterAnimationCurve() {}
 
 void KeyframedFilterAnimationCurve::AddKeyframe(
     scoped_ptr<FilterKeyframe> keyframe) {
-  InsertKeyframe(keyframe.Pass(), keyframes_);
+  InsertKeyframe(keyframe.Pass(), &keyframes_);
 }
 
 double KeyframedFilterAnimationCurve::Duration() const {
   return keyframes_.back()->Time() - keyframes_.front()->Time();
 }
 
 scoped_ptr<AnimationCurve> KeyframedFilterAnimationCurve::Clone() const {
-  scoped_ptr<KeyframedFilterAnimationCurve> to_return(
-      KeyframedFilterAnimationCurve::Create());
+  scoped_ptr<KeyframedFilterAnimationCurve> to_return =
+      KeyframedFilterAnimationCurve::Create();
   for (size_t i = 0; i < keyframes_.size(); ++i)
     to_return->AddKeyframe(keyframes_[i]->Clone());
-  return to_return.PassAs<AnimationCurve>();
+  return to_return.Pass();
 }
 
 FilterOperations KeyframedFilterAnimationCurve::GetValue(double t) const {
   if (t <= keyframes_.front()->Time())
     return keyframes_.front()->Value();
 
   if (t >= keyframes_.back()->Time())
     return keyframes_.back()->Value();
 
   return GetCurveValue<FilterOperations, FilterKeyframe>(&keyframes_, t);
 }
 
 bool KeyframedFilterAnimationCurve::HasFilterThatMovesPixels() const {
   for (size_t i = 0; i < keyframes_.size(); ++i) {
     if (keyframes_[i]->Value().HasFilterThatMovesPixels()) {
       return true;
     }
   }
   return false;
 }
 
 }  // namespace cc