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

cc/trees/layer_tree_host_common_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/trees/layer_tree_host_common.h"
 
 #include <algorithm>
 #include <set>
 #include <vector>
 
@@ skipping 294 matching lines @@
       LayerImpl::Create(host_impl.active_tree(), 4));
   LayerImpl* clip_layer = clip_layer_scoped_ptr.get();
 
   scroll_layer->SetScrollClipLayer(clip_layer->id());
   clip_layer->SetBounds(
       gfx::Size(scroll_layer->bounds().width() + kMaxScrollOffset.x(),
                 scroll_layer->bounds().height() + kMaxScrollOffset.y()));
   scroll_layer->SetScrollClipLayer(clip_layer->id());
   scroll_layer->SetScrollDelta(kScrollDelta);
   gfx::Transform impl_transform;
-  scroll_layer->AddChild(sublayer_scoped_ptr.Pass());
+  scroll_layer->AddChild(std::move(sublayer_scoped_ptr));
   LayerImpl* scroll_layer_raw_ptr = scroll_layer_scoped_ptr.get();
-  clip_layer->AddChild(scroll_layer_scoped_ptr.Pass());
+  clip_layer->AddChild(std::move(scroll_layer_scoped_ptr));
   scroll_layer_raw_ptr->PushScrollOffsetFromMainThread(kScrollOffset);
 
   scoped_ptr<LayerImpl> root(LayerImpl::Create(host_impl.active_tree(), 3));
   SetLayerPropertiesForTesting(root.get(), identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(3, 4), true, false,
                                false);
-  root->AddChild(clip_layer_scoped_ptr.Pass());
+  root->AddChild(std::move(clip_layer_scoped_ptr));
   root->SetHasRenderSurface(true);
 
   ExecuteCalculateDrawProperties(
       root.get(), kDeviceScale, kPageScale, scroll_layer->parent());
   gfx::Transform expected_transform = identity_matrix;
   gfx::PointF sub_layer_screen_position = kScrollLayerPosition - kScrollDelta;
   expected_transform.Translate(MathUtil::Round(sub_layer_screen_position.x() *
                                                kPageScale * kDeviceScale),
                                MathUtil::Round(sub_layer_screen_position.y() *
                                                kPageScale * kDeviceScale));
@@ skipping 293 matching lines @@
                                gfx::Size(10, 12), true, false, false);
   SetLayerPropertiesForTesting(child, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(16, 18), true, false,
                                true);
   SetLayerPropertiesForTesting(grand_child, identity_matrix, gfx::Point3F(),
                                gfx::PointF(-0.5f, -0.5f), gfx::Size(1, 1), true,
                                false, false);
   SetLayerPropertiesForTesting(child_replica.get(), replica_layer_transform,
                                gfx::Point3F(), gfx::PointF(), gfx::Size(), true,
                                false, false);
-  child->SetReplicaLayer(child_replica.Pass());
+  child->SetReplicaLayer(std::move(child_replica));
 
   ExecuteCalculateDrawProperties(root);
 
   // Render surface should have been created now.
   ASSERT_TRUE(child->render_surface());
   ASSERT_EQ(child, child->render_target());
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       replica_composite_transform,
       child->render_target()->render_surface()->replica_draw_transform());
@@ skipping 119 matching lines @@
   SetLayerPropertiesForTesting(grand_child_of_rs2, layer_transform,
                                gfx::Point3F(2.5f, 0.f, 0.f), gfx::PointF(),
                                gfx::Size(10, 10), true, false, false);
   SetLayerPropertiesForTesting(replica_of_rs1.get(), replica_layer_transform,
                                gfx::Point3F(2.5f, 0.f, 0.f), gfx::PointF(),
                                gfx::Size(), true, false, false);
   SetLayerPropertiesForTesting(replica_of_rs2.get(), replica_layer_transform,
                                gfx::Point3F(2.5f, 0.f, 0.f), gfx::PointF(),
                                gfx::Size(), true, false, false);
 
