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

cc/trees/layer_tree_host_impl_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_impl.h"
 
 #include <algorithm>
 #include <cmath>
 
 #include "base/bind.h"
@@ skipping 148 matching lines @@
   void set_reduce_memory_result(bool reduce_memory_result) {
     reduce_memory_result_ = reduce_memory_result;
   }
 
   virtual bool CreateHostImpl(const LayerTreeSettings& settings,
                               scoped_ptr<OutputSurface> output_surface) {
     host_impl_ = LayerTreeHostImpl::Create(
         settings, this, &task_runner_provider_, &stats_instrumentation_,
         &shared_bitmap_manager_, &gpu_memory_buffer_manager_,
         &task_graph_runner_, 0);
-    output_surface_ = output_surface.Pass();
+    output_surface_ = std::move(output_surface);
     host_impl_->SetVisible(true);
     bool init = host_impl_->InitializeRenderer(output_surface_.get());
     host_impl_->SetViewportSize(gfx::Size(10, 10));
     host_impl_->active_tree()->PushPageScaleFromMainThread(1.f, 1.f, 1.f);
     // Set the BeginFrameArgs so that methods which use it are able to.
     host_impl_->WillBeginImplFrame(CreateBeginFrameArgsForTesting(
         BEGINFRAME_FROM_HERE,
         base::TimeTicks() + base::TimeDelta::FromMilliseconds(1)));
     host_impl_->DidFinishImplFrame();
     return init;
   }
 
   void SetupRootLayerImpl(scoped_ptr<LayerImpl> root) {
     root->SetPosition(gfx::PointF());
     root->SetBounds(gfx::Size(10, 10));
     root->SetDrawsContent(true);
     root->draw_properties().visible_layer_rect = gfx::Rect(0, 0, 10, 10);
     root->SetHasRenderSurface(true);
-    host_impl_->active_tree()->SetRootLayer(root.Pass());
+    host_impl_->active_tree()->SetRootLayer(std::move(root));
   }
 
   static void ExpectClearedScrollDeltasRecursive(LayerImpl* layer) {
     ASSERT_EQ(layer->ScrollDelta(), gfx::Vector2d());
     for (size_t i = 0; i < layer->children().size(); ++i)
       ExpectClearedScrollDeltasRecursive(layer->children()[i].get());
   }
 
   static ::testing::AssertionResult ScrollInfoContains(
       const ScrollAndScaleSet& scroll_info,
@@ skipping 76 matching lines @@
     outer_scroll->PushScrollOffsetFromMainThread(gfx::ScrollOffset());
     outer_scroll->SetBounds(content_size);
     outer_scroll->SetPosition(gfx::PointF());
 
     scoped_ptr<LayerImpl> contents =
         LayerImpl::Create(layer_tree_impl, kContentLayerId);
     contents->SetDrawsContent(true);
     contents->SetBounds(content_size);
     contents->SetPosition(gfx::PointF());
 
-    outer_scroll->AddChild(contents.Pass());
-    outer_clip->AddChild(outer_scroll.Pass());
-    inner_scroll->AddChild(outer_clip.Pass());
-    page_scale->AddChild(inner_scroll.Pass());
-    inner_clip->AddChild(page_scale.Pass());
-    root->AddChild(inner_clip.Pass());
+    outer_scroll->AddChild(std::move(contents));
+    outer_clip->AddChild(std::move(outer_scroll));
+    inner_scroll->AddChild(std::move(outer_clip));
+    page_scale->AddChild(std::move(inner_scroll));
+    inner_clip->AddChild(std::move(page_scale));
+    root->AddChild(std::move(inner_clip));
 
-    layer_tree_impl->SetRootLayer(root.Pass());
+    layer_tree_impl->SetRootLayer(std::move(root));
     layer_tree_impl->SetViewportLayersFromIds(
         Layer::INVALID_ID, kPageScaleLayerId, kInnerViewportScrollLayerId,
         kOuterViewportScrollLayerId);
 
     layer_tree_impl->DidBecomeActive();
     return layer_tree_impl->InnerViewportScrollLayer();
   }
 
   LayerImpl* SetupScrollAndContentsLayers(const gfx::Size& content_size) {
     LayerImpl* scroll_layer = CreateScrollAndContentsLayers(
@@ skipping 35 matching lines @@
                                               const gfx::Size& size,
                                               LayerImpl* clip_layer) {
     DCHECK(clip_layer);
     DCHECK(id != clip_layer->id());
     scoped_ptr<LayerImpl> layer =
         LayerImpl::Create(host_impl_->active_tree(), id);
     layer->SetScrollClipLayer(clip_layer->id());
     layer->SetDrawsContent(true);
     layer->SetBounds(size);
     clip_layer->SetBounds(gfx::Size(size.width() / 2, size.height() / 2));
-    return layer.Pass();
+    return layer;
   }
 
   void DrawFrame() {
     LayerTreeHostImpl::FrameData frame;
     EXPECT_EQ(DRAW_SUCCESS, PrepareToDrawFrame(&frame));
     host_impl_->DrawLayers(&frame);
     host_impl_->DidDrawAllLayers(frame);
   }
 
   void RebuildPropertyTrees() {
@@ skipping 131 matching lines @@
     scoped_ptr<LayerImpl> root =
         LayerImpl::Create(host_impl_->active_tree(), 1);
     root->AddChild(LayerImpl::Create(host_impl_->active_tree(), 2));
     root->AddChild(LayerImpl::Create(host_impl_->active_tree(), 3));
     root->children()[1]->AddChild(
         LayerImpl::Create(host_impl_->active_tree(), 4));
     root->children()[1]->AddChild(
         LayerImpl::Create(host_impl_->active_tree(), 5));
     root->children()[1]->children()[0]->AddChild(
         LayerImpl::Create(host_impl_->active_tree(), 6));
-    host_impl_->active_tree()->SetRootLayer(root.Pass());
+    host_impl_->active_tree()->SetRootLayer(std::move(root));
   }
   LayerImpl* root = host_impl_->active_tree()->root_layer();
 
   ExpectClearedScrollDeltasRecursive(root);
 
   scoped_ptr<ScrollAndScaleSet> scroll_info;
 
   scroll_info = host_impl_->ProcessScrollDeltas();
   ASSERT_EQ(scroll_info->scrolls.size(), 0u);
   ExpectClearedScrollDeltasRecursive(root);
 
   scroll_info = host_impl_->ProcessScrollDeltas();
   ASSERT_EQ(scroll_info->scrolls.size(), 0u);
   ExpectClearedScrollDeltasRecursive(root);
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollDeltaRepeatedScrolls) {
   gfx::ScrollOffset scroll_offset(20, 30);
   gfx::Vector2d scroll_delta(11, -15);
   {
     scoped_ptr<LayerImpl> root_clip =
         LayerImpl::Create(host_impl_->active_tree(), 2);
     scoped_ptr<LayerImpl> root =
         LayerImpl::Create(host_impl_->active_tree(), 1);
     root_clip->SetBounds(gfx::Size(10, 10));
     LayerImpl* root_layer = root.get();
-    root_clip->AddChild(root.Pass());
+    root_clip->AddChild(std::move(root));
     root_layer->SetBounds(gfx::Size(110, 110));
     root_layer->SetScrollClipLayer(root_clip->id());
     root_layer->PushScrollOffsetFromMainThread(scroll_offset);
     root_layer->ScrollBy(scroll_delta);
-    host_impl_->active_tree()->SetRootLayer(root_clip.Pass());
+    host_impl_->active_tree()->SetRootLayer(std::move(root_clip));
   }
   LayerImpl* root =
       host_impl_->active_tree()->root_layer()->children()[0].get();
 
   scoped_ptr<ScrollAndScaleSet> scroll_info;
 
   scroll_info = host_impl_->ProcessScrollDeltas();
   ASSERT_EQ(scroll_info->scrolls.size(), 1u);
   EXPECT_TRUE(ScrollInfoContains(*scroll_info, root->id(), scroll_delta));
 
@@ skipping 48 matching lines @@
   EXPECT_EQ(InputHandler::SCROLL_IGNORED,
             host_impl_->ScrollBegin(gfx::Point(), InputHandler::WHEEL));
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollWithoutRenderer) {
   scoped_ptr<TestWebGraphicsContext3D> context_owned =
       TestWebGraphicsContext3D::Create();
   context_owned->set_context_lost(true);
 
   // Initialization will fail.
-  EXPECT_FALSE(CreateHostImpl(
-      DefaultSettings(), FakeOutputSurface::Create3d(context_owned.Pass())));
+  EXPECT_FALSE(
+      CreateHostImpl(DefaultSettings(),
+                     FakeOutputSurface::Create3d(std::move(context_owned))));
 
   SetupScrollAndContentsLayers(gfx::Size(100, 100));
 
   // We should not crash when trying to scroll after the renderer initialization
   // fails.
   EXPECT_EQ(InputHandler::SCROLL_STARTED,
             host_impl_->ScrollBegin(gfx::Point(), InputHandler::WHEEL));
 }
 
 TEST_F(LayerTreeHostImplTest, ReplaceTreeWhileScrolling) {
@@ skipping 57 matching lines @@
   LayerImpl* root = host_impl_->active_tree()->root_layer();
 
   LayerImpl* child = 0;
   {
     scoped_ptr<LayerImpl> child_layer =
         LayerImpl::Create(host_impl_->active_tree(), 6);
     child = child_layer.get();
     child_layer->SetDrawsContent(true);
     child_layer->SetPosition(gfx::PointF(0, 20));
     child_layer->SetBounds(gfx::Size(50, 50));
-    scroll->AddChild(child_layer.Pass());
+    scroll->AddChild(std::move(child_layer));
     RebuildPropertyTrees();
   }
 
   // Touch handler regions determine whether touch events block scroll.
   root->SetTouchEventHandlerRegion(gfx::Rect(0, 0, 100, 100));
   EXPECT_FALSE(host_impl_->DoTouchEventsBlockScrollAt(gfx::Point(10, 10)));
   root->SetScrollBlocksOn(SCROLL_BLOCKS_ON_START_TOUCH |
                           SCROLL_BLOCKS_ON_WHEEL_EVENT);
   EXPECT_TRUE(host_impl_->DoTouchEventsBlockScrollAt(gfx::Point(10, 10)));
 
@@ skipping 61 matching lines @@
   LayerImpl* child1 = 0;
   {
     scoped_ptr<LayerImpl> scrollable_child_clip_1 =
         LayerImpl::Create(host_impl_->active_tree(), 6);
     scoped_ptr<LayerImpl> scrollable_child_1 = CreateScrollableLayer(
         7, gfx::Size(10, 10), scrollable_child_clip_1.get());
     child1 = scrollable_child_1.get();
     scrollable_child_1->SetPosition(gfx::PointF(5.f, 5.f));
     scrollable_child_1->SetHaveWheelEventHandlers(true);
     scrollable_child_1->SetHaveScrollEventHandlers(true);
-    scrollable_child_clip_1->AddChild(scrollable_child_1.Pass());
-    root_child->AddChild(scrollable_child_clip_1.Pass());
+    scrollable_child_clip_1->AddChild(std::move(scrollable_child_1));
+    root_child->AddChild(std::move(scrollable_child_clip_1));
     RebuildPropertyTrees();
   }
 
   LayerImpl* child2 = 0;
   {
     scoped_ptr<LayerImpl> scrollable_child_clip_2 =
         LayerImpl::Create(host_impl_->active_tree(), 8);
     scoped_ptr<LayerImpl> scrollable_child_2 = CreateScrollableLayer(
         9, gfx::Size(10, 10), scrollable_child_clip_2.get());
     child2 = scrollable_child_2.get();
     scrollable_child_2->SetPosition(gfx::PointF(5.f, 20.f));
     scrollable_child_2->SetHaveWheelEventHandlers(true);
     scrollable_child_2->SetHaveScrollEventHandlers(true);
-    scrollable_child_clip_2->AddChild(scrollable_child_2.Pass());
-    root_child->AddChild(scrollable_child_clip_2.Pass());
+    scrollable_child_clip_2->AddChild(std::move(scrollable_child_2));
+    root_child->AddChild(std::move(scrollable_child_clip_2));
     RebuildPropertyTrees();
   }
 
   // Scroll-blocks-on on a layer affects scrolls that hit that layer.
   EXPECT_EQ(InputHandler::SCROLL_STARTED,
             host_impl_->ScrollBegin(gfx::Point(10, 10), InputHandler::GESTURE));
   host_impl_->ScrollEnd();
   child1->SetScrollBlocksOn(SCROLL_BLOCKS_ON_SCROLL_EVENT);
   EXPECT_EQ(InputHandler::SCROLL_ON_MAIN_THREAD,
             host_impl_->ScrollBegin(gfx::Point(10, 10), InputHandler::GESTURE));
@@ skipping 775 matching lines @@
   ui::LatencyInfo latency_info;
   latency_info.AddLatencyNumber(ui::INPUT_EVENT_LATENCY_BEGIN_RWH_COMPONENT, 0,
                                 1234);
   scoped_ptr<SwapPromise> swap_promise(
       new LatencyInfoSwapPromise(latency_info));
 
   SetupScrollAndContentsLayers(gfx::Size(100, 100));
   EXPECT_EQ(InputHandler::SCROLL_STARTED,
             host_impl_->ScrollBegin(gfx::Point(), InputHandler::GESTURE));
   host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, 10));
