cc: Replace Pass() with std::move() in some subdirs.

cc/layers/layer_unittest.cc

 // Copyright 2011 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/layers/layer.h"
 
 #include "base/thread_task_runner_handle.h"
 #include "cc/animation/keyframed_animation_curve.h"
 #include "cc/base/math_util.h"
 #include "cc/layers/layer_impl.h"
@@ skipping 1135 matching lines @@
   layer_tree_host->SetRootLayer(root);
 }
 
 static bool AddTestAnimation(Layer* layer) {
   scoped_ptr<KeyframedFloatAnimationCurve> curve =
       KeyframedFloatAnimationCurve::Create();
   curve->AddKeyframe(FloatKeyframe::Create(base::TimeDelta(), 0.3f, nullptr));
   curve->AddKeyframe(
       FloatKeyframe::Create(base::TimeDelta::FromSecondsD(1.0), 0.7f, nullptr));
   scoped_ptr<Animation> animation =
-      Animation::Create(curve.Pass(), 0, 0, Animation::OPACITY);
+      Animation::Create(std::move(curve), 0, 0, Animation::OPACITY);
 
-  return layer->AddAnimation(animation.Pass());
+  return layer->AddAnimation(std::move(animation));
 }
 
 TEST_F(LayerLayerTreeHostTest, ShouldNotAddAnimationWithoutAnimationRegistrar) {
   scoped_refptr<Layer> layer = Layer::Create(layer_settings_);
 
   // Case 1: without a LayerTreeHost and without an AnimationRegistrar, the
   // animation should not be accepted.
   EXPECT_FALSE(AddTestAnimation(layer.get()));
 
   scoped_ptr<AnimationRegistrar> registrar = AnimationRegistrar::Create();
@@ skipping 98 matching lines @@
 }
 
 TEST_F(LayerTest, DedupesCopyOutputRequestsBySource) {
   scoped_refptr<Layer> layer = Layer::Create(layer_settings_);
   int result_count = 0;
 
   // Create identical requests without the source being set, and expect the
   // layer does not abort either one.
   scoped_ptr<CopyOutputRequest> request = CopyOutputRequest::CreateRequest(
       base::Bind(&ReceiveCopyOutputResult, &result_count));
-  layer->RequestCopyOfOutput(request.Pass());
+  layer->RequestCopyOfOutput(std::move(request));
   EXPECT_EQ(0, result_count);
   request = CopyOutputRequest::CreateRequest(
       base::Bind(&ReceiveCopyOutputResult, &result_count));
-  layer->RequestCopyOfOutput(request.Pass());
+  layer->RequestCopyOfOutput(std::move(request));
   EXPECT_EQ(0, result_count);
 
   // When the layer is destroyed, expect both requests to be aborted.
   layer = nullptr;
   EXPECT_EQ(2, result_count);
 
   layer = Layer::Create(layer_settings_);
   result_count = 0;
 
   // Create identical requests, but this time the source is being set.  Expect
   // the first request from |this| source aborts immediately when the second
   // request from |this| source is made.
   int did_receive_first_result_from_this_source = 0;
   request = CopyOutputRequest::CreateRequest(base::Bind(
       &ReceiveCopyOutputResult, &did_receive_first_result_from_this_source));
   request->set_source(this);
-  layer->RequestCopyOfOutput(request.Pass());
+  layer->RequestCopyOfOutput(std::move(request));
   EXPECT_EQ(0, did_receive_first_result_from_this_source);
   // Make a request from a different source.
   int did_receive_result_from_different_source = 0;
   request = CopyOutputRequest::CreateRequest(base::Bind(
       &ReceiveCopyOutputResult, &did_receive_result_from_different_source));
   request->set_source(reinterpret_cast<void*>(0xdeadbee0));
-  layer->RequestCopyOfOutput(request.Pass());
+  layer->RequestCopyOfOutput(std::move(request));
   EXPECT_EQ(0, did_receive_result_from_different_source);
   // Make a request without specifying the source.
   int did_receive_result_from_anonymous_source = 0;
   request = CopyOutputRequest::CreateRequest(base::Bind(
       &ReceiveCopyOutputResult, &did_receive_result_from_anonymous_source));
-  layer->RequestCopyOfOutput(request.Pass());
+  layer->RequestCopyOfOutput(std::move(request));
   EXPECT_EQ(0, did_receive_result_from_anonymous_source);
   // Make the second request from |this| source.
   int did_receive_second_result_from_this_source = 0;
   request = CopyOutputRequest::CreateRequest(base::Bind(
       &ReceiveCopyOutputResult, &did_receive_second_result_from_this_source));
   request->set_source(this);
-  layer->RequestCopyOfOutput(request.Pass());  // First request to be aborted.
+  layer->RequestCopyOfOutput(
+      std::move(request));  // First request to be aborted.
   EXPECT_EQ(1, did_receive_first_result_from_this_source);
   EXPECT_EQ(0, did_receive_result_from_different_source);
   EXPECT_EQ(0, did_receive_result_from_anonymous_source);
   EXPECT_EQ(0, did_receive_second_result_from_this_source);
 
   // When the layer is destroyed, the other three requests should be aborted.
   layer = nullptr;
   EXPECT_EQ(1, did_receive_first_result_from_this_source);
   EXPECT_EQ(1, did_receive_result_from_different_source);
   EXPECT_EQ(1, did_receive_result_from_anonymous_source);
@@ skipping 368 matching lines @@
 
   properties.set_needs_push_properties(true);
   properties.mutable_base();
   layer->FromLayerPropertiesProto(properties);
   EXPECT_TRUE(layer->needs_push_properties());
   EXPECT_FALSE(layer->descendant_needs_push_properties());
 }
 
 }  // namespace
 }  // namespace cc