-  render_surface1->SetReplicaLayer(replica_of_rs1.Pass());
-  render_surface2->SetReplicaLayer(replica_of_rs2.Pass());
+  render_surface1->SetReplicaLayer(std::move(replica_of_rs1));
+  render_surface2->SetReplicaLayer(std::move(replica_of_rs2));
   ExecuteCalculateDrawProperties(root);
 
   // Only layers that are associated with render surfaces should have an actual
   // RenderSurface() value.
   ASSERT_TRUE(root->render_surface());
   ASSERT_FALSE(child_of_root->render_surface());
   ASSERT_FALSE(grand_child_of_root->render_surface());
 
   ASSERT_TRUE(render_surface1->render_surface());
   ASSERT_FALSE(child_of_rs1->render_surface());
@@ skipping 1613 matching lines @@
   SetLayerPropertiesForTesting(great_grand_child, identity, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(10, 10), true, false,
                                false);
 
   // Add a transform animation with a start delay to |grand_child|.
   scoped_ptr<Animation> animation = Animation::Create(
       scoped_ptr<AnimationCurve>(new FakeTransformTransition(1.0)).Pass(), 0, 1,
       Animation::TRANSFORM);
   animation->set_fill_mode(Animation::FILL_MODE_NONE);
   animation->set_time_offset(base::TimeDelta::FromMilliseconds(-1000));
-  grand_child->layer_animation_controller()->AddAnimation(animation.Pass());
+  grand_child->layer_animation_controller()->AddAnimation(std::move(animation));
 
   ExecuteCalculateDrawProperties(parent);
 
   EXPECT_FALSE(parent->screen_space_transform_is_animating());
   EXPECT_FALSE(child->screen_space_transform_is_animating());
 
   EXPECT_FALSE(grand_child->TransformIsAnimating());
   EXPECT_TRUE(grand_child->HasPotentiallyRunningTransformAnimation());
   EXPECT_TRUE(grand_child->screen_space_transform_is_animating());
   EXPECT_TRUE(great_grand_child->screen_space_transform_is_animating());
@@ skipping 848 matching lines @@
                                false, true, false);
   SetLayerPropertiesForTesting(grand_child.get(), rotation, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(200, 200), false, true,
                                false);
   SetLayerPropertiesForTesting(occluding_child.get(), identity_matrix,
                                gfx::Point3F(), gfx::PointF(),
                                gfx::Size(200, 200), false, false, false);
 
   host_impl.SetViewportSize(root->bounds());
 
-  child->AddChild(grand_child.Pass());
-  root->AddChild(child.Pass());
-  root->AddChild(occluding_child.Pass());
-  host_impl.active_tree()->SetRootLayer(root.Pass());
+  child->AddChild(std::move(grand_child));
+  root->AddChild(std::move(child));
+  root->AddChild(std::move(occluding_child));
+  host_impl.active_tree()->SetRootLayer(std::move(root));
   host_impl.SetVisible(true);
   host_impl.InitializeRenderer(output_surface.get());
   host_impl.active_tree()->BuildPropertyTreesForTesting();
   bool update_lcd_text = false;
   host_impl.active_tree()->UpdateDrawProperties(update_lcd_text);
 
   LayerImpl* grand_child_ptr =
       host_impl.active_tree()->root_layer()->children()[0]->children()[0].get();
 
   // Though all layers have invertible transforms, matrix multiplication using
@@ skipping 1417 matching lines @@
                                true, true);
 
   gfx::Transform replica_transform;
   replica_transform.Scale(1.0, -1.0);
 
   scoped_ptr<LayerImpl> replica =
       LayerImpl::Create(host_impl()->active_tree(), 7);
   SetLayerPropertiesForTesting(replica.get(), replica_transform, gfx::Point3F(),
                                gfx::PointF(2.f, 2.f), gfx::Size(10, 10), false,
                                true, false);
-  child->SetReplicaLayer(replica.Pass());
+  child->SetReplicaLayer(std::move(replica));
 
   // This layer should end up in the same surface as child, with the same draw
   // and screen space transforms.
   LayerImpl* duplicate_child_non_owner = AddChild<LayerImpl>(child);
   duplicate_child_non_owner->SetDrawsContent(true);
   SetLayerPropertiesForTesting(duplicate_child_non_owner, identity_matrix,
                                gfx::Point3F(), gfx::PointF(), gfx::Size(10, 10),
                                false, true, false);
 
   float device_scale_factor = 1.5f;