-  host_impl_->QueueSwapPromiseForMainThreadScrollUpdate(swap_promise.Pass());
+  host_impl_->QueueSwapPromiseForMainThreadScrollUpdate(
+      std::move(swap_promise));
   host_impl_->ScrollEnd();
 
   scoped_ptr<ScrollAndScaleSet> scroll_info = host_impl_->ProcessScrollDeltas();
   EXPECT_EQ(1u, scroll_info->swap_promises.size());
   EXPECT_EQ(latency_info.trace_id(), scroll_info->swap_promises[0]->TraceId());
 }
 
 // Test that scrolls targeting a layer with a non-null scroll_parent() don't
 // bubble up.
 TEST_F(LayerTreeHostImplTest, ScrollDoesntBubble) {
   LayerImpl* viewport_scroll =
       SetupScrollAndContentsLayers(gfx::Size(100, 100));
   host_impl_->SetViewportSize(gfx::Size(50, 50));
 
   // Set up two scrolling children of the root, one of which is a scroll parent
   // to the other. Scrolls shouldn't bubbling from the child.
   LayerImpl *parent;
   LayerImpl *child;
   LayerImpl *child_clip;
 
   scoped_ptr<LayerImpl> scroll_parent_clip =
       LayerImpl::Create(host_impl_->active_tree(), 6);
   scoped_ptr<LayerImpl> scroll_parent = CreateScrollableLayer(
       7, gfx::Size(10, 10), scroll_parent_clip.get());
   parent = scroll_parent.get();
-  scroll_parent_clip->AddChild(scroll_parent.Pass());
+  scroll_parent_clip->AddChild(std::move(scroll_parent));
 
-  viewport_scroll->AddChild(scroll_parent_clip.Pass());
+  viewport_scroll->AddChild(std::move(scroll_parent_clip));
 
   scoped_ptr<LayerImpl> scroll_child_clip =
       LayerImpl::Create(host_impl_->active_tree(), 8);
   scoped_ptr<LayerImpl> scroll_child = CreateScrollableLayer(
       9, gfx::Size(10, 10), scroll_child_clip.get());
   child = scroll_child.get();
   scroll_child->SetPosition(gfx::PointF(20.f, 20.f));
-  scroll_child_clip->AddChild(scroll_child.Pass());
+  scroll_child_clip->AddChild(std::move(scroll_child));
 
   child_clip = scroll_child_clip.get();
-  viewport_scroll->AddChild(scroll_child_clip.Pass());
+  viewport_scroll->AddChild(std::move(scroll_child_clip));
 
   child_clip->SetScrollParent(parent);
   scoped_ptr<std::set<LayerImpl*>> scroll_children(new std::set<LayerImpl*>);
   scroll_children->insert(child_clip);
   parent->SetScrollChildren(scroll_children.release());
 
   DrawFrame();
 
   {
     host_impl_->ScrollBegin(gfx::Point(21, 21), InputHandler::GESTURE);
@@ skipping 581 matching lines @@
         gfx::Size(content_size.width() / 2, content_size.height() / 2));
 
     scoped_ptr<SolidColorScrollbarLayerImpl> scrollbar =
         SolidColorScrollbarLayerImpl::Create(host_impl_->active_tree(), 400,
                                              VERTICAL, 10, 0, false, true);
     EXPECT_FLOAT_EQ(0.f, scrollbar->opacity());
 
     LayerImpl* scroll = host_impl_->active_tree()->OuterViewportScrollLayer();
     LayerImpl* root = host_impl_->active_tree()->InnerViewportContainerLayer();
     scrollbar->SetScrollLayerId(scroll->id());
-    root->AddChild(scrollbar.Pass());
+    root->AddChild(std::move(scrollbar));
 
     host_impl_->active_tree()->DidBecomeActive();
     DrawFrame();
   }
 
   void RunTest(LayerTreeSettings::ScrollbarAnimator animator) {
     LayerTreeSettings settings;
     settings.scrollbar_animator = animator;
     settings.scrollbar_fade_delay_ms = 20;
     settings.scrollbar_fade_duration_ms = 20;
@@ skipping 115 matching lines @@
 
     CreateHostImpl(settings, CreateOutputSurface());
     host_impl_->CreatePendingTree();
     CreateScrollAndContentsLayers(host_impl_->pending_tree(), content_size);
     scoped_ptr<SolidColorScrollbarLayerImpl> scrollbar =
         SolidColorScrollbarLayerImpl::Create(host_impl_->pending_tree(), 400,
                                              VERTICAL, 10, 0, false, true);
     LayerImpl* scroll = host_impl_->pending_tree()->OuterViewportScrollLayer();
     LayerImpl* root = host_impl_->pending_tree()->InnerViewportContainerLayer();
     scrollbar->SetScrollLayerId(scroll->id());
-    root->AddChild(scrollbar.Pass());
+    root->AddChild(std::move(scrollbar));
     host_impl_->pending_tree()->PushPageScaleFromMainThread(1.f, 1.f, 1.f);
     host_impl_->pending_tree()->BuildPropertyTreesForTesting();
     host_impl_->ActivateSyncTree();
 
     LayerImpl* scrollbar_layer = host_impl_->active_tree()->LayerById(400);
 
     EffectNode* active_tree_node =
         host_impl_->active_tree()->property_trees()->effect_tree.Node(
             scrollbar_layer->effect_tree_index());
     EXPECT_FLOAT_EQ(scrollbar_layer->opacity(), active_tree_node->data.opacity);
@@ skipping 126 matching lines @@
       gfx::ScrollOffset(10, 10));
   EXPECT_FALSE(animation_task_.Equals(base::Closure()));
   animation_task_ = base::Closure();
   host_impl_->active_tree()->InnerViewportScrollLayer()->SetCurrentScrollOffset(
       gfx::ScrollOffset(10, 10));
   EXPECT_FALSE(animation_task_.Equals(base::Closure()));
   animation_task_ = base::Closure();
 
   // Check scrollbar registration on a sublayer.
   child->SetScrollClipLayer(child_clip->id());
-  child_clip->AddChild(child.Pass());
-  root_scroll->AddChild(child_clip.Pass());
+  child_clip->AddChild(std::move(child));
+  root_scroll->AddChild(std::move(child_clip));
   EXPECT_EQ(0ul, host_impl_->ScrollbarsFor(child_scroll_id).size());
   EXPECT_EQ(nullptr,
             host_impl_->ScrollbarAnimationControllerForId(child_scroll_id));
   vert_2_scrollbar->SetScrollLayerId(child_scroll_id);
   EXPECT_EQ(1ul, host_impl_->ScrollbarsFor(child_scroll_id).size());
   EXPECT_TRUE(host_impl_->ScrollbarAnimationControllerForId(child_scroll_id));
   horiz_2_scrollbar->SetScrollLayerId(child_scroll_id);
   EXPECT_EQ(2ul, host_impl_->ScrollbarsFor(child_scroll_id).size());
   EXPECT_TRUE(host_impl_->ScrollbarAnimationControllerForId(child_scroll_id));
 
@@ skipping 57 matching lines @@
       host_impl_->active_tree()->OuterViewportScrollLayer();
   // The scrollbar is on the left side.
   scoped_ptr<SolidColorScrollbarLayerImpl> scrollbar =
       SolidColorScrollbarLayerImpl::Create(host_impl_->active_tree(), 6,
                                            VERTICAL, 5, 5, true, true);
   scrollbar->SetScrollLayerId(root_scroll->id());
   scrollbar->SetDrawsContent(true);
   scrollbar->SetBounds(scrollbar_size);
   scrollbar->SetTouchEventHandlerRegion(gfx::Rect(scrollbar_size));
   host_impl_->active_tree()->InnerViewportContainerLayer()->AddChild(
-      scrollbar.Pass());
+      std::move(scrollbar));
   host_impl_->active_tree()->DidBecomeActive();
 
   DrawFrame();
   host_impl_->active_tree()->UpdateDrawProperties(false);
 
   ScrollbarAnimationControllerThinning* scrollbar_animation_controller =
       static_cast<ScrollbarAnimationControllerThinning*>(
           host_impl_->ScrollbarAnimationControllerForId(root_scroll->id()));
   scrollbar_animation_controller->set_mouse_move_distance_for_test(100.f);
 
@@ skipping 662 matching lines @@
     host_impl_->DrawLayers(&frame);
     host_impl_->DidDrawAllLayers(frame);
     host_impl_->SwapBuffers(frame);
   }
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollRootIgnored) {
   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl_->active_tree(), 1);
   root->SetScrollClipLayer(Layer::INVALID_ID);
   root->SetHasRenderSurface(true);
