Convert Pass()→std::move() in ui/

ui/compositor/layer_animation_element.cc

 // Copyright (c) 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 "ui/compositor/layer_animation_element.h"
 
+#include <utility>
+
 #include "base/compiler_specific.h"
 #include "cc/animation/animation.h"
 #include "cc/animation/animation_id_provider.h"
 #include "ui/compositor/float_animation_curve_adapter.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/layer_animation_delegate.h"
 #include "ui/compositor/layer_animator.h"
 #include "ui/compositor/scoped_animation_duration_scale_mode.h"
 #include "ui/compositor/transform_animation_curve_adapter.h"
 #include "ui/gfx/animation/tween.h"
@@ skipping 339 matching lines @@
 
   void RequestEffectiveStart(LayerAnimationDelegate* delegate) override {
     DCHECK(animation_group_id());
     if (!IsThreaded()) {
       set_effective_start_time(requested_start_time());
       return;
     }
     set_effective_start_time(base::TimeTicks());
     scoped_ptr<cc::Animation> animation = CreateCCAnimation();
     animation->set_needs_synchronized_start_time(true);
-    delegate->AddThreadedAnimation(animation.Pass());
+    delegate->AddThreadedAnimation(std::move(animation));
   }
 
   virtual void OnEnd(LayerAnimationDelegate* delegate) = 0;
 
   virtual scoped_ptr<cc::Animation> CreateCCAnimation() = 0;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ThreadedLayerAnimationElement);
 };
 
@@ skipping 27 matching lines @@
     delegate->SetOpacityFromAnimation(target_);
   }
 
   scoped_ptr<cc::Animation> CreateCCAnimation() override {
     scoped_ptr<cc::AnimationCurve> animation_curve(
         new FloatAnimationCurveAdapter(tween_type(),
                                        start_,
                                        target_,
                                        duration()));
     scoped_ptr<cc::Animation> animation(
-        cc::Animation::Create(animation_curve.Pass(), animation_id(),
+        cc::Animation::Create(std::move(animation_curve), animation_id(),
                               animation_group_id(), cc::Animation::OPACITY));
-    return animation.Pass();
+    return animation;
   }
 
   void OnGetTarget(TargetValue* target) const override {
     target->opacity = target_;
   }
 
  private:
   float start_;
   const float target_;
 
@@ skipping 30 matching lines @@
     delegate->SetTransformFromAnimation(target_);
   }
 
   scoped_ptr<cc::Animation> CreateCCAnimation() override {
     scoped_ptr<cc::AnimationCurve> animation_curve(
         new TransformAnimationCurveAdapter(tween_type(),
                                            start_,
                                            target_,
                                            duration()));
     scoped_ptr<cc::Animation> animation(
-        cc::Animation::Create(animation_curve.Pass(), animation_id(),
+        cc::Animation::Create(std::move(animation_curve), animation_id(),
                               animation_group_id(), cc::Animation::TRANSFORM));
-    return animation.Pass();
+    return animation;
   }
 
   void OnGetTarget(TargetValue* target) const override {
     target->transform = target_;
   }
 
  private:
   gfx::Transform start_;
   const gfx::Transform target_;
 
@@ skipping 51 matching lines @@
   }
 
   void OnEnd(LayerAnimationDelegate* delegate) override {
     delegate->SetTransformFromAnimation(computed_target_transform_);
   }
 
   scoped_ptr<cc::Animation> CreateCCAnimation() override {
     scoped_ptr<cc::Animation> animation(
         cc::Animation::Create(animation_curve_->Clone(), animation_id(),
                               animation_group_id(), cc::Animation::TRANSFORM));
-    return animation.Pass();
+    return animation;
   }
 
   void OnGetTarget(TargetValue* target) const override {
     target->transform = computed_target_transform_;
   }
 
  private:
   gfx::Transform ComputeCurrentTransform() const {
     gfx::Transform base_current = gfx::Tween::TransformValueBetween(
         gfx::Tween::CalculateValue(tween_type(), last_progressed_fraction()),
@@ skipping 281 matching lines @@
 }
 
 // static
 LayerAnimationElement* LayerAnimationElement::CreateColorElement(
     SkColor color,
     base::TimeDelta duration) {
   return new ColorTransition(color, duration);
 }
 
 }  // namespace ui