@@ skipping 90 matching lines @@
                                gfx::PointF(), gfx::Size(13, 11), false, true,
                                true);
 
   gfx::Transform replica_transform;
   replica_transform.Scale(1.0, -1.0);
   scoped_ptr<LayerImpl> replica =
       LayerImpl::Create(host_impl()->active_tree(), 7);
   SetLayerPropertiesForTesting(replica.get(), replica_transform, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(13, 11), false, true,
                                false);
-  child->SetReplicaLayer(replica.Pass());
+  child->SetReplicaLayer(std::move(replica));
 
   float device_scale_factor = 1.7f;
   ExecuteCalculateDrawProperties(parent, device_scale_factor);
 
   // We should have two render surfaces. The root's render surface and child's
   // render surface (it needs one because it has a replica layer).
   EXPECT_EQ(2u, render_surface_layer_list_impl()->size());
 
   gfx::Transform identity_transform;
   EXPECT_TRANSFORMATION_MATRIX_EQ(identity_transform,
@@ skipping 107 matching lines @@
   SetLayerPropertiesForTesting(child.get(), identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(50, 50), true, false,
                                false);
   child->SetDrawsContent(true);
   child->SetOpacity(0.0f);
 
   // Add opacity animation.
   AddOpacityTransitionToController(
       child->layer_animation_controller(), 10.0, 0.0f, 1.0f, false);
 
-  root->AddChild(child.Pass());
+  root->AddChild(std::move(child));
   root->SetHasRenderSurface(true);
 
   LayerImplList render_surface_layer_list;
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
       root.get(), root->bounds(), &render_surface_layer_list);
   inputs.can_adjust_raster_scales = true;
   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   // We should have one render surface and two layers. The child
   // layer should be included even though it is transparent.
@@ skipping 24 matching lines @@
     scoped_ptr<LayerImpl> child_ptr =
         LayerImpl::Create(host_impl_.active_tree(), 2);
     scoped_ptr<LayerImpl> grand_child_ptr =
         LayerImpl::Create(host_impl_.active_tree(), 3);
 
     // Stash raw pointers to look at later.
     root_ = root_ptr.get();
     child_ = child_ptr.get();
     grand_child_ = grand_child_ptr.get();
 
-    child_->AddChild(grand_child_ptr.Pass());
-    root_->AddChild(child_ptr.Pass());
-    host_impl_.active_tree()->SetRootLayer(root_ptr.Pass());
+    child_->AddChild(std::move(grand_child_ptr));
+    root_->AddChild(std::move(child_ptr));
+    host_impl_.active_tree()->SetRootLayer(std::move(root_ptr));
 
     root_->SetContentsOpaque(true);
     child_->SetContentsOpaque(true);
     grand_child_->SetContentsOpaque(true);
 
     root_->SetDrawsContent(true);
     child_->SetDrawsContent(true);
     grand_child_->SetDrawsContent(true);
 
     gfx::Transform identity_matrix;
@@ skipping 202 matching lines @@
   child->SetDrawsContent(true);
 
   scoped_ptr<LayerImpl> grand_child =
       LayerImpl::Create(host_impl.pending_tree(), 3);
   SetLayerPropertiesForTesting(grand_child.get(), identity_matrix,
                                gfx::Point3F(), gfx::PointF(), gfx::Size(30, 30),
                                true, false, false);
   grand_child->SetDrawsContent(true);
   grand_child->SetHideLayerAndSubtree(true);
 
-  child->AddChild(grand_child.Pass());
-  root->AddChild(child.Pass());
+  child->AddChild(std::move(grand_child));
+  root->AddChild(std::move(child));
   root->SetHasRenderSurface(true);
 
   LayerImplList render_surface_layer_list;
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
       root.get(), root->bounds(), &render_surface_layer_list);
   inputs.can_adjust_raster_scales = true;
   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   // We should have one render surface and two layers. The grand child has
   // hidden itself.