-  host_impl_->active_tree()->SetRootLayer(root.Pass());
+  host_impl_->active_tree()->SetRootLayer(std::move(root));
   DrawFrame();
 
   // Scroll event is ignored because layer is not scrollable.
   EXPECT_EQ(InputHandler::SCROLL_IGNORED,
             host_impl_->ScrollBegin(gfx::Point(), InputHandler::WHEEL));
   EXPECT_FALSE(did_request_redraw_);
   EXPECT_FALSE(did_request_commit_);
 }
 
 TEST_F(LayerTreeHostImplTest, ClampingAfterActivation) {
@@ skipping 23 matching lines @@
       // non-scrollable.
       : layer_size_(10, 10),
         clip_size_(layer_size_),
         top_controls_height_(50) {
     viewport_size_ = gfx::Size(clip_size_.width(),
                                clip_size_.height() + top_controls_height_);
   }
 
   bool CreateHostImpl(const LayerTreeSettings& settings,
                       scoped_ptr<OutputSurface> output_surface) override {
-    bool init =
-        LayerTreeHostImplTest::CreateHostImpl(settings, output_surface.Pass());
+    bool init = LayerTreeHostImplTest::CreateHostImpl(
+        settings, std::move(output_surface));
     if (init) {
       host_impl_->active_tree()->set_top_controls_height(top_controls_height_);
       host_impl_->active_tree()->SetCurrentTopControlsShownRatio(1.f);
       host_impl_->active_tree()->PushPageScaleFromMainThread(1.f, 1.f, 1.f);
     }
     return init;
   }
 
   void SetupTopControlsAndScrollLayerWithVirtualViewport(
       const gfx::Size& inner_viewport_size,
@@ skipping 27 matching lines @@
     outer_scroll->SetScrollClipLayer(outer_clip->id());
     outer_scroll->SetBounds(scroll_layer_size);
     outer_scroll->SetPosition(gfx::PointF());
     outer_scroll->SetDrawsContent(false);
     outer_scroll->SetIsContainerForFixedPositionLayers(true);
 
     int inner_viewport_scroll_layer_id = root->id();
     int outer_viewport_scroll_layer_id = outer_scroll->id();
     int page_scale_layer_id = page_scale->id();
 
-    outer_clip->AddChild(outer_scroll.Pass());
-    root->AddChild(outer_clip.Pass());
-    page_scale->AddChild(root.Pass());
-    root_clip->AddChild(page_scale.Pass());
+    outer_clip->AddChild(std::move(outer_scroll));
+    root->AddChild(std::move(outer_clip));
+    page_scale->AddChild(std::move(root));
+    root_clip->AddChild(std::move(page_scale));
 
-    host_impl_->active_tree()->SetRootLayer(root_clip.Pass());
+    host_impl_->active_tree()->SetRootLayer(std::move(root_clip));
     host_impl_->active_tree()->SetViewportLayersFromIds(
         Layer::INVALID_ID, page_scale_layer_id, inner_viewport_scroll_layer_id,
         outer_viewport_scroll_layer_id);
 
     host_impl_->SetViewportSize(inner_viewport_size);
     LayerImpl* root_clip_ptr = host_impl_->active_tree()->root_layer();
     EXPECT_EQ(inner_viewport_size, root_clip_ptr->bounds());
   }
 
  protected:
@@ skipping 265 matching lines @@
 
   child_clip->SetBounds(sub_content_layer_size);
   child->SetScrollClipLayer(child_clip->id());
   child->SetBounds(sub_content_size);
   child->SetPosition(gfx::PointF());
   child->SetDrawsContent(true);
   child->SetIsContainerForFixedPositionLayers(true);
 
   // scroll child to limit
   child->SetScrollDelta(gfx::Vector2dF(0, 100.f));
-  child_clip->AddChild(child.Pass());
-  outer_viewport_scroll_layer->AddChild(child_clip.Pass());
+  child_clip->AddChild(std::move(child));
+  outer_viewport_scroll_layer->AddChild(std::move(child_clip));
 
   // Scroll 25px to hide top controls
   gfx::Vector2dF scroll_delta(0.f, 25.f);
   host_impl_->active_tree()->property_trees()->needs_rebuild = true;
   host_impl_->active_tree()->BuildPropertyTreesForTesting();
   EXPECT_EQ(InputHandler::SCROLL_STARTED,
             host_impl_->ScrollBegin(gfx::Point(), InputHandler::GESTURE));
   host_impl_->ScrollBy(gfx::Point(), scroll_delta);
   host_impl_->ScrollEnd();
 
@@ skipping 352 matching lines @@
 
   scoped_ptr<LayerImpl> scroll_clip_layer =
       LayerImpl::Create(host_impl_->active_tree(), 3);
   scroll_clip_layer->SetBounds(surface_size);
 
   scoped_ptr<LayerImpl> scroll_layer =
       LayerImpl::Create(host_impl_->active_tree(), 2);
   scroll_layer->SetScrollClipLayer(3);
   scroll_layer->SetBounds(contents_size);
   scroll_layer->SetPosition(gfx::PointF());
-  scroll_layer->AddChild(content_layer.Pass());
-  scroll_clip_layer->AddChild(scroll_layer.Pass());
+  scroll_layer->AddChild(std::move(content_layer));
+  scroll_clip_layer->AddChild(std::move(scroll_layer));
 
   scroll_clip_layer->SetHasRenderSurface(true);
-  host_impl_->active_tree()->SetRootLayer(scroll_clip_layer.Pass());
+  host_impl_->active_tree()->SetRootLayer(std::move(scroll_clip_layer));
   host_impl_->SetViewportSize(surface_size);
   DrawFrame();
 
   EXPECT_EQ(InputHandler::SCROLL_STARTED,
             host_impl_->ScrollBegin(gfx::Point(5, 5), InputHandler::WHEEL));
   host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, 10));
   host_impl_->ScrollEnd();
   EXPECT_TRUE(did_request_redraw_);
   EXPECT_TRUE(did_request_commit_);
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollChildCallsCommitAndRedraw) {
   gfx::Size surface_size(10, 10);
   gfx::Size contents_size(20, 20);
   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl_->active_tree(), 1);
   root->SetBounds(surface_size);
   root->AddChild(CreateScrollableLayer(2, contents_size, root.get()));
   root->SetHasRenderSurface(true);
-  host_impl_->active_tree()->SetRootLayer(root.Pass());
+  host_impl_->active_tree()->SetRootLayer(std::move(root));
   host_impl_->SetViewportSize(surface_size);
   DrawFrame();
 
   EXPECT_EQ(InputHandler::SCROLL_STARTED,
             host_impl_->ScrollBegin(gfx::Point(5, 5), InputHandler::WHEEL));
   host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, 10));
   host_impl_->ScrollEnd();
   EXPECT_TRUE(did_request_redraw_);
   EXPECT_TRUE(did_request_commit_);
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollMissesChild) {
   gfx::Size surface_size(10, 10);
   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl_->active_tree(), 1);
   root->AddChild(CreateScrollableLayer(2, surface_size, root.get()));
   root->SetHasRenderSurface(true);
-  host_impl_->active_tree()->SetRootLayer(root.Pass());
+  host_impl_->active_tree()->SetRootLayer(std::move(root));
   host_impl_->SetViewportSize(surface_size);
   DrawFrame();
 
   // Scroll event is ignored because the input coordinate is outside the layer
   // boundaries.
   EXPECT_EQ(InputHandler::SCROLL_IGNORED,
             host_impl_->ScrollBegin(gfx::Point(15, 5), InputHandler::WHEEL));
   EXPECT_FALSE(did_request_redraw_);
   EXPECT_FALSE(did_request_commit_);
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollMissesBackfacingChild) {
   gfx::Size surface_size(10, 10);
   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl_->active_tree(), 1);
   root->SetHasRenderSurface(true);
   scoped_ptr<LayerImpl> child =
       CreateScrollableLayer(2, surface_size, root.get());
   host_impl_->SetViewportSize(surface_size);
 
   gfx::Transform matrix;
   matrix.RotateAboutXAxis(180.0);
   child->SetTransform(matrix);
   child->SetDoubleSided(false);
 
-  root->AddChild(child.Pass());
-  host_impl_->active_tree()->SetRootLayer(root.Pass());
+  root->AddChild(std::move(child));
+  host_impl_->active_tree()->SetRootLayer(std::move(root));
   DrawFrame();
 
   // Scroll event is ignored because the scrollable layer is not facing the
   // viewer and there is nothing scrollable behind it.
   EXPECT_EQ(InputHandler::SCROLL_IGNORED,
             host_impl_->ScrollBegin(gfx::Point(5, 5), InputHandler::WHEEL));
   EXPECT_FALSE(did_request_redraw_);
   EXPECT_FALSE(did_request_commit_);
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollBlockedByContentLayer) {
   gfx::Size surface_size(10, 10);
   scoped_ptr<LayerImpl> clip_layer =
       LayerImpl::Create(host_impl_->active_tree(), 3);
   scoped_ptr<LayerImpl> content_layer =
       CreateScrollableLayer(1, surface_size, clip_layer.get());
   content_layer->SetShouldScrollOnMainThread(true);
   content_layer->SetScrollClipLayer(Layer::INVALID_ID);
 
   // Note: we can use the same clip layer for both since both calls to
   // CreateScrollableLayer() use the same surface size.
   scoped_ptr<LayerImpl> scroll_layer =
       CreateScrollableLayer(2, surface_size, clip_layer.get());
-  scroll_layer->AddChild(content_layer.Pass());
-  clip_layer->AddChild(scroll_layer.Pass());
+  scroll_layer->AddChild(std::move(content_layer));
+  clip_layer->AddChild(std::move(scroll_layer));
   clip_layer->SetHasRenderSurface(true);
 
-  host_impl_->active_tree()->SetRootLayer(clip_layer.Pass());
+  host_impl_->active_tree()->SetRootLayer(std::move(clip_layer));
   host_impl_->SetViewportSize(surface_size);
   DrawFrame();
 
   // Scrolling fails because the content layer is asking to be scrolled on the
   // main thread.
   EXPECT_EQ(InputHandler::SCROLL_ON_MAIN_THREAD,
             host_impl_->ScrollBegin(gfx::Point(5, 5), InputHandler::WHEEL));
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollRootAndChangePageScaleOnMainThread) {
@@ skipping 102 matching lines @@
   LayerImpl* scroll = SetupScrollAndContentsLayers(surface_size);
   scroll->SetDrawsContent(true);
   LayerImpl* root = host_impl_->active_tree()->root_layer();
   LayerImpl* child = scroll->children()[0].get();
   child->SetDrawsContent(true);
 
   scoped_ptr<LayerImpl> scrollable_child_clip =
       LayerImpl::Create(host_impl_->active_tree(), 6);
   scoped_ptr<LayerImpl> scrollable_child =
       CreateScrollableLayer(7, surface_size, scrollable_child_clip.get());
-  scrollable_child_clip->AddChild(scrollable_child.Pass());
-  child->AddChild(scrollable_child_clip.Pass());
+  scrollable_child_clip->AddChild(std::move(scrollable_child));
+  child->AddChild(std::move(scrollable_child_clip));
   LayerImpl* grand_child = child->children()[0].get();
   grand_child->SetDrawsContent(true);
 
   // Set new page scale on impl thread by pinching.
   RebuildPropertyTrees();
   host_impl_->ScrollBegin(gfx::Point(), InputHandler::GESTURE);
   host_impl_->PinchGestureBegin();
   host_impl_->PinchGestureUpdate(new_page_scale, gfx::Point());
   host_impl_->PinchGestureEnd();
   host_impl_->ScrollEnd();
@@ skipping 62 matching lines @@
   gfx::Size content_size(20, 20);
   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl_->active_tree(), 1);
   root->SetBounds(surface_size);
   root->SetHasRenderSurface(true);
   scoped_ptr<LayerImpl> grand_child =
       CreateScrollableLayer(3, content_size, root.get());
 
   scoped_ptr<LayerImpl> child =
       CreateScrollableLayer(2, content_size, root.get());
   LayerImpl* grand_child_layer = grand_child.get();
