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

cc/trees/layer_tree_host_unittest_delegated.cc

 // Copyright 2013 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.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/location.h"
@@ skipping 67 matching lines @@
   scoped_ptr<DelegatedFrameData> CreateFrameData(
       const gfx::Rect& root_output_rect,
       const gfx::Rect& root_damage_rect) {
     scoped_ptr<DelegatedFrameData> frame(new DelegatedFrameData);
 
     scoped_ptr<RenderPass> root_pass(RenderPass::Create());
     root_pass->SetNew(RenderPassId(1, 1),
                       root_output_rect,
                       root_damage_rect,
                       gfx::Transform());
-    frame->render_pass_list.push_back(root_pass.Pass());
-    return frame.Pass();
+    frame->render_pass_list.push_back(std::move(root_pass));
+    return frame;
   }
 
   scoped_ptr<DelegatedFrameData> CreateInvalidFrameData(
       const gfx::Rect& root_output_rect,
       const gfx::Rect& root_damage_rect) {
     scoped_ptr<DelegatedFrameData> frame(new DelegatedFrameData);
 
     scoped_ptr<RenderPass> root_pass(RenderPass::Create());
     root_pass->SetNew(RenderPassId(1, 1),
                       root_output_rect,
@@ skipping 24 matching lines @@
                               visible_rect,
                               resource_id,
                               premultiplied_alpha,
                               uv_top_left,
                               uv_bottom_right,
                               background_color,
                               vertex_opacity,
                               flipped,
                               nearest_neighbor);
 
-    frame->render_pass_list.push_back(root_pass.Pass());
-    return frame.Pass();
+    frame->render_pass_list.push_back(std::move(root_pass));
+    return frame;
   }
 
   void AddTransferableResource(DelegatedFrameData* frame,
                                ResourceId resource_id) {
     TransferableResource resource;
     resource.id = resource_id;
     resource.mailbox_holder.texture_target = GL_TEXTURE_2D;
     GLbyte arbitrary_mailbox[GL_MAILBOX_SIZE_CHROMIUM] = {
         1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2,
         3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4,
@@ skipping 104 matching lines @@
   void BeginTest() override {
     resource_collection_->SetClient(this);
     PostSetNeedsCommitToMainThread();
   }
 
   void SetFrameData(scoped_ptr<DelegatedFrameData> frame_data) {
     RenderPass* root_pass = frame_data->render_pass_list.back().get();
     gfx::Size frame_size = root_pass->output_rect.size();
 
     if (frame_provider_.get() && frame_size == frame_provider_->frame_size()) {
-      frame_provider_->SetFrameData(frame_data.Pass());
+      frame_provider_->SetFrameData(std::move(frame_data));
       return;
     }
 
     if (delegated_.get()) {
       delegated_->RemoveFromParent();
       delegated_ = NULL;
       frame_provider_ = NULL;
     }
 
     frame_provider_ = new DelegatedFrameProvider(resource_collection_.get(),
-                                                 frame_data.Pass());
+                                                 std::move(frame_data));
 
     delegated_ = CreateDelegatedLayer(frame_provider_.get());
   }
 
   scoped_refptr<DelegatedRendererLayer> CreateDelegatedLayer(
       DelegatedFrameProvider* frame_provider) {
     scoped_refptr<DelegatedRendererLayer> delegated =
         FakeDelegatedRendererLayer::Create(layer_settings(), frame_provider);
     delegated->SetBounds(gfx::Size(10, 10));
     delegated->SetIsDrawable(true);
@@ skipping 132 matching lines @@
   LayerTreeHostDelegatedTestInvalidFrameAfterContextLost()
       : num_activates_(0), num_output_surfaces_initialized_(0) {}
 
   void DidCommit() override {
     if (TestEnded())
       return;
     scoped_ptr<DelegatedFrameData> frame1 =
         CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
     AddTextureQuad(frame1.get(), 999);
     AddTransferableResource(frame1.get(), 999);
-    SetFrameData(frame1.Pass());
+    SetFrameData(std::move(frame1));
   }
 
   void DidInitializeOutputSurface() override {
     if (!num_output_surfaces_initialized_++)
       return;
 
     scoped_refptr<DelegatedRendererLayer> old_delegated = delegated_;
     SetFrameData(
         CreateInvalidFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1)));
     // Make sure we end up using the same layer, or we won't test the right
@@ skipping 254 matching lines @@
     : public LayerTreeHostDelegatedTestCaseSingleDelegatedLayer {
  public:
   void BeginTest() override {
     // Push two frames to the delegated renderer layer with no commit between.
 
     // The first frame has resource 999.
     scoped_ptr<DelegatedFrameData> frame1 =
         CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
     AddTextureQuad(frame1.get(), 999);
     AddTransferableResource(frame1.get(), 999);
-    SetFrameData(frame1.Pass());
+    SetFrameData(std::move(frame1));
 
     // The second frame uses resource 999 still, but also adds 555.
     scoped_ptr<DelegatedFrameData> frame2 =
         CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
     AddTextureQuad(frame2.get(), 999);
     AddTransferableResource(frame2.get(), 999);
     AddTextureQuad(frame2.get(), 555);
     AddTransferableResource(frame2.get(), 555);
-    SetFrameData(frame2.Pass());
+    SetFrameData(std::move(frame2));
 
     // The resource 999 from frame1 is returned since it is still on the main
     // thread.
     ReturnedResourceArray returned_resources;
     resource_collection_->TakeUnusedResourcesForChildCompositor(
         &returned_resources);
     {
       unsigned expected[] = {999};
       EXPECT_RESOURCES(expected, returned_resources);
       EXPECT_TRUE(TestAndResetAvailable());
@@ skipping 31 matching lines @@
     : public LayerTreeHostDelegatedTestCaseSingleDelegatedLayer {
  public:
   void BeginTest() override {
     // Generate a frame with two resources in it.
     scoped_ptr<DelegatedFrameData> frame =
         CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
     AddTextureQuad(frame.get(), 999);
     AddTransferableResource(frame.get(), 999);
     AddTextureQuad(frame.get(), 555);
     AddTransferableResource(frame.get(), 555);
-    SetFrameData(frame.Pass());
+    SetFrameData(std::move(frame));
 
     PostSetNeedsCommitToMainThread();
   }
 
   void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) override {
     LayerImpl* root_impl = host_impl->active_tree()->root_layer();
     FakeDelegatedRendererLayerImpl* delegated_impl =
         static_cast<FakeDelegatedRendererLayerImpl*>(
             root_impl->children()[0].get());
 
@@ skipping 36 matching lines @@
 
     int next_source_frame_number = layer_tree_host()->source_frame_number();
     switch (next_source_frame_number) {
       case 1:
         // Generate a frame with two resources in it.
         frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
         AddTextureQuad(frame.get(), 999);
         AddTransferableResource(frame.get(), 999);
         AddTextureQuad(frame.get(), 555);
         AddTransferableResource(frame.get(), 555);
-        SetFrameData(frame.Pass());
+        SetFrameData(std::move(frame));
         break;
       case 2:
         // All of the resources are in use.
         resource_collection_->TakeUnusedResourcesForChildCompositor(&resources);
         EXPECT_EQ(0u, resources.size());
         EXPECT_FALSE(TestAndResetAvailable());
 
         // Keep using 999 but stop using 555.
         frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
         AddTextureQuad(frame.get(), 999);
         AddTransferableResource(frame.get(), 999);
         AddTextureQuad(frame.get(), 444);
         AddTransferableResource(frame.get(), 444);
-        SetFrameData(frame.Pass());
+        SetFrameData(std::move(frame));
         break;
       case 3:
         // 555 is no longer in use.
         resource_collection_->TakeUnusedResourcesForChildCompositor(&resources);
         {
           unsigned expected[] = {555};
           EXPECT_RESOURCES(expected, resources);
           EXPECT_TRUE(TestAndResetAvailable());
         }
 
         // Stop using any resources.
         frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
-        SetFrameData(frame.Pass());
+        SetFrameData(std::move(frame));
         break;
       case 4:
         // Postpone collecting resources for a frame. They should still be there
         // the next frame.
         layer_tree_host()->SetNeedsCommit();
         return;
       case 5:
         // 444 and 999 are no longer in use. We sent two refs to 999, so we
         // should get two back.
         resource_collection_->TakeUnusedResourcesForChildCompositor(&resources);
@@ skipping 35 matching lines @@
     switch (next_source_frame_number) {
       case 1:
         // Generate a frame with some resources in it.
         frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
         AddTextureQuad(frame.get(), 999);
         AddTransferableResource(frame.get(), 999);
         AddTextureQuad(frame.get(), 555);
         AddTransferableResource(frame.get(), 555);
         AddTextureQuad(frame.get(), 444);
         AddTransferableResource(frame.get(), 444);
-        SetFrameData(frame.Pass());
+        SetFrameData(std::move(frame));
         break;
       case 2:
         // All of the resources are in use.
         resource_collection_->TakeUnusedResourcesForChildCompositor(&resources);
         EXPECT_EQ(0u, resources.size());
         EXPECT_FALSE(TestAndResetAvailable());
 
         // Keep using 999 but stop using 555 and 444.
         frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
         AddTextureQuad(frame.get(), 999);
         AddTransferableResource(frame.get(), 999);
-        SetFrameData(frame.Pass());
+        SetFrameData(std::move(frame));
 
         // Resource are not immediately released.
         resource_collection_->TakeUnusedResourcesForChildCompositor(&resources);
         EXPECT_EQ(0u, resources.size());
         EXPECT_FALSE(TestAndResetAvailable());
 
         // Now using 555 and 444 again, but not 999.
         frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
         AddTextureQuad(frame.get(), 555);
         AddTransferableResource(frame.get(), 555);
         AddTextureQuad(frame.get(), 444);
         AddTransferableResource(frame.get(), 444);
-        SetFrameData(frame.Pass());
+        SetFrameData(std::move(frame));
         break;
       case 3:
         // The 999 resource is the only unused one. Two references were sent, so
         // two should be returned.
         resource_collection_->TakeUnusedResourcesForChildCompositor(&resources);
         {
           unsigned expected[] = {999, 999};
           EXPECT_RESOURCES(expected, resources);
           EXPECT_TRUE(TestAndResetAvailable());
         }
@@ skipping 22 matching lines @@
     switch (next_source_frame_number) {
       case 1:
         // Generate a frame with some resources in it.
         frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
         AddTextureQuad(frame.get(), 999);
         AddTransferableResource(frame.get(), 999);
         AddTextureQuad(frame.get(), 555);
         AddTransferableResource(frame.get(), 555);
         AddTextureQuad(frame.get(), 444);
         AddTransferableResource(frame.get(), 444);
-        SetFrameData(frame.Pass());
+        SetFrameData(std::move(frame));
         break;
       case 2:
         // All of the resources are in use.
         resource_collection_->TakeUnusedResourcesForChildCompositor(&resources);
         EXPECT_EQ(0u, resources.size());
         EXPECT_FALSE(TestAndResetAvailable());
 
         // Keep using 999 but stop using 555 and 444.
         frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
         AddTextureQuad(frame.get(), 999);
         AddTransferableResource(frame.get(), 999);
-        SetFrameData(frame.Pass());
+        SetFrameData(std::move(frame));
 
         // Resource are not immediately released.
         resource_collection_->TakeUnusedResourcesForChildCompositor(&resources);
         EXPECT_EQ(0u, resources.size());
         EXPECT_FALSE(TestAndResetAvailable());
 
         // The parent compositor (this one) does a commit.
         break;
       case 3:
         resource_collection_->TakeUnusedResourcesForChildCompositor(&resources);
         {
           unsigned expected[] = {444, 555};
           EXPECT_RESOURCES(expected, resources);
           EXPECT_TRUE(TestAndResetAvailable());
         }
 
         // The child compositor sends a frame referring to resources not in the
         // frame.
         frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
         AddTextureQuad(frame.get(), 999);
         AddTextureQuad(frame.get(), 555);
         AddTextureQuad(frame.get(), 444);
-        SetFrameData(frame.Pass());
+        SetFrameData(std::move(frame));
         break;
     }
   }
 
   void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) override {
     if (host_impl->active_tree()->source_frame_number() != 3)
       return;
 
     LayerImpl* root_impl = host_impl->active_tree()->root_layer();
     FakeDelegatedRendererLayerImpl* delegated_impl =
@@ skipping 42 matching lines @@
     switch (next_source_frame_number) {
       case 1:
         // Generate a frame with some resources in it.
         frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
         AddTextureQuad(frame.get(), 999);
         AddTransferableResource(frame.get(), 999);
         AddTextureQuad(frame.get(), 555);
         AddTransferableResource(frame.get(), 555);
         AddTextureQuad(frame.get(), 444);
         AddTransferableResource(frame.get(), 444);
-        SetFrameData(frame.Pass());
+        SetFrameData(std::move(frame));
         break;
       case 2:
         // All of the resources are in use.
         resource_collection_->TakeUnusedResourcesForChildCompositor(&resources);
         EXPECT_EQ(0u, resources.size());
         EXPECT_FALSE(TestAndResetAvailable());
 
         // Keep using 999 but stop using 555 and 444.
         frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
         AddTextureQuad(frame.get(), 999);
         AddTransferableResource(frame.get(), 999);
-        SetFrameData(frame.Pass());
+        SetFrameData(std::move(frame));
 
         // Resource are not immediately released.
         resource_collection_->TakeUnusedResourcesForChildCompositor(&resources);
         EXPECT_EQ(0u, resources.size());
         EXPECT_FALSE(TestAndResetAvailable());
 
         // The parent compositor (this one) does a commit.
         break;
       case 3:
         // The child compositor sends a frame before taking resources back
         // from the previous commit. This frame makes use of the resources 555
         // and 444, which were just released during commit.
         frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
         AddTextureQuad(frame.get(), 999);
         AddTransferableResource(frame.get(), 999);
         AddTextureQuad(frame.get(), 555);
         AddTransferableResource(frame.get(), 555);
         AddTextureQuad(frame.get(), 444);
         AddTransferableResource(frame.get(), 444);
-        SetFrameData(frame.Pass());
+        SetFrameData(std::move(frame));
 
         // The resources are used by the new frame but are returned anyway since
         // we passed them again.
         resource_collection_->TakeUnusedResourcesForChildCompositor(&resources);
         {
           unsigned expected[] = {444, 555};
           EXPECT_RESOURCES(expected, resources);
           EXPECT_TRUE(TestAndResetAvailable());
         }
         break;
@@ skipping 63 matching lines @@
 
     int next_source_frame_number = layer_tree_host()->source_frame_number();
     switch (next_source_frame_number) {
       case 1:
         // Generate a frame with some resources in it.
         frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
         AddTextureQuad(frame.get(), 999);
         AddTransferableResource(frame.get(), 999);
         AddTextureQuad(frame.get(), 555);
         AddTransferableResource(frame.get(), 555);
-        SetFrameData(frame.Pass());
+        SetFrameData(std::move(frame));
         break;
       case 2:
         // All of the resources are in use.
         resource_collection_->TakeUnusedResourcesForChildCompositor(&resources);
         EXPECT_EQ(0u, resources.size());
         EXPECT_FALSE(TestAndResetAvailable());
 
         // Generate a bad frame with a resource the layer doesn't have. The
         // 885 and 775 resources are unknown, while ownership of the legit 444
         // resource is passed in here. The bad frame does not use any of the
         // previous resources, 999 or 555.
         // A bad quad is present both before and after the good quad.
         frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
         AddTextureQuad(frame.get(), 885);
         AddTextureQuad(frame.get(), 444);
         AddTransferableResource(frame.get(), 444);
         AddTextureQuad(frame.get(), 775);
-        SetFrameData(frame.Pass());
+        SetFrameData(std::move(frame));
 
         // The parent compositor (this one) does a commit.
         break;
       case 3:
         resource_collection_->TakeUnusedResourcesForChildCompositor(&resources);
         EXPECT_EQ(0u, resources.size());
         EXPECT_FALSE(TestAndResetAvailable());
 
         // Now send a good frame with 999 again.
         frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
         AddTextureQuad(frame.get(), 999);
-        SetFrameData(frame.Pass());
+        SetFrameData(std::move(frame));
 
         // The bad frame's resource is given back to the child compositor.
         resource_collection_->TakeUnusedResourcesForChildCompositor(&resources);
         {
           unsigned expected[] = {444};
           EXPECT_RESOURCES(expected, resources);
           EXPECT_TRUE(TestAndResetAvailable());
         }
         break;
       case 4:
@@ skipping 103 matching lines @@
     ReturnedResourceArray resources;
 
     int next_source_frame_number = layer_tree_host()->source_frame_number();
     switch (next_source_frame_number) {
       case 1:
         // This frame includes two resources in it, but only uses one.
         frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
         AddTransferableResource(frame.get(), 999);
         AddTextureQuad(frame.get(), 555);
         AddTransferableResource(frame.get(), 555);
-        SetFrameData(frame.Pass());
+        SetFrameData(std::move(frame));
         break;
       case 2:
         resource_collection_->TakeUnusedResourcesForChildCompositor(&resources);
         EXPECT_EQ(0u, resources.size());
         EXPECT_FALSE(TestAndResetAvailable());
 
         // Now send an empty frame.
         frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
-        SetFrameData(frame.Pass());
+        SetFrameData(std::move(frame));
 
         // The unused resource should be returned.
         resource_collection_->TakeUnusedResourcesForChildCompositor(&resources);
         {
           unsigned expected[] = {999};
           EXPECT_RESOURCES(expected, resources);
           EXPECT_TRUE(TestAndResetAvailable());
         }
 
         EndTest();
@@ skipping 36 matching lines @@
 
     int next_source_frame_number = layer_tree_host()->source_frame_number();
     switch (next_source_frame_number) {
       case 1:
         // This frame includes two resources in it.
         frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
         AddTextureQuad(frame.get(), 999);
         AddTransferableResource(frame.get(), 999);
         AddTextureQuad(frame.get(), 555);
         AddTransferableResource(frame.get(), 555);
-        SetFrameData(frame.Pass());
+        SetFrameData(std::move(frame));
 
         // But then we immediately stop using 999.
         frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
         AddTextureQuad(frame.get(), 555);
         AddTransferableResource(frame.get(), 555);
-        SetFrameData(frame.Pass());
+        SetFrameData(std::move(frame));
         break;
       case 2:
         // The unused resources should be returned. 555 is still used, but it's
         // returned once to account for the first frame.
         resource_collection_->TakeUnusedResourcesForChildCompositor(&resources);
         {
           unsigned expected[] = {555, 999};
           EXPECT_RESOURCES(expected, resources);
           EXPECT_TRUE(TestAndResetAvailable());
         }
         // Send a frame with no resources in it.
         frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
-        SetFrameData(frame.Pass());
+        SetFrameData(std::move(frame));
         break;
       case 3:
         // The now unused resource 555 should be returned.
         resources.clear();
         resource_collection_->TakeUnusedResourcesForChildCompositor(&resources);
         {
           unsigned expected[] = {555};
           EXPECT_RESOURCES(expected, resources);
           EXPECT_TRUE(TestAndResetAvailable());
         }
@@ skipping 39 matching lines @@
 
     int next_source_frame_number = layer_tree_host()->source_frame_number();
     switch (next_source_frame_number) {
       case 1:
         // This frame includes two resources in it.
         frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
         AddTextureQuad(frame.get(), 999);
         AddTransferableResource(frame.get(), 999);
         AddTextureQuad(frame.get(), 555);
         AddTransferableResource(frame.get(), 555);
-        SetFrameData(frame.Pass());
+        SetFrameData(std::move(frame));
         break;
       case 2:
         resource_collection_->TakeUnusedResourcesForChildCompositor(&resources);
         EXPECT_EQ(0u, resources.size());
         EXPECT_FALSE(TestAndResetAvailable());
 
         // 999 is in use in the grandparent compositor, generate a frame without
         // it present.
         frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
         AddTextureQuad(frame.get(), 555);
         AddTransferableResource(frame.get(), 555);
-        SetFrameData(frame.Pass());
+        SetFrameData(std::move(frame));
         break;
       case 3:
         // Since 999 is in the grandparent it is not returned.
         resource_collection_->TakeUnusedResourcesForChildCompositor(&resources);
         EXPECT_EQ(0u, resources.size());
         EXPECT_FALSE(TestAndResetAvailable());
 
         // The impl side will get back the resource at some point.
         ImplThreadTaskRunner()->PostTask(FROM_HERE,
                                          receive_resource_on_thread_);
@@ skipping 107 matching lines @@
     int next_source_frame_number = layer_tree_host()->source_frame_number();
     switch (next_source_frame_number) {
       case 1:
         frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
         AddTextureQuad(frame.get(), 999);
         AddTransferableResource(frame.get(), 999);
         AddTextureQuad(frame.get(), 555);
         AddTransferableResource(frame.get(), 555);
         AddTextureQuad(frame.get(), 444);
         AddTransferableResource(frame.get(), 444);
-        SetFrameData(frame.Pass());
+        SetFrameData(std::move(frame));
         break;
       case 2:
         resource_collection_->TakeUnusedResourcesForChildCompositor(&resources);
         EXPECT_EQ(0u, resources.size());
         EXPECT_FALSE(TestAndResetAvailable());
 
         // Stop using 999 and 444 in this frame and commit.
         frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
         AddTextureQuad(frame.get(), 555);
         AddTransferableResource(frame.get(), 555);
-        SetFrameData(frame.Pass());
+        SetFrameData(std::move(frame));
         // 999 and 444 will be returned for frame 1, but not 555 since it's in
         // the current frame.
         break;
       case 3:
         // Don't take resources here, but set a new frame that uses 999 again.
         frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
         AddTextureQuad(frame.get(), 999);
         AddTransferableResource(frame.get(), 999);
         AddTextureQuad(frame.get(), 555);
         AddTransferableResource(frame.get(), 555);
-        SetFrameData(frame.Pass());
+        SetFrameData(std::move(frame));
         break;
       case 4:
         // 555 from frame 1 and 2 isn't returned since it's still in use. 999
         // from frame 1 is returned though.
         resource_collection_->TakeUnusedResourcesForChildCompositor(&resources);
         {
           unsigned expected[] = {444, 999};
           EXPECT_RESOURCES(expected, resources);
           EXPECT_TRUE(TestAndResetAvailable());
         }
 
         frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
-        SetFrameData(frame.Pass());
+        SetFrameData(std::move(frame));
         // 555 will be returned 3 times for frames 1 2 and 3, and 999 will be
         // returned once for frame 3.
         break;
       case 5:
         resource_collection_->TakeUnusedResourcesForChildCompositor(&resources);
         {
           unsigned expected[] = {555, 555, 555, 999};
           EXPECT_RESOURCES(expected, resources);
           EXPECT_TRUE(TestAndResetAvailable());
         }
@@ skipping 54 matching lines @@
  protected:
   DelegatedFrameIsActivatedDuringCommit() : returned_resource_count_(0) {}
 
   void BeginTest() override {
     activate_count_ = 0;
 
     scoped_ptr<DelegatedFrameData> frame =
         CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
     AddTextureQuad(frame.get(), 999);
     AddTransferableResource(frame.get(), 999);
-    SetFrameData(frame.Pass());
+    SetFrameData(std::move(frame));
 
     PostSetNeedsCommitToMainThread();
   }
 
   void WillActivateTreeOnThread(LayerTreeHostImpl* impl) override {
     base::AutoLock lock(activate_count_lock_);
     ++activate_count_;
   }
 
   void DidCommit() override {
     // The first frame doesn't cause anything to be returned so it does not
     // need to wait for activation.
     if (layer_tree_host()->source_frame_number() > 1) {
       base::AutoLock lock(activate_count_lock_);
       // The activate happened before commit is done on the main side.
       EXPECT_EQ(activate_count_, layer_tree_host()->source_frame_number());
     }
 
     switch (layer_tree_host()->source_frame_number()) {
       case 1: {
         // The first frame has been committed and will activate. Set a new
         // frame, and expect the next commit to finish *after* it is activated.
         scoped_ptr<DelegatedFrameData> frame =
             CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
         AddTextureQuad(frame.get(), 555);
         AddTransferableResource(frame.get(), 555);
-        SetFrameData(frame.Pass());
+        SetFrameData(std::move(frame));
         break;
       }
       case 2:
         // The second frame has been activated. Remove the layer from
         // the tree to cause another commit/activation. The commit should
         // finish *after* the layer is removed from the active tree.
         delegated_->RemoveFromParent();
         break;
       case 3:
         // Finish the test by releasing resources on the next frame.
         scoped_ptr<DelegatedFrameData> frame =
             CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
-        SetFrameData(frame.Pass());
+        SetFrameData(std::move(frame));
         break;
     }
   }
 
   void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) override {
     // The activate didn't happen before commit is done on the impl side (but it
     // should happen before the main thread is done).
     EXPECT_EQ(activate_count_, host_impl->sync_tree()->source_frame_number());
   }
 
@@ skipping 30 matching lines @@
     ReturnedResourceArray resources;
 
     int next_source_frame_number = layer_tree_host()->source_frame_number();
     switch (next_source_frame_number) {
       case 1:
         frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
         AddTextureQuad(frame.get(), 999);
         AddTransferableResource(frame.get(), 999);
         AddTextureQuad(frame.get(), 555);
         AddTransferableResource(frame.get(), 555);
-        SetFrameData(frame.Pass());
+        SetFrameData(std::move(frame));
         break;
       case 2:
         resource_collection_->TakeUnusedResourcesForChildCompositor(&resources);
         EXPECT_EQ(0u, resources.size());
         EXPECT_FALSE(TestAndResetAvailable());
 
         // Remove the delegated layer and replace it with a new one. Use the
         // same frame and resources for it.
         delegated_->RemoveFromParent();
         delegated_ = CreateDelegatedLayer(frame_provider_.get());
         break;
       case 3:
         resource_collection_->TakeUnusedResourcesForChildCompositor(&resources);
         EXPECT_EQ(0u, resources.size());
         EXPECT_FALSE(TestAndResetAvailable());
 
         // Use a frame with no resources in it.
         frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
-        SetFrameData(frame.Pass());
+        SetFrameData(std::move(frame));
         break;
       case 4:
         // We gave one frame to the frame provider, so we should get one
         // ref back for each resource.
         resource_collection_->TakeUnusedResourcesForChildCompositor(&resources);
         {
           unsigned expected[] = {555, 999};
           EXPECT_RESOURCES(expected, resources);
           EXPECT_TRUE(TestAndResetAvailable());
         }
@@ skipping 19 matching lines @@
     ReturnedResourceArray resources;
 
     int next_source_frame_number = layer_tree_host()->source_frame_number();
     switch (next_source_frame_number) {
       case 1:
         frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
         AddTextureQuad(frame.get(), 999);
         AddTransferableResource(frame.get(), 999);
         AddTextureQuad(frame.get(), 555);
         AddTransferableResource(frame.get(), 555);
-        SetFrameData(frame.Pass());
+        SetFrameData(std::move(frame));
         break;
       case 2:
         resource_collection_->TakeUnusedResourcesForChildCompositor(&resources);
         EXPECT_EQ(0u, resources.size());
         EXPECT_FALSE(TestAndResetAvailable());
 
         frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
         AddTextureQuad(frame.get(), 999);
         AddTransferableResource(frame.get(), 999);
         AddTextureQuad(frame.get(), 555);
         AddTransferableResource(frame.get(), 555);
 
         // Remove the delegated layer and replace it with a new one. Make a new
         // frame but with the same resources for it.
         delegated_->RemoveFromParent();
         delegated_ = NULL;
 
-        frame_provider_->SetFrameData(frame.Pass());
+        frame_provider_->SetFrameData(std::move(frame));
         delegated_ = CreateDelegatedLayer(frame_provider_.get());
         break;
       case 3:
         resource_collection_->TakeUnusedResourcesForChildCompositor(&resources);
         EXPECT_EQ(0u, resources.size());
         EXPECT_FALSE(TestAndResetAvailable());
 
         // Use a frame with no resources in it.
         frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
-        SetFrameData(frame.Pass());
+        SetFrameData(std::move(frame));
         break;
       case 4:
         // We gave two frames to the frame provider, so we should get two
         // refs back for each resource.
         resource_collection_->TakeUnusedResourcesForChildCompositor(&resources);
         {
           unsigned expected[] = {555, 555, 999, 999};
           EXPECT_RESOURCES(expected, resources);
           EXPECT_TRUE(TestAndResetAvailable());
         }
@@ skipping 22 matching lines @@
     int next_source_frame_number = layer_tree_host()->source_frame_number();
     switch (next_source_frame_number) {
       case 1:
         frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
         AddTextureQuad(frame.get(), 999);
         AddTransferableResource(frame.get(), 999);
         AddTextureQuad(frame.get(), 555);
         AddTransferableResource(frame.get(), 555);
 
         // Create a DelegatedRendererLayer using the frame.
-        SetFrameData(frame.Pass());
+        SetFrameData(std::move(frame));
         break;
       case 2:
         // Create a second DelegatedRendererLayer using the same frame provider.
         delegated_thief_ = CreateDelegatedLayer(frame_provider_.get());
         root_->AddChild(delegated_thief_);
 
         // And drop our ref on the frame provider so only the layers keep it
         // alive.
         frame_provider_ = NULL;
         break;
@@ skipping 66 matching lines @@
     int next_source_frame_number = layer_tree_host()->source_frame_number();
     switch (next_source_frame_number) {
       case 1:
         frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
         AddTextureQuad(frame.get(), 999);
         AddTransferableResource(frame.get(), 999);
         AddTextureQuad(frame.get(), 555);
         AddTransferableResource(frame.get(), 555);
 
         // Create a DelegatedRendererLayer using the frame.
-        SetFrameData(frame.Pass());
+        SetFrameData(std::move(frame));
         break;
       case 2:
         resource_collection_->TakeUnusedResourcesForChildCompositor(&resources);
         EXPECT_EQ(0u, resources.size());
         EXPECT_FALSE(TestAndResetAvailable());
 
         // Remove the layer from the tree. The resources should not be returned
         // since they are still on the main thread layer.
         delegated_->RemoveFromParent();
         break;
       case 3:
         resource_collection_->TakeUnusedResourcesForChildCompositor(&resources);
         EXPECT_EQ(0u, resources.size());
         EXPECT_FALSE(TestAndResetAvailable());
 
         // Add the layer back to the tree.
         layer_tree_host()->root_layer()->AddChild(delegated_);
         break;
       case 4:
         resource_collection_->TakeUnusedResourcesForChildCompositor(&resources);
         EXPECT_EQ(0u, resources.size());
         EXPECT_FALSE(TestAndResetAvailable());
 
         // Set a new frame. Resources should be returned.
         frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
         AddTextureQuad(frame.get(), 888);
         AddTransferableResource(frame.get(), 888);
         AddTextureQuad(frame.get(), 777);
         AddTransferableResource(frame.get(), 777);
-        SetFrameData(frame.Pass());
+        SetFrameData(std::move(frame));
         break;
       case 5:
         resource_collection_->TakeUnusedResourcesForChildCompositor(&resources);
         {
           unsigned expected[] = {555, 999};
           EXPECT_RESOURCES(expected, resources);
           EXPECT_TRUE(TestAndResetAvailable());
         }
 
         // Destroy the layer.
@@ skipping 40 matching lines @@
     int next_source_frame_number = layer_tree_host()->source_frame_number();
     switch (next_source_frame_number) {
       case 1:
         frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
         AddTextureQuad(frame.get(), 999);
         AddTransferableResource(frame.get(), 999);
         AddTextureQuad(frame.get(), 555);
         AddTransferableResource(frame.get(), 555);
 
         // Create a DelegatedRendererLayer using the frame.
-        SetFrameData(frame.Pass());
+        SetFrameData(std::move(frame));
         break;
       case 2:
         resource_collection_->TakeUnusedResourcesForChildCompositor(&resources);
         EXPECT_EQ(0u, resources.size());
         EXPECT_FALSE(TestAndResetAvailable());
 
         // Remove the layer from the tree. The resources should not be returned
         // since they are still on the main thread layer.
         delegated_->RemoveFromParent();
         break;
       case 3:
         resource_collection_->TakeUnusedResourcesForChildCompositor(&resources);
         EXPECT_EQ(0u, resources.size());
         EXPECT_FALSE(TestAndResetAvailable());
 
         // Set a new frame. Resources should be returned immediately.
         frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
         AddTextureQuad(frame.get(), 888);
         AddTransferableResource(frame.get(), 888);
         AddTextureQuad(frame.get(), 777);
         AddTransferableResource(frame.get(), 777);
-        SetFrameData(frame.Pass());
+        SetFrameData(std::move(frame));
 
         resource_collection_->TakeUnusedResourcesForChildCompositor(&resources);
         {
           unsigned expected[] = {555, 999};
           EXPECT_RESOURCES(expected, resources);
           EXPECT_TRUE(TestAndResetAvailable());
           resources.clear();
         }
 
         // Destroy the frame provider.
@@ skipping 34 matching lines @@
       : drew_with_pending_tree_(false) {}
 
   void DidCommitAndDrawFrame() override {
     scoped_ptr<DelegatedFrameData> frame;
     switch (layer_tree_host()->source_frame_number()) {
       case 1:
         // This frame goes to the active tree.
         frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
         AddTextureQuad(frame.get(), 999);
         AddTransferableResource(frame.get(), 999);
-        SetFrameData(frame.Pass());
+        SetFrameData(std::move(frame));
         break;
       case 2:
         // This frame stops in the pending tree while we redraw the active tree.
         frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
         AddTextureQuad(frame.get(), 555);
         AddTransferableResource(frame.get(), 555);
-        SetFrameData(frame.Pass());
+        SetFrameData(std::move(frame));
         break;
     }
   }
 
   void DrawLayersOnThread(LayerTreeHostImpl* host_impl) override {
     if (host_impl->active_tree()->source_frame_number() < 1)
       return;
 
     LayerImpl* root_impl = host_impl->active_tree()->root_layer();
     FakeDelegatedRendererLayerImpl* delegated_impl =
@@ skipping 38 matching lines @@
   }
 
   bool drew_with_pending_tree_;
 };
 
 // This test blocks activation which is not supported for single thread mode.
 MULTI_THREAD_BLOCKNOTIFY_TEST_F(LayerTreeHostDelegatedTestActiveFrameIsValid);
 
 }  // namespace
 }  // namespace cc