@@ skipping 25 matching lines @@
   child->SetDrawsContent(true);
   child->SetHideLayerAndSubtree(true);
 
   scoped_ptr<LayerImpl> grand_child =
       LayerImpl::Create(host_impl.pending_tree(), 3);
   SetLayerPropertiesForTesting(grand_child.get(), identity_matrix,
                                gfx::Point3F(), gfx::PointF(), gfx::Size(30, 30),
                                true, false, false);
   grand_child->SetDrawsContent(true);
 
-  child->AddChild(grand_child.Pass());
-  root->AddChild(child.Pass());
+  child->AddChild(std::move(grand_child));
+  root->AddChild(std::move(child));
 
   LayerImplList render_surface_layer_list;
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
       root.get(), root->bounds(), &render_surface_layer_list);
   inputs.can_adjust_raster_scales = true;
   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   // We should have one render surface and one layers. The child has
   // hidden itself and the grand child.
   ASSERT_EQ(1u, render_surface_layer_list.size());
@@ skipping 61 matching lines @@
 
   scoped_ptr<LayerImpl> copy_grand_parent_sibling_after =
       LayerImpl::Create(host_impl.pending_tree(), 7);
   SetLayerPropertiesForTesting(copy_grand_parent_sibling_after.get(),
                                identity_matrix, gfx::Point3F(), gfx::PointF(),
                                gfx::Size(40, 40), true, false, false);
   copy_grand_parent_sibling_after->SetDrawsContent(true);
   LayerImpl* copy_grand_parent_sibling_after_layer =
       copy_grand_parent_sibling_after.get();
 
-  copy_request->AddChild(copy_child.Pass());
-  copy_parent->AddChild(copy_request.Pass());
-  copy_grand_parent->AddChild(copy_parent.Pass());
-  root->AddChild(copy_grand_parent_sibling_before.Pass());
-  root->AddChild(copy_grand_parent.Pass());
-  root->AddChild(copy_grand_parent_sibling_after.Pass());
+  copy_request->AddChild(std::move(copy_child));
+  copy_parent->AddChild(std::move(copy_request));
+  copy_grand_parent->AddChild(std::move(copy_parent));
+  root->AddChild(std::move(copy_grand_parent_sibling_before));
+  root->AddChild(std::move(copy_grand_parent));
+  root->AddChild(std::move(copy_grand_parent_sibling_after));
 
   // Hide the copy_grand_parent and its subtree. But make a copy request in that
   // hidden subtree on copy_layer.
   copy_grand_parent_layer->SetHideLayerAndSubtree(true);
   copy_grand_parent_sibling_before_layer->SetHideLayerAndSubtree(true);
   copy_grand_parent_sibling_after_layer->SetHideLayerAndSubtree(true);
 
   std::vector<scoped_ptr<CopyOutputRequest>> copy_requests;
   copy_requests.push_back(
       CopyOutputRequest::CreateRequest(base::Bind(&EmptyCopyOutputCallback)));
@@ skipping 85 matching lines @@
                                gfx::Point3F(), gfx::PointF(), gfx::Size(20, 20),
                                true, false, false);
   copy_child->SetDrawsContent(true);
 
   std::vector<scoped_ptr<CopyOutputRequest>> copy_requests;
   copy_requests.push_back(
       CopyOutputRequest::CreateRequest(base::Bind(&EmptyCopyOutputCallback)));
   copy_layer->PassCopyRequests(&copy_requests);
   EXPECT_TRUE(copy_layer->HasCopyRequest());
 
-  copy_layer->AddChild(copy_child.Pass());
-  copy_parent->AddChild(copy_layer.Pass());
-  root->AddChild(copy_parent.Pass());
+  copy_layer->AddChild(std::move(copy_child));
+  copy_parent->AddChild(std::move(copy_layer));
+  root->AddChild(std::move(copy_parent));
 
   LayerImplList render_surface_layer_list;
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
       root.get(), root->bounds(), &render_surface_layer_list);
   inputs.can_adjust_raster_scales = true;
   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   // We should have two render surface, as the others are clipped out.
   ASSERT_EQ(2u, render_surface_layer_list.size());
   EXPECT_EQ(root->id(), render_surface_layer_list.at(0)->id());