-  child->AddChild(grand_child.Pass());
+  child->AddChild(std::move(grand_child));
 
   LayerImpl* child_layer = child.get();
-  root->AddChild(child.Pass());
-  host_impl_->active_tree()->SetRootLayer(root.Pass());
+  root->AddChild(std::move(child));
+  host_impl_->active_tree()->SetRootLayer(std::move(root));
   host_impl_->active_tree()->DidBecomeActive();
   host_impl_->SetViewportSize(surface_size);
   grand_child_layer->PushScrollOffsetFromMainThread(gfx::ScrollOffset(0, 5));
   child_layer->PushScrollOffsetFromMainThread(gfx::ScrollOffset(3, 0));
 
   DrawFrame();
   {
     gfx::Vector2d scroll_delta(-8, -7);
     EXPECT_EQ(InputHandler::SCROLL_STARTED,
               host_impl_->ScrollBegin(gfx::Point(), InputHandler::WHEEL));
@@ skipping 25 matching lines @@
   scoped_ptr<LayerImpl> root_scrolling =
       CreateScrollableLayer(2, surface_size, root.get());
   root_scrolling->SetIsContainerForFixedPositionLayers(true);
 
   scoped_ptr<LayerImpl> grand_child =
       CreateScrollableLayer(4, surface_size, root.get());
 
   scoped_ptr<LayerImpl> child =
       CreateScrollableLayer(3, surface_size, root.get());
   LayerImpl* grand_child_layer = grand_child.get();
-  child->AddChild(grand_child.Pass());
+  child->AddChild(std::move(grand_child));
 
   LayerImpl* child_layer = child.get();
-  root_scrolling->AddChild(child.Pass());
-  root->AddChild(root_scrolling.Pass());
+  root_scrolling->AddChild(std::move(child));
+  root->AddChild(std::move(root_scrolling));
   EXPECT_EQ(viewport_size, root->bounds());
-  host_impl_->active_tree()->SetRootLayer(root.Pass());
+  host_impl_->active_tree()->SetRootLayer(std::move(root));
   host_impl_->active_tree()->SetViewportLayersFromIds(Layer::INVALID_ID, 1, 2,
                                                       Layer::INVALID_ID);
   host_impl_->active_tree()->DidBecomeActive();
   host_impl_->SetViewportSize(viewport_size);
 
   grand_child_layer->PushScrollOffsetFromMainThread(gfx::ScrollOffset(0, 2));
   child_layer->PushScrollOffsetFromMainThread(gfx::ScrollOffset(0, 3));
 
   DrawFrame();
   {
@@ skipping 89 matching lines @@
   scoped_ptr<LayerImpl> root =
       CreateScrollableLayer(1, content_size, root_clip.get());
   // Make 'root' the clip layer for child: since they have the same sizes the
   // child will have zero max_scroll_offset and scrolls will bubble.
   scoped_ptr<LayerImpl> child =
       CreateScrollableLayer(2, content_size, root.get());
   child->SetIsContainerForFixedPositionLayers(true);
   root->SetBounds(content_size);
 
   int root_scroll_id = root->id();
-  root->AddChild(child.Pass());
-  root_clip->AddChild(root.Pass());
+  root->AddChild(std::move(child));
+  root_clip->AddChild(std::move(root));
 
   host_impl_->SetViewportSize(surface_size);
-  host_impl_->active_tree()->SetRootLayer(root_clip.Pass());
+  host_impl_->active_tree()->SetRootLayer(std::move(root_clip));
   host_impl_->active_tree()->SetViewportLayersFromIds(Layer::INVALID_ID, 3, 2,
                                                       Layer::INVALID_ID);
   host_impl_->active_tree()->DidBecomeActive();
   DrawFrame();
   {
     gfx::Vector2d scroll_delta(0, 4);
     EXPECT_EQ(InputHandler::SCROLL_STARTED,
               host_impl_->ScrollBegin(gfx::Point(5, 5), InputHandler::WHEEL));
     host_impl_->ScrollBy(gfx::Point(), scroll_delta);
     host_impl_->ScrollEnd();
 
     scoped_ptr<ScrollAndScaleSet> scroll_info =
         host_impl_->ProcessScrollDeltas();
 
     // Only the root scroll should have scrolled.
     ASSERT_EQ(scroll_info->scrolls.size(), 1u);
     EXPECT_TRUE(
         ScrollInfoContains(*scroll_info.get(), root_scroll_id, scroll_delta));
   }
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollBeforeRedraw) {
   gfx::Size surface_size(10, 10);
   scoped_ptr<LayerImpl> root_clip =
       LayerImpl::Create(host_impl_->active_tree(), 1);
   scoped_ptr<LayerImpl> root_scroll =
       CreateScrollableLayer(2, surface_size, root_clip.get());
   root_scroll->SetIsContainerForFixedPositionLayers(true);
   root_clip->SetHasRenderSurface(true);
-  root_clip->AddChild(root_scroll.Pass());
-  host_impl_->active_tree()->SetRootLayer(root_clip.Pass());
+  root_clip->AddChild(std::move(root_scroll));
+  host_impl_->active_tree()->SetRootLayer(std::move(root_clip));
   host_impl_->active_tree()->SetViewportLayersFromIds(Layer::INVALID_ID, 1, 2,
                                                       Layer::INVALID_ID);
   host_impl_->active_tree()->DidBecomeActive();
   host_impl_->SetViewportSize(surface_size);
 
   // Draw one frame and then immediately rebuild the layer tree to mimic a tree
   // synchronization.
   DrawFrame();
   host_impl_->active_tree()->DetachLayerTree();
   scoped_ptr<LayerImpl> root_clip2 =
       LayerImpl::Create(host_impl_->active_tree(), 3);
   scoped_ptr<LayerImpl> root_scroll2 =
       CreateScrollableLayer(4, surface_size, root_clip2.get());
   root_scroll2->SetIsContainerForFixedPositionLayers(true);
-  root_clip2->AddChild(root_scroll2.Pass());
+  root_clip2->AddChild(std::move(root_scroll2));
   root_clip2->SetHasRenderSurface(true);
-  host_impl_->active_tree()->SetRootLayer(root_clip2.Pass());
+  host_impl_->active_tree()->SetRootLayer(std::move(root_clip2));
   host_impl_->active_tree()->SetViewportLayersFromIds(Layer::INVALID_ID, 3, 4,
                                                       Layer::INVALID_ID);
   host_impl_->active_tree()->DidBecomeActive();
 
   // Scrolling should still work even though we did not draw yet.
   RebuildPropertyTrees();
   EXPECT_EQ(InputHandler::SCROLL_STARTED,
             host_impl_->ScrollBegin(gfx::Point(5, 5), InputHandler::WHEEL));
 }
 
@@ skipping 55 matching lines @@
 
   // Only allow vertical scrolling.
   clip_layer->SetBounds(
       gfx::Size(child->bounds().width(), child->bounds().height() / 2));
   // The rotation depends on the layer's transform origin, and the child layer
   // is a different size than the clip, so make sure the clip layer's origin
   // lines up over the child.
   clip_layer->SetTransformOrigin(gfx::Point3F(
       clip_layer->bounds().width() * 0.5f, clip_layer->bounds().height(), 0.f));
   LayerImpl* child_ptr = child.get();
-  clip_layer->AddChild(child.Pass());
-  scroll_layer->AddChild(clip_layer.Pass());
+  clip_layer->AddChild(std::move(child));
+  scroll_layer->AddChild(std::move(clip_layer));
 
   gfx::Size surface_size(50, 50);
   host_impl_->SetViewportSize(surface_size);
   DrawFrame();
   {
     // Scroll down in screen coordinates with a gesture.
     gfx::Vector2d gesture_scroll_delta(0, 10);
     EXPECT_EQ(InputHandler::SCROLL_STARTED,
               host_impl_->ScrollBegin(gfx::Point(1, 1), InputHandler::GESTURE));
     host_impl_->ScrollBy(gfx::Point(), gesture_scroll_delta);
@@ skipping 56 matching lines @@
   perspective_transform.Translate(50.0, 50.0);
   clip_layer->SetTransform(perspective_transform);
 
   clip_layer->SetBounds(gfx::Size(child_ptr->bounds().width() / 2,
                                   child_ptr->bounds().height() / 2));
   // The transform depends on the layer's transform origin, and the child layer
   // is a different size than the clip, so make sure the clip layer's origin
   // lines up over the child.
   clip_layer->SetTransformOrigin(gfx::Point3F(
       clip_layer->bounds().width(), clip_layer->bounds().height(), 0.f));
-  clip_layer->AddChild(child.Pass());
-  scroll_layer->AddChild(clip_layer.Pass());
+  clip_layer->AddChild(std::move(child));
+  scroll_layer->AddChild(std::move(clip_layer));
 
   gfx::Size surface_size(50, 50);
   host_impl_->SetViewportSize(surface_size);
 
   scoped_ptr<ScrollAndScaleSet> scroll_info;
 
   gfx::Vector2d gesture_scroll_deltas[4];
   gesture_scroll_deltas[0] = gfx::Vector2d(4, 10);
   gesture_scroll_deltas[1] = gfx::Vector2d(4, 10);
   gesture_scroll_deltas[2] = gfx::Vector2d(10, 0);
@@ skipping 406 matching lines @@
 
   scoped_ptr<LayerImpl> root =
       CreateScrollableLayer(1, surface_size, root_clip.get());
 
   scoped_ptr<LayerImpl> grand_child =
       CreateScrollableLayer(3, surface_size, root_clip.get());
 
   scoped_ptr<LayerImpl> child =
       CreateScrollableLayer(2, surface_size, root_clip.get());
   LayerImpl* grand_child_layer = grand_child.get();
-  child->AddChild(grand_child.Pass());
+  child->AddChild(std::move(grand_child));
 
   LayerImpl* child_layer = child.get();
-  root->AddChild(child.Pass());
-  root_clip->AddChild(root.Pass());
+  root->AddChild(std::move(child));
+  root_clip->AddChild(std::move(root));
   child_layer->PushScrollOffsetFromMainThread(gfx::ScrollOffset(0, 3));
   grand_child_layer->PushScrollOffsetFromMainThread(gfx::ScrollOffset(0, 2));
-  host_impl_->active_tree()->SetRootLayer(root_clip.Pass());
+  host_impl_->active_tree()->SetRootLayer(std::move(root_clip));
   host_impl_->active_tree()->DidBecomeActive();
   host_impl_->SetViewportSize(surface_size);
   DrawFrame();
   {
     gfx::Vector2d scroll_delta(0, -10);
     EXPECT_EQ(InputHandler::SCROLL_STARTED,
               host_impl_->ScrollBegin(gfx::Point(),
                                       InputHandler::NON_BUBBLING_GESTURE));
     scroll_result = host_impl_->ScrollBy(gfx::Point(), scroll_delta);
     EXPECT_TRUE(scroll_result.did_scroll);
@@ skipping 219 matching lines @@
   ResourceId resource_id_;
 };
 
 TEST_F(LayerTreeHostImplTest, BlendingOffWhenDrawingOpaqueLayers) {
   {
     scoped_ptr<LayerImpl> root =
         LayerImpl::Create(host_impl_->active_tree(), 1);
     root->SetBounds(gfx::Size(10, 10));
     root->SetDrawsContent(false);
     root->SetHasRenderSurface(true);
-    host_impl_->active_tree()->SetRootLayer(root.Pass());
+    host_impl_->active_tree()->SetRootLayer(std::move(root));
   }
   LayerImpl* root = host_impl_->active_tree()->root_layer();
 
   root->AddChild(
       BlendStateCheckLayer::Create(host_impl_->active_tree(),
                                    2,
                                    host_impl_->resource_provider()));
   BlendStateCheckLayer* layer1 =
       static_cast<BlendStateCheckLayer*>(root->children()[0].get());
   layer1->SetPosition(gfx::PointF(2.f, 2.f));
@@ skipping 468 matching lines @@
       : LayerImpl(tree_impl, id) {}
 };
 
 // Only reshape when we know we are going to draw. Otherwise, the reshape
 // can leave the window at the wrong size if we never draw and the proper
 // viewport size is never set.
 TEST_F(LayerTreeHostImplTest, ReshapeNotCalledUntilDraw) {
   scoped_refptr<TestContextProvider> provider(TestContextProvider::Create());
   scoped_ptr<OutputSurface> output_surface(
       FakeOutputSurface::Create3d(provider));
-  CreateHostImpl(DefaultSettings(), output_surface.Pass());
+  CreateHostImpl(DefaultSettings(), std::move(output_surface));
 
   scoped_ptr<LayerImpl> root =
       FakeDrawableLayerImpl::Create(host_impl_->active_tree(), 1);
   root->SetBounds(gfx::Size(10, 10));
   root->SetDrawsContent(true);
   root->SetHasRenderSurface(true);
-  host_impl_->active_tree()->SetRootLayer(root.Pass());
+  host_impl_->active_tree()->SetRootLayer(std::move(root));
   EXPECT_FALSE(provider->TestContext3d()->reshape_called());
   provider->TestContext3d()->clear_reshape_called();
 
   LayerTreeHostImpl::FrameData frame;
   host_impl_->SetViewportSize(gfx::Size(10, 10));
   host_impl_->active_tree()->SetDeviceScaleFactor(1.f);
   EXPECT_EQ(DRAW_SUCCESS, PrepareToDrawFrame(&frame));
   host_impl_->DrawLayers(&frame);
   EXPECT_TRUE(provider->TestContext3d()->reshape_called());
   EXPECT_EQ(provider->TestContext3d()->width(), 10);
@@ skipping 52 matching lines @@
   scoped_ptr<LayerImpl> root =
       FakeDrawableLayerImpl::Create(layer_tree_host_impl->active_tree(), 1);
   root->SetHasRenderSurface(true);
   scoped_ptr<LayerImpl> child =
       FakeDrawableLayerImpl::Create(layer_tree_host_impl->active_tree(), 2);
   child->SetPosition(gfx::PointF(12.f, 13.f));
   child->SetBounds(gfx::Size(14, 15));
   child->SetDrawsContent(true);
   root->SetBounds(gfx::Size(500, 500));
   root->SetDrawsContent(true);
-  root->AddChild(child.Pass());
-  layer_tree_host_impl->active_tree()->SetRootLayer(root.Pass());
+  root->AddChild(std::move(child));
+  layer_tree_host_impl->active_tree()->SetRootLayer(std::move(root));
 
   LayerTreeHostImpl::FrameData frame;
 
   // First frame, the entire screen should get swapped.
   layer_tree_host_impl->active_tree()->BuildPropertyTreesForTesting();
   EXPECT_EQ(DRAW_SUCCESS, layer_tree_host_impl->PrepareToDraw(&frame));
   layer_tree_host_impl->DrawLayers(&frame);
   layer_tree_host_impl->DidDrawAllLayers(frame);
   layer_tree_host_impl->SwapBuffers(frame);
   gfx::Rect expected_swap_rect(0, 0, 500, 500);
@@ skipping 37 matching lines @@
 TEST_F(LayerTreeHostImplTest, RootLayerDoesntCreateExtraSurface) {
   scoped_ptr<LayerImpl> root =
       FakeDrawableLayerImpl::Create(host_impl_->active_tree(), 1);
   scoped_ptr<LayerImpl> child =
       FakeDrawableLayerImpl::Create(host_impl_->active_tree(), 2);
   child->SetBounds(gfx::Size(10, 10));
   child->SetDrawsContent(true);
   root->SetBounds(gfx::Size(10, 10));
   root->SetDrawsContent(true);
   root->SetHasRenderSurface(true);
-  root->AddChild(child.Pass());
+  root->AddChild(std::move(child));
 
-  host_impl_->active_tree()->SetRootLayer(root.Pass());
+  host_impl_->active_tree()->SetRootLayer(std::move(root));
 
   LayerTreeHostImpl::FrameData frame;
 
   EXPECT_EQ(DRAW_SUCCESS, PrepareToDrawFrame(&frame));
   EXPECT_EQ(1u, frame.render_surface_layer_list->size());
   EXPECT_EQ(1u, frame.render_passes.size());
   host_impl_->DidDrawAllLayers(frame);
 }
 
 class FakeLayerWithQuads : public LayerImpl {
@@ skipping 111 matching lines @@
 
 TEST_F(LayerTreeHostImplTest, NoPartialSwap) {
   scoped_ptr<MockContext> mock_context_owned(new MockContext);
   MockContext* mock_context = mock_context_owned.get();
   MockContextHarness harness(mock_context);
 
   // Run test case
   LayerTreeSettings settings = DefaultSettings();
   settings.renderer_settings.partial_swap_enabled = false;
   CreateHostImpl(settings,
-                 FakeOutputSurface::Create3d(mock_context_owned.Pass()));
+                 FakeOutputSurface::Create3d(std::move(mock_context_owned)));
   SetupRootLayerImpl(FakeLayerWithQuads::Create(host_impl_->active_tree(), 1));
 
   // Without partial swap, and no clipping, no scissor is set.
   harness.MustDrawSolidQuad();
   harness.MustSetNoScissor();
   {
     LayerTreeHostImpl::FrameData frame;
     EXPECT_EQ(DRAW_SUCCESS, PrepareToDrawFrame(&frame));
     host_impl_->DrawLayers(&frame);
     host_impl_->DidDrawAllLayers(frame);
@@ skipping 14 matching lines @@
   Mock::VerifyAndClearExpectations(&mock_context);
 }
 
 TEST_F(LayerTreeHostImplTest, PartialSwap) {
   scoped_ptr<MockContext> context_owned(new MockContext);
   MockContext* mock_context = context_owned.get();
   MockContextHarness harness(mock_context);
 
   LayerTreeSettings settings = DefaultSettings();
   settings.renderer_settings.partial_swap_enabled = true;
-  CreateHostImpl(settings, FakeOutputSurface::Create3d(context_owned.Pass()));
+  CreateHostImpl(settings,
+                 FakeOutputSurface::Create3d(std::move(context_owned)));
   SetupRootLayerImpl(FakeLayerWithQuads::Create(host_impl_->active_tree(), 1));
 
   // The first frame is not a partially-swapped one. No scissor should be set.
   harness.MustSetNoScissor();
   harness.MustDrawSolidQuad();
   {
     LayerTreeHostImpl::FrameData frame;
     EXPECT_EQ(DRAW_SUCCESS, PrepareToDrawFrame(&frame));
     host_impl_->DrawLayers(&frame);
     host_impl_->DidDrawAllLayers(frame);
@@ skipping 76 matching lines @@
   child->SetBounds(gfx::Size(child_rect.width(), child_rect.height()));
   child->draw_properties().visible_layer_rect = child_rect;
   child->SetDrawsContent(false);
   child->SetHasRenderSurface(true);
 
   grand_child->SetPosition(gfx::PointF(grand_child_rect.origin()));
   grand_child->SetBounds(grand_child_rect.size());
   grand_child->draw_properties().visible_layer_rect = grand_child_rect;
   grand_child->SetDrawsContent(true);
 
-  child->AddChild(grand_child.Pass());
-  root->AddChild(child.Pass());
+  child->AddChild(std::move(grand_child));
+  root->AddChild(std::move(child));
 
-  my_host_impl->active_tree()->SetRootLayer(root.Pass());
+  my_host_impl->active_tree()->SetRootLayer(std::move(root));
   my_host_impl->active_tree()->BuildPropertyTreesForTesting();
-  return my_host_impl.Pass();
+  return my_host_impl;
 }
 
 TEST_F(LayerTreeHostImplTest, ContributingLayerEmptyScissorPartialSwap) {
   TestSharedBitmapManager shared_bitmap_manager;
   TestTaskGraphRunner task_graph_runner;
   scoped_refptr<TestContextProvider> provider(TestContextProvider::Create());
   provider->BindToCurrentThread();
   provider->TestContext3d()->set_have_post_sub_buffer(true);
   scoped_ptr<OutputSurface> output_surface(
       FakeOutputSurface::Create3d(provider));
@@ skipping 45 matching lines @@
     my_host_impl->DrawLayers(&frame);
     my_host_impl->DidDrawAllLayers(frame);
   }
 }
 
 TEST_F(LayerTreeHostImplTest, LayersFreeTextures) {
   scoped_ptr<TestWebGraphicsContext3D> context =
       TestWebGraphicsContext3D::Create();
   TestWebGraphicsContext3D* context3d = context.get();
   scoped_ptr<OutputSurface> output_surface(
-      FakeOutputSurface::Create3d(context.Pass()));
-  CreateHostImpl(DefaultSettings(), output_surface.Pass());
+      FakeOutputSurface::Create3d(std::move(context)));
+  CreateHostImpl(DefaultSettings(), std::move(output_surface));
 
   scoped_ptr<LayerImpl> root_layer =
       LayerImpl::Create(host_impl_->active_tree(), 1);
   root_layer->SetBounds(gfx::Size(10, 10));
   root_layer->SetHasRenderSurface(true);
 
   scoped_refptr<VideoFrame> softwareFrame =
       media::VideoFrame::CreateColorFrame(
           gfx::Size(4, 4), 0x80, 0x80, 0x80, base::TimeDelta());
   FakeVideoFrameProvider provider;
   provider.set_frame(softwareFrame);
   scoped_ptr<VideoLayerImpl> video_layer = VideoLayerImpl::Create(
       host_impl_->active_tree(), 4, &provider, media::VIDEO_ROTATION_0);
   video_layer->SetBounds(gfx::Size(10, 10));
   video_layer->SetDrawsContent(true);
-  root_layer->AddChild(video_layer.Pass());
+  root_layer->AddChild(std::move(video_layer));
 
   scoped_ptr<IOSurfaceLayerImpl> io_surface_layer =
       IOSurfaceLayerImpl::Create(host_impl_->active_tree(), 5);
   io_surface_layer->SetBounds(gfx::Size(10, 10));
   io_surface_layer->SetDrawsContent(true);
   io_surface_layer->SetIOSurfaceProperties(1, gfx::Size(10, 10));
-  root_layer->AddChild(io_surface_layer.Pass());
+  root_layer->AddChild(std::move(io_surface_layer));
 
-  host_impl_->active_tree()->SetRootLayer(root_layer.Pass());
+  host_impl_->active_tree()->SetRootLayer(std::move(root_layer));
 
   EXPECT_EQ(0u, context3d->NumTextures());
 
   LayerTreeHostImpl::FrameData frame;
   EXPECT_EQ(DRAW_SUCCESS, PrepareToDrawFrame(&frame));
   host_impl_->DrawLayers(&frame);
   host_impl_->DidDrawAllLayers(frame);
   host_impl_->SwapBuffers(frame);
 
   EXPECT_GT(context3d->NumTextures(), 0u);
@@ skipping 16 matching lines @@
 
 TEST_F(LayerTreeHostImplTest, HasTransparentBackground) {
   scoped_ptr<MockDrawQuadsToFillScreenContext> mock_context_owned(
       new MockDrawQuadsToFillScreenContext);
   MockDrawQuadsToFillScreenContext* mock_context = mock_context_owned.get();
 
   // Run test case
   LayerTreeSettings settings = DefaultSettings();
   settings.renderer_settings.partial_swap_enabled = false;
   CreateHostImpl(settings,
-                 FakeOutputSurface::Create3d(mock_context_owned.Pass()));
+                 FakeOutputSurface::Create3d(std::move(mock_context_owned)));
   SetupRootLayerImpl(LayerImpl::Create(host_impl_->active_tree(), 1));
   host_impl_->active_tree()->set_background_color(SK_ColorWHITE);
 
   // Verify one quad is drawn when transparent background set is not set.
   host_impl_->active_tree()->set_has_transparent_background(false);
   EXPECT_CALL(*mock_context, useProgram(_))
       .Times(1);
   EXPECT_CALL(*mock_context, drawElements(_, _, _, _))
       .Times(1);
   LayerTreeHostImpl::FrameData frame;
@@ skipping 63 matching lines @@
   root->SetBounds(gfx::Size(10, 10));
   root->SetDrawsContent(true);
   root->SetHasRenderSurface(true);
 
   // Child layer is in the bottom right corner.
   scoped_ptr<SolidColorLayerImpl> child =
       SolidColorLayerImpl::Create(host_impl_->active_tree(), 2);
   child->SetPosition(gfx::PointF(9.f, 9.f));
   child->SetBounds(gfx::Size(1, 1));
   child->SetDrawsContent(true);
-  root->AddChild(child.Pass());
+  root->AddChild(std::move(child));
 
-  host_impl_->active_tree()->SetRootLayer(root.Pass());
+  host_impl_->active_tree()->SetRootLayer(std::move(root));
 
   // Draw a frame. In the first frame, the entire viewport should be damaged.
   gfx::Rect full_frame_damage(host_impl_->DrawViewportSize());
   DrawFrameAndTestDamage(full_frame_damage);
 
   // The second frame has damage that doesn't touch the child layer. Its quads
   // should still be generated.
   gfx::Rect small_damage = gfx::Rect(0, 0, 1, 1);
   host_impl_->active_tree()->root_layer()->SetUpdateRect(small_damage);
   DrawFrameAndTestDamage(small_damage);
@@ skipping 45 matching lines @@
   host_impl_->CreatePendingTree();
   host_impl_->pending_tree()->SetDeviceScaleFactor(device_scale_factor);
   host_impl_->pending_tree()->PushPageScaleFromMainThread(1.f, 1.f / 16.f,
                                                           16.f);
 
   scoped_ptr<LayerImpl> scoped_root =
       LayerImpl::Create(host_impl_->pending_tree(), 1);
   LayerImpl* root = scoped_root.get();
   root->SetHasRenderSurface(true);
 
-  host_impl_->pending_tree()->SetRootLayer(scoped_root.Pass());
+  host_impl_->pending_tree()->SetRootLayer(std::move(scoped_root));
 
   scoped_ptr<LayerImpl> scoped_scrolling_layer =
       LayerImpl::Create(host_impl_->pending_tree(), 2);
   LayerImpl* scrolling_layer = scoped_scrolling_layer.get();
-  root->AddChild(scoped_scrolling_layer.Pass());
+  root->AddChild(std::move(scoped_scrolling_layer));
 
   gfx::Size content_layer_bounds(100000, 100);
   scoped_refptr<FakeDisplayListRasterSource> raster_source(
       FakeDisplayListRasterSource::CreateFilled(content_layer_bounds));
 
   scoped_ptr<FakePictureLayerImpl> scoped_content_layer =
       FakePictureLayerImpl::CreateWithRasterSource(host_impl_->pending_tree(),
                                                    3, raster_source);
   LayerImpl* content_layer = scoped_content_layer.get();
-  scrolling_layer->AddChild(scoped_content_layer.Pass());
+  scrolling_layer->AddChild(std::move(scoped_content_layer));
   content_layer->SetBounds(content_layer_bounds);
   content_layer->SetDrawsContent(true);
 
   root->SetBounds(root_size);
 
   gfx::ScrollOffset scroll_offset(100000, 0);
   scrolling_layer->SetScrollClipLayer(root->id());
   scrolling_layer->PushScrollOffsetFromMainThread(scroll_offset);
 
   host_impl_->pending_tree()->BuildPropertyTreesForTesting();
@@ skipping 125 matching lines @@
   // SolidColorLayerImpl will be drawn.
   scoped_ptr<SolidColorLayerImpl> root_layer =
       SolidColorLayerImpl::Create(host_impl_->active_tree(), 1);
 
   // VideoLayerImpl will not be drawn.
   FakeVideoFrameProvider provider;
   scoped_ptr<VideoLayerImpl> video_layer = VideoLayerImpl::Create(
       host_impl_->active_tree(), 2, &provider, media::VIDEO_ROTATION_0);
   video_layer->SetBounds(gfx::Size(10, 10));
   video_layer->SetDrawsContent(true);
-  root_layer->AddChild(video_layer.Pass());
-  SetupRootLayerImpl(root_layer.Pass());
+  root_layer->AddChild(std::move(video_layer));
+  SetupRootLayerImpl(std::move(root_layer));
 
   LayerTreeHostImpl::FrameData frame;
   EXPECT_EQ(DRAW_SUCCESS, PrepareToDrawFrame(&frame));
   host_impl_->DrawLayers(&frame);
   host_impl_->DidDrawAllLayers(frame);
 
   EXPECT_EQ(1u, frame.will_draw_layers.size());
   EXPECT_EQ(host_impl_->active_tree()->root_layer(), frame.will_draw_layers[0]);
 }
 
@@ skipping 85 matching lines @@
   EXPECT_FALSE(fake_host_impl_->prepare_tiles_needed());
   host_impl_->SetVisible(true);
   EXPECT_TRUE(fake_host_impl_->prepare_tiles_needed());
 }
 
 TEST_F(LayerTreeHostImplTest, UIResourceManagement) {
   scoped_ptr<TestWebGraphicsContext3D> context =
       TestWebGraphicsContext3D::Create();
   TestWebGraphicsContext3D* context3d = context.get();
   scoped_ptr<FakeOutputSurface> output_surface = FakeOutputSurface::Create3d();
-  CreateHostImpl(DefaultSettings(), output_surface.Pass());
+  CreateHostImpl(DefaultSettings(), std::move(output_surface));
 
   EXPECT_EQ(0u, context3d->NumTextures());
 
   UIResourceId ui_resource_id = 1;
   bool is_opaque = false;
   UIResourceBitmap bitmap(gfx::Size(1, 1), is_opaque);
   host_impl_->CreateUIResource(ui_resource_id, bitmap);
   EXPECT_EQ(1u, context3d->NumTextures());
   ResourceId id1 = host_impl_->ResourceIdForUIResource(ui_resource_id);
   EXPECT_NE(0u, id1);
@@ skipping 95 matching lines @@
   scoped_ptr<LayerImpl> root_clip =
       LayerImpl::Create(host_impl_->active_tree(), 3);
   root_clip->SetHasRenderSurface(true);
 
   scoped_ptr<LayerImpl> root =
       CreateScrollableLayer(1, content_size, root_clip.get());
   root->SetIsContainerForFixedPositionLayers(true);
   scoped_ptr<LayerImpl> child =
       CreateScrollableLayer(2, content_size, root_clip.get());
 
-  root->AddChild(child.Pass());
+  root->AddChild(std::move(child));
   int root_id = root->id();
-  root_clip->AddChild(root.Pass());
+  root_clip->AddChild(std::move(root));
 
   host_impl_->SetViewportSize(surface_size);
-  host_impl_->active_tree()->SetRootLayer(root_clip.Pass());
+  host_impl_->active_tree()->SetRootLayer(std::move(root_clip));
   host_impl_->active_tree()->SetViewportLayersFromIds(Layer::INVALID_ID, 3, 1,
                                                       Layer::INVALID_ID);
   host_impl_->active_tree()->DidBecomeActive();
   DrawFrame();
   {
     EXPECT_EQ(InputHandler::SCROLL_STARTED,
               host_impl_->ScrollBegin(gfx::Point(), InputHandler::GESTURE));
 
     EXPECT_EQ(InputHandler::SCROLL_STARTED, host_impl_->FlingScrollBegin());
 
@@ skipping 21 matching lines @@
   scoped_ptr<LayerImpl> root_scrolling =
       CreateScrollableLayer(2, surface_size, root.get());
 
   scoped_ptr<LayerImpl> grand_child =
       CreateScrollableLayer(4, surface_size, root.get());
   grand_child->PushScrollOffsetFromMainThread(gfx::ScrollOffset(0, 2));
 
   scoped_ptr<LayerImpl> child =
       CreateScrollableLayer(3, surface_size, root.get());
   child->PushScrollOffsetFromMainThread(gfx::ScrollOffset(0, 4));
-  child->AddChild(grand_child.Pass());
+  child->AddChild(std::move(grand_child));
 
-  root_scrolling->AddChild(child.Pass());
-  root->AddChild(root_scrolling.Pass());
-  host_impl_->active_tree()->SetRootLayer(root.Pass());
+  root_scrolling->AddChild(std::move(child));
+  root->AddChild(std::move(root_scrolling));
+  host_impl_->active_tree()->SetRootLayer(std::move(root));
   host_impl_->active_tree()->DidBecomeActive();
   host_impl_->SetViewportSize(surface_size);
   DrawFrame();
   {
     scoped_ptr<ScrollAndScaleSet> scroll_info;
     LayerImpl* child =
         host_impl_->active_tree()->root_layer()->children()[0]->children()
             [0].get();
     LayerImpl* grand_child = child->children()[0].get();
 
@@ skipping 42 matching lines @@
   gfx::Size content_size(20, 20);
   scoped_ptr<LayerImpl> root_clip =
       LayerImpl::Create(host_impl_->active_tree(), 3);
   root_clip->SetHasRenderSurface(true);
   scoped_ptr<LayerImpl> root_scroll =
       CreateScrollableLayer(1, content_size, root_clip.get());
   int root_scroll_id = root_scroll->id();
   scoped_ptr<LayerImpl> child =
       CreateScrollableLayer(2, content_size, root_clip.get());
 
-  root_scroll->AddChild(child.Pass());
-  root_clip->AddChild(root_scroll.Pass());
+  root_scroll->AddChild(std::move(child));
+  root_clip->AddChild(std::move(root_scroll));
 
   host_impl_->SetViewportSize(surface_size);
-  host_impl_->active_tree()->SetRootLayer(root_clip.Pass());
+  host_impl_->active_tree()->SetRootLayer(std::move(root_clip));
   host_impl_->active_tree()->DidBecomeActive();
   DrawFrame();
   {
     EXPECT_EQ(InputHandler::SCROLL_STARTED,
               host_impl_->ScrollBegin(gfx::Point(), InputHandler::WHEEL));
 
     EXPECT_EQ(InputHandler::SCROLL_STARTED, host_impl_->FlingScrollBegin());
 
     gfx::Vector2d scroll_delta(0, 100);
     host_impl_->ScrollBy(gfx::Point(), scroll_delta);
@@ skipping 26 matching lines @@
       host_impl_->active_tree()->LayerById(page_scale_layer_id);
 
   int occluder_layer_id = 6;
   scoped_ptr<LayerImpl> occluder_layer =
       LayerImpl::Create(host_impl_->active_tree(), occluder_layer_id);
   occluder_layer->SetDrawsContent(true);
   occluder_layer->SetBounds(content_size);
   occluder_layer->SetPosition(gfx::PointF());
 
   // The parent of the occluder is *above* the scroller.
-  page_scale_layer->AddChild(occluder_layer.Pass());
+  page_scale_layer->AddChild(std::move(occluder_layer));
 
   DrawFrame();
 
   EXPECT_EQ(InputHandler::SCROLL_UNKNOWN,
             host_impl_->ScrollBegin(gfx::Point(), InputHandler::WHEEL));
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollUnknownScrollAncestorMismatch) {
   // If we ray cast a scroller this is on the first layer's ancestor chain, but
   // is not the first scroller we encounter when walking up from the layer, we
@@ skipping 16 matching lines @@
   int child_scroll_clip_layer_id = 7;
   scoped_ptr<LayerImpl> child_scroll_clip =
       LayerImpl::Create(host_impl_->active_tree(), child_scroll_clip_layer_id);
 
   int child_scroll_layer_id = 8;
   scoped_ptr<LayerImpl> child_scroll = CreateScrollableLayer(
       child_scroll_layer_id, content_size, child_scroll_clip.get());
 
   child_scroll->SetPosition(gfx::PointF(10.f, 10.f));
 
-  child_scroll->AddChild(occluder_layer.Pass());
-  scroll_layer->AddChild(child_scroll.Pass());
+  child_scroll->AddChild(std::move(occluder_layer));
+  scroll_layer->AddChild(std::move(child_scroll));
 
   DrawFrame();
 
   EXPECT_EQ(InputHandler::SCROLL_UNKNOWN,
             host_impl_->ScrollBegin(gfx::Point(), InputHandler::WHEEL));
 }
 
 TEST_F(LayerTreeHostImplTest, NotScrollInvisibleScroller) {
   gfx::Size content_size(100, 100);
   SetupScrollAndContentsLayers(content_size);
 
   LayerImpl* root = host_impl_->active_tree()->LayerById(1);
 
   int scroll_layer_id = 2;
   LayerImpl* scroll_layer =
       host_impl_->active_tree()->LayerById(scroll_layer_id);
 
   int child_scroll_layer_id = 7;
   scoped_ptr<LayerImpl> child_scroll =
       CreateScrollableLayer(child_scroll_layer_id, content_size, root);
   child_scroll->SetDrawsContent(false);
 
-  scroll_layer->AddChild(child_scroll.Pass());
+  scroll_layer->AddChild(std::move(child_scroll));
 
   DrawFrame();
 
   // We should not have scrolled |child_scroll| even though we technically "hit"
   // it. The reason for this is that if the scrolling the scroll would not move
   // any layer that is a drawn RSLL member, then we can ignore the hit.
   //
   // Why SCROLL_STARTED? In this case, it's because we've bubbled out and
   // started scrolling the inner viewport.
   EXPECT_EQ(InputHandler::SCROLL_STARTED,
@@ skipping 17 matching lines @@
       LayerImpl::Create(host_impl_->active_tree(), 8);
   child_layer->SetDrawsContent(false);
 
   scoped_ptr<LayerImpl> grand_child_layer =
       LayerImpl::Create(host_impl_->active_tree(), 9);
   grand_child_layer->SetDrawsContent(true);
   grand_child_layer->SetBounds(content_size);
   // Move the grand child so it's not hit by our test point.
   grand_child_layer->SetPosition(gfx::PointF(10.f, 10.f));
 
-  child_layer->AddChild(grand_child_layer.Pass());
-  invisible_scroll_layer->AddChild(child_layer.Pass());
-  root_scroll_layer->AddChild(invisible_scroll_layer.Pass());
+  child_layer->AddChild(std::move(grand_child_layer));
+  invisible_scroll_layer->AddChild(std::move(child_layer));
+  root_scroll_layer->AddChild(std::move(invisible_scroll_layer));
 
   DrawFrame();
 
   // We should have scrolled |invisible_scroll_layer| as it was hit and it has
   // a descendant which is a drawn RSLL member.
   EXPECT_EQ(InputHandler::SCROLL_STARTED,
             host_impl_->ScrollBegin(gfx::Point(), InputHandler::WHEEL));
 
   EXPECT_EQ(7, host_impl_->CurrentlyScrollingLayer()->id());
 }
@@ skipping 28 matching lines @@
   int container_id = 8;
   scoped_ptr<LayerImpl> container =
       LayerImpl::Create(host_impl_->active_tree(), container_id);
 
   scoped_ptr<std::set<LayerImpl*>> scroll_children(new std::set<LayerImpl*>);
   scroll_children->insert(scroll_child.get());
   invisible_scroll->SetScrollChildren(scroll_children.release());
 
   scroll_child->SetScrollParent(invisible_scroll.get());
 
-  container->AddChild(invisible_scroll.Pass());
-  container->AddChild(scroll_child.Pass());
+  container->AddChild(std::move(invisible_scroll));
+  container->AddChild(std::move(scroll_child));
 
-  scroll_layer->AddChild(container.Pass());
+  scroll_layer->AddChild(std::move(container));
 
   DrawFrame();
 
   // We should have scrolled |child_scroll| even though it is invisible.
   // The reason for this is that if the scrolling the scroll would move a layer
   // that is a drawn RSLL member, then we should accept this hit.
   EXPECT_EQ(InputHandler::SCROLL_STARTED,
             host_impl_->ScrollBegin(gfx::Point(), InputHandler::WHEEL));
 
   EXPECT_EQ(7, host_impl_->CurrentlyScrollingLayer()->id());
 }
 
 // Make sure LatencyInfo carried by LatencyInfoSwapPromise are passed
 // to CompositorFrameMetadata after SwapBuffers();
 TEST_F(LayerTreeHostImplTest, LatencyInfoPassedToCompositorFrameMetadata) {
   scoped_ptr<SolidColorLayerImpl> root =
       SolidColorLayerImpl::Create(host_impl_->active_tree(), 1);
   root->SetPosition(gfx::PointF());
   root->SetBounds(gfx::Size(10, 10));
   root->SetDrawsContent(true);
   root->SetHasRenderSurface(true);
 
-  host_impl_->active_tree()->SetRootLayer(root.Pass());
+  host_impl_->active_tree()->SetRootLayer(std::move(root));
 
   FakeOutputSurface* fake_output_surface =
       static_cast<FakeOutputSurface*>(host_impl_->output_surface());
 
   const std::vector<ui::LatencyInfo>& metadata_latency_before =
       fake_output_surface->last_sent_frame().metadata.latency_info;
   EXPECT_TRUE(metadata_latency_before.empty());
 
   ui::LatencyInfo latency_info;
   latency_info.AddLatencyNumber(
       ui::INPUT_EVENT_LATENCY_BEGIN_RWH_COMPONENT, 0, 0);
   scoped_ptr<SwapPromise> swap_promise(
       new LatencyInfoSwapPromise(latency_info));
-  host_impl_->active_tree()->QueuePinnedSwapPromise(swap_promise.Pass());
+  host_impl_->active_tree()->QueuePinnedSwapPromise(std::move(swap_promise));
   host_impl_->SetNeedsRedraw();
 
   gfx::Rect full_frame_damage(host_impl_->DrawViewportSize());
   LayerTreeHostImpl::FrameData frame;
   EXPECT_EQ(DRAW_SUCCESS, PrepareToDrawFrame(&frame));
   host_impl_->DrawLayers(&frame);
   host_impl_->DidDrawAllLayers(frame);
   EXPECT_TRUE(host_impl_->SwapBuffers(frame));
 
   const std::vector<ui::LatencyInfo>& metadata_latency_after =
       fake_output_surface->last_sent_frame().metadata.latency_info;
   EXPECT_EQ(1u, metadata_latency_after.size());
   EXPECT_TRUE(metadata_latency_after[0].FindLatency(
       ui::INPUT_EVENT_LATENCY_BEGIN_RWH_COMPONENT, 0, NULL));
 }
 
 TEST_F(LayerTreeHostImplTest, SelectionBoundsPassedToCompositorFrameMetadata) {
   int root_layer_id = 1;
   scoped_ptr<SolidColorLayerImpl> root =
       SolidColorLayerImpl::Create(host_impl_->active_tree(), root_layer_id);
   root->SetPosition(gfx::PointF());
   root->SetBounds(gfx::Size(10, 10));
   root->SetDrawsContent(true);
   root->SetHasRenderSurface(true);
 
-  host_impl_->active_tree()->SetRootLayer(root.Pass());
+  host_impl_->active_tree()->SetRootLayer(std::move(root));
 
   // Ensure the default frame selection bounds are empty.
   FakeOutputSurface* fake_output_surface =
       static_cast<FakeOutputSurface*>(host_impl_->output_surface());
   const ViewportSelection& selection_before =
       fake_output_surface->last_sent_frame().metadata.selection;
   EXPECT_EQ(ViewportSelectionBound(), selection_before.start);
   EXPECT_EQ(ViewportSelectionBound(), selection_before.end);
 
   // Plumb the layer-local selection bounds.
@@ skipping 606 matching lines @@
     outer_scroll->PushScrollOffsetFromMainThread(gfx::ScrollOffset());
     outer_scroll->SetBounds(content_size);
     outer_scroll->SetPosition(gfx::PointF());
 
     scoped_ptr<LayerImpl> contents =
         LayerImpl::Create(layer_tree_impl, 8);
     contents->SetDrawsContent(true);
     contents->SetBounds(content_size);
     contents->SetPosition(gfx::PointF());
 
-    outer_scroll->AddChild(contents.Pass());
-    outer_clip->AddChild(outer_scroll.Pass());
-    inner_scroll->AddChild(outer_clip.Pass());
-    page_scale->AddChild(inner_scroll.Pass());
-    inner_clip->AddChild(page_scale.Pass());
+    outer_scroll->AddChild(std::move(contents));
+    outer_clip->AddChild(std::move(outer_scroll));
+    inner_scroll->AddChild(std::move(outer_clip));
+    page_scale->AddChild(std::move(inner_scroll));
+    inner_clip->AddChild(std::move(page_scale));
 
     inner_clip->SetHasRenderSurface(true);
-    layer_tree_impl->SetRootLayer(inner_clip.Pass());
+    layer_tree_impl->SetRootLayer(std::move(inner_clip));
     layer_tree_impl->SetViewportLayersFromIds(
         Layer::INVALID_ID, kPageScaleLayerId, kInnerViewportScrollLayerId,
         kOuterViewportScrollLayerId);
 
     host_impl_->active_tree()->DidBecomeActive();
   }
 };
 
 TEST_F(LayerTreeHostImplVirtualViewportTest, ScrollBothInnerAndOuterLayer) {
   gfx::Size content_size = gfx::Size(100, 160);
@@ skipping 144 matching lines @@
   gfx::Size inner_viewport = gfx::Size(25, 40);
 
   SetupVirtualViewportLayers(content_size, outer_viewport, inner_viewport);
 
   LayerImpl* outer_scroll = host_impl_->OuterViewportScrollLayer();
   LayerImpl* inner_scroll = host_impl_->InnerViewportScrollLayer();
 
   scoped_ptr<LayerImpl> child =
       CreateScrollableLayer(10, outer_viewport, outer_scroll);
   LayerImpl* child_scroll = child.get();
-  outer_scroll->children()[0]->AddChild(child.Pass());
+  outer_scroll->children()[0]->AddChild(std::move(child));
 
   DrawFrame();
   {
     scoped_ptr<ScrollAndScaleSet> scroll_info;
 
     gfx::Vector2d scroll_delta(0, inner_viewport.height());
     EXPECT_EQ(InputHandler::SCROLL_STARTED,
               host_impl_->ScrollBegin(gfx::Point(), InputHandler::GESTURE));
     EXPECT_TRUE(host_impl_->ScrollBy(gfx::Point(), scroll_delta).did_scroll);
     EXPECT_TRUE(host_impl_->IsCurrentlyScrollingLayerAt(gfx::Point(),
@@ skipping 36 matching lines @@
   gfx::Size inner_viewport = gfx::Size(25, 40);
 
   SetupVirtualViewportLayers(content_size, outer_viewport, inner_viewport);
 
   LayerImpl* outer_scroll = host_impl_->OuterViewportScrollLayer();
   LayerImpl* inner_scroll = host_impl_->InnerViewportScrollLayer();
 
   scoped_ptr<LayerImpl> child =
       CreateScrollableLayer(10, outer_viewport, outer_scroll);
   LayerImpl* child_scroll = child.get();
-  outer_scroll->children()[0]->AddChild(child.Pass());
+  outer_scroll->children()[0]->AddChild(std::move(child));
 
   DrawFrame();
 
   EXPECT_EQ(InputHandler::SCROLL_STARTED,
             host_impl_->RootScrollBegin(InputHandler::GESTURE));
   EXPECT_EQ(host_impl_->CurrentlyScrollingLayer(), inner_scroll);
   host_impl_->ScrollEnd();
   EXPECT_EQ(InputHandler::SCROLL_STARTED,
             host_impl_->ScrollBegin(gfx::Point(), InputHandler::GESTURE));
   EXPECT_EQ(host_impl_->CurrentlyScrollingLayer(), child_scroll);
@@ skipping 415 matching lines @@
   layer->set_gpu_raster_max_texture_size(host_impl_->device_viewport_size());
   layer->SetDrawsContent(true);
   layer->tilings()->AddTiling(1.0f, raster_source_with_tiles);
   layer->UpdateRasterSource(raster_source_with_tiles, &empty_invalidation,
                             nullptr);
   layer->tilings()->tiling_at(0)->set_resolution(
       TileResolution::HIGH_RESOLUTION);
   layer->tilings()->tiling_at(0)->CreateAllTilesForTesting();
   layer->tilings()->tiling_at(0)->ComputeTilePriorityRects(
       gfx::Rect(gfx::Size(10, 10)), 1.f, 1.0, Occlusion());
-  host_impl_->pending_tree()->SetRootLayer(layer.Pass());
+  host_impl_->pending_tree()->SetRootLayer(std::move(layer));
 
   FakePictureLayerImpl* root_layer = static_cast<FakePictureLayerImpl*>(
       host_impl_->pending_tree()->root_layer());
 
   root_layer->set_has_valid_tile_priorities(true);
   scoped_ptr<RasterTilePriorityQueue> non_empty_raster_priority_queue_all =
       host_impl_->BuildRasterQueue(TreePriority::SAME_PRIORITY_FOR_BOTH_TREES,
                                    RasterTilePriorityQueue::Type::ALL);
   EXPECT_FALSE(non_empty_raster_priority_queue_all->IsEmpty());
 
   root_layer->set_has_valid_tile_priorities(false);
   scoped_ptr<RasterTilePriorityQueue> empty_raster_priority_queue_all =
       host_impl_->BuildRasterQueue(TreePriority::SAME_PRIORITY_FOR_BOTH_TREES,
                                    RasterTilePriorityQueue::Type::ALL);
   EXPECT_TRUE(empty_raster_priority_queue_all->IsEmpty());
 }
 
 TEST_F(LayerTreeHostImplTest, DidBecomeActive) {
   host_impl_->CreatePendingTree();
   host_impl_->ActivateSyncTree();
   host_impl_->CreatePendingTree();
 
   LayerTreeImpl* pending_tree = host_impl_->pending_tree();
 
   scoped_ptr<FakePictureLayerImpl> pending_layer =
       FakePictureLayerImpl::Create(pending_tree, 10);
   FakePictureLayerImpl* raw_pending_layer = pending_layer.get();
-  pending_tree->SetRootLayer(pending_layer.Pass());
+  pending_tree->SetRootLayer(std::move(pending_layer));
   ASSERT_EQ(raw_pending_layer, pending_tree->root_layer());
 
   EXPECT_EQ(0u, raw_pending_layer->did_become_active_call_count());
   pending_tree->DidBecomeActive();
   EXPECT_EQ(1u, raw_pending_layer->did_become_active_call_count());
 
   scoped_ptr<FakePictureLayerImpl> mask_layer =
       FakePictureLayerImpl::Create(pending_tree, 11);
   FakePictureLayerImpl* raw_mask_layer = mask_layer.get();
-  raw_pending_layer->SetMaskLayer(mask_layer.Pass());
+  raw_pending_layer->SetMaskLayer(std::move(mask_layer));
   ASSERT_EQ(raw_mask_layer, raw_pending_layer->mask_layer());
 
   EXPECT_EQ(1u, raw_pending_layer->did_become_active_call_count());
   EXPECT_EQ(0u, raw_mask_layer->did_become_active_call_count());
   pending_tree->DidBecomeActive();
   EXPECT_EQ(2u, raw_pending_layer->did_become_active_call_count());
   EXPECT_EQ(1u, raw_mask_layer->did_become_active_call_count());
 
   scoped_ptr<FakePictureLayerImpl> replica_layer =
       FakePictureLayerImpl::Create(pending_tree, 12);
   scoped_ptr<FakePictureLayerImpl> replica_mask_layer =
       FakePictureLayerImpl::Create(pending_tree, 13);
   FakePictureLayerImpl* raw_replica_mask_layer = replica_mask_layer.get();
-  replica_layer->SetMaskLayer(replica_mask_layer.Pass());
-  raw_pending_layer->SetReplicaLayer(replica_layer.Pass());
+  replica_layer->SetMaskLayer(std::move(replica_mask_layer));
+  raw_pending_layer->SetReplicaLayer(std::move(replica_layer));
   ASSERT_EQ(raw_replica_mask_layer,
             raw_pending_layer->replica_layer()->mask_layer());
 
   EXPECT_EQ(2u, raw_pending_layer->did_become_active_call_count());
   EXPECT_EQ(1u, raw_mask_layer->did_become_active_call_count());
   EXPECT_EQ(0u, raw_replica_mask_layer->did_become_active_call_count());
   pending_tree->DidBecomeActive();
   EXPECT_EQ(3u, raw_pending_layer->did_become_active_call_count());
   EXPECT_EQ(2u, raw_mask_layer->did_become_active_call_count());
   EXPECT_EQ(1u, raw_replica_mask_layer->did_become_active_call_count());
@@ skipping 277 matching lines @@
   EXPECT_FALSE(host_impl_->use_gpu_rasterization());
   EXPECT_FALSE(host_impl_->use_msaa());
 
   scoped_ptr<TestWebGraphicsContext3D> context_with_msaa =
       TestWebGraphicsContext3D::Create();
   context_with_msaa->SetMaxSamples(8);
 
   LayerTreeSettings msaaSettings = GpuRasterizationEnabledSettings();
   msaaSettings.gpu_rasterization_msaa_sample_count = 4;
   EXPECT_TRUE(CreateHostImpl(
-      msaaSettings, FakeOutputSurface::Create3d(context_with_msaa.Pass())));
+      msaaSettings, FakeOutputSurface::Create3d(std::move(context_with_msaa))));
   host_impl_->SetHasGpuRasterizationTrigger(true);
   host_impl_->SetContentIsSuitableForGpuRasterization(false);
   EXPECT_EQ(GpuRasterizationStatus::MSAA_CONTENT,
             host_impl_->gpu_rasterization_status());
   EXPECT_TRUE(host_impl_->use_gpu_rasterization());
   EXPECT_TRUE(host_impl_->use_msaa());
 
   LayerTreeSettings settings = DefaultSettings();
   settings.gpu_rasterization_enabled = false;
   EXPECT_TRUE(CreateHostImpl(settings, FakeOutputSurface::Create3d()));
@@ skipping 37 matching lines @@
 // Display::Draw (and the planned Display Scheduler) currently rely on resources
 // being reclaimed to block drawing between BeginCommit / Swap. This test
 // ensures that BeginCommit triggers ForceReclaimResources. See
 // crbug.com/489515.
 TEST_F(LayerTreeHostImplTest, BeginCommitReclaimsResources) {
   scoped_ptr<MockReclaimResourcesOutputSurface> output_surface(
       MockReclaimResourcesOutputSurface::Create3d());
   // Hold an unowned pointer to the output surface to use for mock expectations.
   MockReclaimResourcesOutputSurface* mock_output_surface = output_surface.get();
 
-  CreateHostImpl(DefaultSettings(), output_surface.Pass());
+  CreateHostImpl(DefaultSettings(), std::move(output_surface));
   EXPECT_CALL(*mock_output_surface, ForceReclaimResources()).Times(1);
   host_impl_->BeginCommit();
 }
 
 TEST_F(LayerTreeHostImplTest, UpdatePageScaleFactorOnActiveTree) {
   // Check page scale factor update in property trees when an update is made
   // on the active tree.
   host_impl_->CreatePendingTree();
   host_impl_->pending_tree()->PushPageScaleFromMainThread(1.f, 1.f, 3.f);
   CreateScrollAndContentsLayers(host_impl_->pending_tree(),
@@ skipping 53 matching lines @@
   host_impl_->active_tree()->SetPageScaleOnActiveTree(2.f);
   DrawFrame();
   in_subtree_of_page_scale_layer = host_impl_->active_tree()->LayerById(100);
   node = host_impl_->active_tree()->property_trees()->transform_tree.Node(
       in_subtree_of_page_scale_layer->transform_tree_index());
   EXPECT_EQ(node->data.sublayer_scale, gfx::Vector2dF(2.f, 2.f));
 }
 
 }  // namespace
 }  // namespace cc