@@ skipping 476 matching lines @@
   scoped_refptr<LayerWithForcedDrawsContent> child_1 =
       make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   Layer* child1 = child_1.get();
   scoped_refptr<LayerWithForcedDrawsContent> child_2 =
       make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   Layer* child2 = child_2.get();
   scoped_refptr<LayerWithForcedDrawsContent> child_3 =
       make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   Layer* child3 = child_3.get();
 
-  parent->AddChild(child_1.Pass());
-  child1->AddChild(child_2.Pass());
-  child2->AddChild(child_3.Pass());
+  parent->AddChild(std::move(child_1));
+  child1->AddChild(std::move(child_2));
+  child2->AddChild(std::move(child_3));
 
   host()->SetRootLayer(root);
 
   const gfx::Transform identity_matrix;
   gfx::Point3F transform_origin;
   gfx::PointF position;
   gfx::Size bounds(100, 100);
 
   SetLayerPropertiesForTesting(root, identity_matrix, transform_origin,
                                position, bounds, true, false);
@@ skipping 47 matching lines @@
   SetLayerPropertiesForTesting(child2.get(), identity_matrix, transform_origin,
                                position, bounds, true, false, true);
   child2->SetDrawsContent(true);
   SetLayerPropertiesForTesting(child3.get(), identity_matrix, transform_origin,
                                position, bounds, true, false, false);
   child3->SetDrawsContent(true);
 
   child2->Set3dSortingContextId(1);
   child3->Set3dSortingContextId(1);
 
-  child2->AddChild(child3.Pass());
-  child1->AddChild(child2.Pass());
-  root->AddChild(child1.Pass());
+  child2->AddChild(std::move(child3));
+  child1->AddChild(std::move(child2));
+  root->AddChild(std::move(child1));
 
   {
     LayerImplList render_surface_layer_list;
     FakeLayerTreeHostImpl::RecursiveUpdateNumChildren(root.get());
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
         root.get(), root->bounds(), &render_surface_layer_list);
     inputs.can_render_to_separate_surface = true;
     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
     EXPECT_EQ(2u, render_surface_layer_list.size());
@@ skipping 589 matching lines @@
                                gfx::Point3F(), gfx::PointF(), gfx::Size(30, 30),
                                true, false, false);
   SetLayerPropertiesForTesting(fixed.get(), identity_transform, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(50, 50), true, false,
                                false);
 
   root->SetDrawsContent(true);
   container->SetDrawsContent(true);
   scroller->SetDrawsContent(true);
   fixed->SetDrawsContent(true);
-  scroller->AddChild(fixed.Pass());
-  container->AddChild(scroller.Pass());
-  root->AddChild(container.Pass());
+  scroller->AddChild(std::move(fixed));
+  container->AddChild(std::move(scroller));
+  root->AddChild(std::move(container));
 
   // Rounded to integers already.
   {
     gfx::Vector2dF scroll_delta(3.0, 5.0);
     scroll_layer->SetScrollDelta(scroll_delta);
 
     LayerImplList render_surface_layer_list;
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
         root.get(), root->bounds(), &render_surface_layer_list);
     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
@@ skipping 118 matching lines @@
   gfx::Vector2dF scroll_delta(0.1f, 0.4f);
   // Blink only uses the integer part of the scroll_offset for fixed
   // position layer.
   SetLayerPropertiesForTesting(fixed.get(), identity_transform, gfx::Point3F(),
                                gfx::PointF(3.0f, 4.0f), gfx::Size(50, 50), true,
                                false, false);
   scroll_layer->PushScrollOffsetFromMainThread(scroll_offset);
   scroll_layer->SetScrollDelta(scroll_delta);
   scroll_layer->SetScrollCompensationAdjustment(main_scroll_fractional_part);
 
-  scroller->AddChild(fixed.Pass());
-  container->AddChild(scroller.Pass());
-  root->AddChild(container.Pass());
+  scroller->AddChild(std::move(fixed));
+  container->AddChild(std::move(scroller));
+  root->AddChild(std::move(container));
 
   LayerImplList render_surface_layer_list;
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
       root.get(), root->bounds(), &render_surface_layer_list);
   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       container_layer->draw_properties().screen_space_transform,
       fixed_layer->draw_properties().screen_space_transform);
   EXPECT_VECTOR_EQ(
@@ skipping 100 matching lines @@
       AnimationScaleFactorTrackingLayerImpl::Create(host_impl.active_tree(), 2);
   scoped_ptr<AnimationScaleFactorTrackingLayerImpl> child =
       AnimationScaleFactorTrackingLayerImpl::Create(host_impl.active_tree(), 3);
   scoped_ptr<AnimationScaleFactorTrackingLayerImpl> grand_child =
       AnimationScaleFactorTrackingLayerImpl::Create(host_impl.active_tree(), 4);
 
   AnimationScaleFactorTrackingLayerImpl* parent_raw = parent.get();
   AnimationScaleFactorTrackingLayerImpl* child_raw = child.get();
   AnimationScaleFactorTrackingLayerImpl* grand_child_raw = grand_child.get();
 
-  child->AddChild(grand_child.Pass());
-  parent->AddChild(child.Pass());
-  grand_parent->AddChild(parent.Pass());
+  child->AddChild(std::move(grand_child));
+  parent->AddChild(std::move(child));
+  grand_parent->AddChild(std::move(parent));
 
   SetLayerPropertiesForTesting(grand_parent.get(), identity_matrix,
                                gfx::Point3F(), gfx::PointF(), gfx::Size(1, 2),
                                true, false, true);
   SetLayerPropertiesForTesting(parent_raw, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(1, 2), true, false,
                                false);
   SetLayerPropertiesForTesting(child_raw, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(1, 2), true, false,
                                false);
@@ skipping 306 matching lines @@
       LayerImpl::Create(host_impl.active_tree(), 7);
   scoped_ptr<LayerImpl> grand_child2 =
       LayerImpl::Create(host_impl.active_tree(), 9);
 
   LayerImpl* grand_parent_raw = grand_parent.get();
   LayerImpl* parent_raw = parent.get();
   LayerImpl* child_raw = child.get();
   LayerImpl* grand_child1_raw = grand_child1.get();
   LayerImpl* grand_child2_raw = grand_child2.get();
 
-  child->AddChild(grand_child1.Pass());
-  child->AddChild(grand_child2.Pass());
-  parent->AddChild(child.Pass());
-  grand_parent->AddChild(parent.Pass());
+  child->AddChild(std::move(grand_child1));
+  child->AddChild(std::move(grand_child2));
+  parent->AddChild(std::move(child));
+  grand_parent->AddChild(std::move(parent));
 
   SetLayerPropertiesForTesting(grand_parent_raw, identity_matrix,
                                gfx::Point3F(), gfx::PointF(), gfx::Size(1, 2),
                                true, false, true);
   SetLayerPropertiesForTesting(parent_raw, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(1, 2), true, false,
                                false);
 
   SetLayerPropertiesForTesting(child_raw, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(1, 2), true, false,
@@ skipping 108 matching lines @@
   expected.insert(child_raw->mask_layer());
 
   actual.clear();
   GatherDrawnLayers(render_surface_layer_list_impl(), &actual);
   EXPECT_EQ(expected, actual);
 
   // Add replica mask layer.
   scoped_ptr<LayerImpl> replica_layer =
       LayerImpl::Create(host_impl.active_tree(), 20);
   replica_layer->SetMaskLayer(LayerImpl::Create(host_impl.active_tree(), 21));
-  child_raw->SetReplicaLayer(replica_layer.Pass());
+  child_raw->SetReplicaLayer(std::move(replica_layer));
   child_raw->layer_tree_impl()->property_trees()->needs_rebuild = true;
 
   ExecuteCalculateDrawProperties(grand_parent_raw);
   member_id = render_surface_layer_list_count();
 
   EXPECT_NE(member_id, membership_id(grand_parent_raw));
   EXPECT_NE(member_id, membership_id(parent_raw));
   EXPECT_NE(member_id, membership_id(child_raw));
   EXPECT_EQ(member_id, membership_id(child_raw->mask_layer()));
   EXPECT_EQ(member_id, membership_id(child_raw->replica_layer()->mask_layer()));
@@ skipping 90 matching lines @@
   FakeLayerTreeHostImpl host_impl(settings, &task_runner_provider,
                                   &shared_bitmap_manager, &task_graph_runner);
 
   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl.active_tree(), 1);
   LayerImpl* root_layer = root.get();
   scoped_ptr<LayerImpl> child1 = LayerImpl::Create(host_impl.active_tree(), 2);
   LayerImpl* child1_layer = child1.get();
   scoped_ptr<LayerImpl> child2 = LayerImpl::Create(host_impl.active_tree(), 3);
   LayerImpl* child2_layer = child2.get();
 
-  root->AddChild(child1.Pass());
-  root->AddChild(child2.Pass());
+  root->AddChild(std::move(child1));
+  root->AddChild(std::move(child2));
   root->SetHasRenderSurface(true);
   root->SetDrawsContent(true);
 
   gfx::Transform identity_matrix, scale_transform_child1,
       scale_transform_child2;
   scale_transform_child1.Scale(2, 3);
   scale_transform_child2.Scale(4, 5);
 
   SetLayerPropertiesForTesting(root_layer, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(1, 1), true, false,
                                true);
   SetLayerPropertiesForTesting(child1_layer, scale_transform_child1,
                                gfx::Point3F(), gfx::PointF(), gfx::Size(1, 1),
                                true, false, false);
 
   child1_layer->SetMaskLayer(
       LayerImpl::Create(host_impl.active_tree(), 4).Pass());
   child1_layer->SetDrawsContent(true);
 
   scoped_ptr<LayerImpl> replica_layer =
       LayerImpl::Create(host_impl.active_tree(), 5);
   replica_layer->SetHasRenderSurface(true);
   replica_layer->SetMaskLayer(LayerImpl::Create(host_impl.active_tree(), 6));
-  child1_layer->SetReplicaLayer(replica_layer.Pass());
+  child1_layer->SetReplicaLayer(std::move(replica_layer));
   child1_layer->SetHasRenderSurface(true);
 
   ExecuteCalculateDrawProperties(root_layer);
 
   TransformOperations scale;
   scale.AppendScale(5.f, 8.f, 3.f);
 
   AddAnimatedTransformToLayer(child2_layer, 1.0, TransformOperations(), scale);
   SetLayerPropertiesForTesting(child2_layer, scale_transform_child2,
                                gfx::Point3F(), gfx::PointF(), gfx::Size(1, 1),
@@ skipping 441 matching lines @@
       KeyframedFilterAnimationCurve::Create());
   FilterOperations start_filters;
   start_filters.Append(FilterOperation::CreateBrightnessFilter(0.1f));
   FilterOperations end_filters;
   end_filters.Append(FilterOperation::CreateBrightnessFilter(0.3f));
   curve->AddKeyframe(
       FilterKeyframe::Create(base::TimeDelta(), start_filters, nullptr));
   curve->AddKeyframe(FilterKeyframe::Create(
       base::TimeDelta::FromMilliseconds(100), end_filters, nullptr));
   scoped_ptr<Animation> animation =
-      Animation::Create(curve.Pass(), 0, 1, Animation::FILTER);
+      Animation::Create(std::move(curve), 0, 1, Animation::FILTER);
   animation->set_fill_mode(Animation::FILL_MODE_NONE);
   animation->set_time_offset(base::TimeDelta::FromMilliseconds(-1000));
-  child->layer_animation_controller()->AddAnimation(animation.Pass());
+  child->layer_animation_controller()->AddAnimation(std::move(animation));
 
   ExecuteCalculateDrawProperties(root.get());
 
   EXPECT_TRUE(root->has_render_surface());
   EXPECT_TRUE(child->has_render_surface());
   EXPECT_FALSE(grandchild->has_render_surface());
 
   EXPECT_TRUE(root->filters().IsEmpty());
   EXPECT_TRUE(child->filters().IsEmpty());
   EXPECT_TRUE(grandchild->filters().IsEmpty());
@@ skipping 420 matching lines @@
   child->SetTransform(zero_z_scale);
 
   // Add a transform animation with a start delay. Now, even though |child| has
   // a singular transform, the subtree should still get processed.
   int animation_id = 0;
   scoped_ptr<Animation> animation = Animation::Create(
       scoped_ptr<AnimationCurve>(new FakeTransformTransition(1.0)).Pass(),
       animation_id, 1, Animation::TRANSFORM);
   animation->set_fill_mode(Animation::FILL_MODE_NONE);
   animation->set_time_offset(base::TimeDelta::FromMilliseconds(-1000));
-  child->AddAnimation(animation.Pass());
+  child->AddAnimation(std::move(animation));
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
   EXPECT_EQ(gfx::Rect(10, 10), grandchild->visible_rect_from_property_trees());
   grandchild->set_visible_rect_from_property_trees(gfx::Rect());
 
   child->RemoveAnimation(animation_id);
   child->SetTransform(identity);
   child->SetOpacity(0.f);
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
   EXPECT_EQ(gfx::Rect(0, 0), grandchild->visible_rect_from_property_trees());
 
   // Now, even though child has zero opacity, we will configure |grandchild| and
   // |greatgrandchild| in several ways that should force the subtree to be
   // processed anyhow.
   greatgrandchild->RequestCopyOfOutput(
       CopyOutputRequest::CreateBitmapRequest(base::Bind(&CopyOutputCallback)));
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
   EXPECT_EQ(gfx::Rect(10, 10), grandchild->visible_rect_from_property_trees());
   grandchild->set_visible_rect_from_property_trees(gfx::Rect());
 
   // Add an opacity animation with a start delay.
   animation_id = 1;
   animation = Animation::Create(
       scoped_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)).Pass(),
       animation_id, 1, Animation::OPACITY);
   animation->set_fill_mode(Animation::FILL_MODE_NONE);
   animation->set_time_offset(base::TimeDelta::FromMilliseconds(-1000));
-  child->AddAnimation(animation.Pass());
+  child->AddAnimation(std::move(animation));
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
   EXPECT_EQ(gfx::Rect(10, 10), grandchild->visible_rect_from_property_trees());
 }
 
 TEST_F(LayerTreeHostCommonTest, SkippingSubtreeImpl) {
   FakeImplTaskRunnerProvider task_runner_provider;
   TestSharedBitmapManager shared_bitmap_manager;
   TestTaskGraphRunner task_graph_runner;
   FakeLayerTreeHostImpl host_impl(&task_runner_provider, &shared_bitmap_manager,
                                   &task_graph_runner);
@@ skipping 21 matching lines @@
                                gfx::PointF(), gfx::Size(10, 10), true, false,
                                false);
   SetLayerPropertiesForTesting(greatgrandchild.get(), identity, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(10, 10), true, false,
                                true);
 
   LayerImpl* child_ptr = child.get();
   LayerImpl* grandchild_ptr = grandchild.get();
   LayerImpl* greatgrandchild_ptr = greatgrandchild.get();
 
-  grandchild->AddChild(greatgrandchild.Pass());
-  child->AddChild(grandchild.Pass());
-  root->AddChild(child.Pass());
+  grandchild->AddChild(std::move(greatgrandchild));
+  child->AddChild(std::move(grandchild));
+  root->AddChild(std::move(child));
 
   // Check the non-skipped case.
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
   EXPECT_EQ(gfx::Rect(10, 10),
             grandchild_ptr->visible_rect_from_property_trees());
 
   // Now we will reset the visible rect from property trees for the grandchild,
   // and we will configure |child| in several ways that should force the subtree
   // to be skipped. The visible content rect for |grandchild| should, therefore,
   // remain empty.
@@ skipping 764 matching lines @@
   bool root_in_rsll =
       std::find(rsll->begin(), rsll->end(), root) != rsll->end();
   EXPECT_TRUE(root_in_rsll);
   bool render_surface2_in_rsll =
       std::find(rsll->begin(), rsll->end(), render_surface2) != rsll->end();
   EXPECT_FALSE(render_surface2_in_rsll);
 }
 
 }  // namespace
 }  // namespace cc