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

cc/surfaces/surface_aggregator_unittest.cc

 // Copyright 2014 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/output/compositor_frame.h"
 #include "cc/output/delegated_frame_data.h"
 #include "cc/quads/render_pass.h"
 #include "cc/quads/render_pass_draw_quad.h"
 #include "cc/quads/solid_color_draw_quad.h"
 #include "cc/quads/surface_draw_quad.h"
@@ skipping 139 matching lines @@
           aggregator_.previous_contained_surfaces().find(surface_ids[i]) !=
           aggregator_.previous_contained_surfaces().end());
     }
   }
 
   void SubmitPassListAsFrame(SurfaceId surface_id, RenderPassList* pass_list) {
     scoped_ptr<DelegatedFrameData> frame_data(new DelegatedFrameData);
     pass_list->swap(frame_data->render_pass_list);
 
     scoped_ptr<CompositorFrame> frame(new CompositorFrame);
-    frame->delegated_frame_data = frame_data.Pass();
+    frame->delegated_frame_data = std::move(frame_data);
 
-    factory_.SubmitCompositorFrame(surface_id, frame.Pass(),
+    factory_.SubmitCompositorFrame(surface_id, std::move(frame),
                                    SurfaceFactory::DrawCallback());
   }
 
   void SubmitCompositorFrame(test::Pass* passes,
                              size_t pass_count,
                              SurfaceId surface_id) {
     RenderPassList pass_list;
     AddPasses(&pass_list, gfx::Rect(SurfaceSize()), passes, pass_count);
     SubmitPassListAsFrame(surface_id, &pass_list);
   }
 
   void QueuePassAsFrame(scoped_ptr<RenderPass> pass, SurfaceId surface_id) {
     scoped_ptr<DelegatedFrameData> delegated_frame_data(new DelegatedFrameData);
-    delegated_frame_data->render_pass_list.push_back(pass.Pass());
+    delegated_frame_data->render_pass_list.push_back(std::move(pass));
 
     scoped_ptr<CompositorFrame> child_frame(new CompositorFrame);
-    child_frame->delegated_frame_data = delegated_frame_data.Pass();
+    child_frame->delegated_frame_data = std::move(delegated_frame_data);
 
-    factory_.SubmitCompositorFrame(surface_id, child_frame.Pass(),
+    factory_.SubmitCompositorFrame(surface_id, std::move(child_frame),
                                    SurfaceFactory::DrawCallback());
   }
 
  protected:
   SurfaceId root_surface_id_;
   Surface* root_surface_;
   SurfaceIdAllocator allocator_;
   SurfaceIdAllocator child_allocator_;
 };
 
@@ skipping 130 matching lines @@
 
   test::Quad embedded_quads[] = {test::Quad::SolidColorQuad(SK_ColorGREEN)};
   test::Pass embedded_passes[] = {
       test::Pass(embedded_quads, arraysize(embedded_quads))};
 
   SubmitCompositorFrame(embedded_passes, arraysize(embedded_passes),
                         embedded_surface_id);
   scoped_ptr<CopyOutputRequest> copy_request(
       CopyOutputRequest::CreateEmptyRequest());
   CopyOutputRequest* copy_request_ptr = copy_request.get();
-  factory_.RequestCopyOfSurface(embedded_surface_id, copy_request.Pass());
+  factory_.RequestCopyOfSurface(embedded_surface_id, std::move(copy_request));
 
   test::Quad root_quads[] = {test::Quad::SolidColorQuad(SK_ColorWHITE),
                              test::Quad::SurfaceQuad(embedded_surface_id, 1.f),
                              test::Quad::SolidColorQuad(SK_ColorBLACK)};
   test::Pass root_passes[] = {test::Pass(root_quads, arraysize(root_quads))};
 
   SubmitCompositorFrame(root_passes, arraysize(root_passes), root_surface_id_);
 
   EXPECT_FALSE(surface_aggregator_client_.HasSurface(root_surface_));
   EXPECT_FALSE(surface_aggregator_client_.HasSurface(embedded_surface));
@@ skipping 62 matching lines @@
   test::Quad root_quads2[] = {test::Quad::SolidColorQuad(SK_ColorRED)};
   test::Pass root_passes[] = {
       test::Pass(root_quads, arraysize(root_quads), RenderPassId(1, 1)),
       test::Pass(root_quads2, arraysize(root_quads2), RenderPassId(1, 2))};
   {
     RenderPassList pass_list;
     AddPasses(&pass_list,
               gfx::Rect(SurfaceSize()),
               root_passes,
               arraysize(root_passes));
-    pass_list[0]->copy_requests.push_back(copy_request.Pass());
-    pass_list[1]->copy_requests.push_back(copy_request2.Pass());
+    pass_list[0]->copy_requests.push_back(std::move(copy_request));
+    pass_list[1]->copy_requests.push_back(std::move(copy_request2));
 
     scoped_ptr<DelegatedFrameData> frame_data(new DelegatedFrameData);
     pass_list.swap(frame_data->render_pass_list);
 
     scoped_ptr<CompositorFrame> frame(new CompositorFrame);
-    frame->delegated_frame_data = frame_data.Pass();
+    frame->delegated_frame_data = std::move(frame_data);
 
-    factory_.SubmitCompositorFrame(root_surface_id_, frame.Pass(),
+    factory_.SubmitCompositorFrame(root_surface_id_, std::move(frame),
                                    SurfaceFactory::DrawCallback());
   }
 
   EXPECT_FALSE(surface_aggregator_client_.HasSurface(root_surface_));
   EXPECT_FALSE(surface_aggregator_client_.HasSurface(embedded_surface));
 
   scoped_ptr<CompositorFrame> aggregated_frame =
       aggregator_.Aggregate(root_surface_id_);
 
   EXPECT_TRUE(surface_aggregator_client_.HasSurface(root_surface_));
@@ skipping 445 matching lines @@
   Surface* grandchild_surface = manager_.GetSurfaceForId(grandchild_surface_id);
   EXPECT_FALSE(surface_aggregator_client_.HasSurface(grandchild_surface));
   scoped_ptr<RenderPass> grandchild_pass = RenderPass::Create();
   gfx::Rect output_rect(SurfaceSize());
   gfx::Rect damage_rect(SurfaceSize());
   gfx::Transform transform_to_root_target;
   grandchild_pass->SetNew(
       pass_id, output_rect, damage_rect, transform_to_root_target);
   AddSolidColorQuadWithBlendMode(
       SurfaceSize(), grandchild_pass.get(), blend_modes[2]);
-  QueuePassAsFrame(grandchild_pass.Pass(), grandchild_surface_id);
+  QueuePassAsFrame(std::move(grandchild_pass), grandchild_surface_id);
 
   SurfaceId child_one_surface_id = allocator_.GenerateId();
   factory_.Create(child_one_surface_id);
   Surface* child_one_surface = manager_.GetSurfaceForId(child_one_surface_id);
   EXPECT_FALSE(surface_aggregator_client_.HasSurface(child_one_surface));
 
   scoped_ptr<RenderPass> child_one_pass = RenderPass::Create();
   child_one_pass->SetNew(
       pass_id, output_rect, damage_rect, transform_to_root_target);
   AddSolidColorQuadWithBlendMode(
       SurfaceSize(), child_one_pass.get(), blend_modes[1]);
   SurfaceDrawQuad* grandchild_surface_quad =
       child_one_pass->CreateAndAppendDrawQuad<SurfaceDrawQuad>();
   grandchild_surface_quad->SetNew(child_one_pass->shared_quad_state_list.back(),
                                   gfx::Rect(SurfaceSize()),
                                   gfx::Rect(SurfaceSize()),
                                   grandchild_surface_id);
   AddSolidColorQuadWithBlendMode(
       SurfaceSize(), child_one_pass.get(), blend_modes[3]);
-  QueuePassAsFrame(child_one_pass.Pass(), child_one_surface_id);
+  QueuePassAsFrame(std::move(child_one_pass), child_one_surface_id);
 
   SurfaceId child_two_surface_id = allocator_.GenerateId();
   factory_.Create(child_two_surface_id);
   Surface* child_two_surface = manager_.GetSurfaceForId(child_two_surface_id);
   EXPECT_FALSE(surface_aggregator_client_.HasSurface(child_two_surface));
 
   scoped_ptr<RenderPass> child_two_pass = RenderPass::Create();
   child_two_pass->SetNew(
       pass_id, output_rect, damage_rect, transform_to_root_target);
   AddSolidColorQuadWithBlendMode(
       SurfaceSize(), child_two_pass.get(), blend_modes[5]);
-  QueuePassAsFrame(child_two_pass.Pass(), child_two_surface_id);
+  QueuePassAsFrame(std::move(child_two_pass), child_two_surface_id);
 
   scoped_ptr<RenderPass> root_pass = RenderPass::Create();
   root_pass->SetNew(
       pass_id, output_rect, damage_rect, transform_to_root_target);
 
   AddSolidColorQuadWithBlendMode(
       SurfaceSize(), root_pass.get(), blend_modes[0]);
   SurfaceDrawQuad* child_one_surface_quad =
       root_pass->CreateAndAppendDrawQuad<SurfaceDrawQuad>();
   child_one_surface_quad->SetNew(root_pass->shared_quad_state_list.back(),
                                  gfx::Rect(SurfaceSize()),
                                  gfx::Rect(SurfaceSize()),
                                  child_one_surface_id);
   AddSolidColorQuadWithBlendMode(
       SurfaceSize(), root_pass.get(), blend_modes[4]);
   SurfaceDrawQuad* child_two_surface_quad =
       root_pass->CreateAndAppendDrawQuad<SurfaceDrawQuad>();
   child_two_surface_quad->SetNew(root_pass->shared_quad_state_list.back(),
                                  gfx::Rect(SurfaceSize()),
                                  gfx::Rect(SurfaceSize()),
                                  child_two_surface_id);
   AddSolidColorQuadWithBlendMode(
       SurfaceSize(), root_pass.get(), blend_modes[6]);
 
-  QueuePassAsFrame(root_pass.Pass(), root_surface_id_);
+  QueuePassAsFrame(std::move(root_pass), root_surface_id_);
 
   EXPECT_FALSE(surface_aggregator_client_.HasSurface(root_surface_));
   EXPECT_FALSE(surface_aggregator_client_.HasSurface(grandchild_surface));
   EXPECT_FALSE(surface_aggregator_client_.HasSurface(child_one_surface));
   EXPECT_FALSE(surface_aggregator_client_.HasSurface(child_two_surface));
 
   scoped_ptr<CompositorFrame> aggregated_frame =
       aggregator_.Aggregate(root_surface_id_);
 
   EXPECT_TRUE(surface_aggregator_client_.HasSurface(root_surface_));
@@ skipping 74 matching lines @@
     SharedQuadState* child_root_pass_sqs =
         child_root_pass->shared_quad_state_list.front();
     child_root_pass_sqs->quad_to_target_transform.Translate(8, 0);
     child_root_pass_sqs->is_clipped = true;
     child_root_pass_sqs->clip_rect = gfx::Rect(0, 0, 5, 5);
 
     scoped_ptr<DelegatedFrameData> child_frame_data(new DelegatedFrameData);
     child_pass_list.swap(child_frame_data->render_pass_list);
 
     scoped_ptr<CompositorFrame> child_frame(new CompositorFrame);
-    child_frame->delegated_frame_data = child_frame_data.Pass();
+    child_frame->delegated_frame_data = std::move(child_frame_data);
 
-    factory_.SubmitCompositorFrame(child_surface_id, child_frame.Pass(),
+    factory_.SubmitCompositorFrame(child_surface_id, std::move(child_frame),
                                    SurfaceFactory::DrawCallback());
   }
 
   // Middle child surface.
   SurfaceId middle_surface_id = allocator_.GenerateId();
   factory_.Create(middle_surface_id);
   Surface* middle_surface = manager_.GetSurfaceForId(middle_surface_id);
   EXPECT_FALSE(surface_aggregator_client_.HasSurface(middle_surface));
   {
     test::Quad middle_quads[] = {
@@ skipping 10 matching lines @@
     middle_root_pass->quad_list.ElementAt(0)->visible_rect =
         gfx::Rect(0, 1, 100, 7);
     SharedQuadState* middle_root_pass_sqs =
         middle_root_pass->shared_quad_state_list.front();
     middle_root_pass_sqs->quad_to_target_transform.Scale(2, 3);
 
     scoped_ptr<DelegatedFrameData> middle_frame_data(new DelegatedFrameData);
     middle_pass_list.swap(middle_frame_data->render_pass_list);
 
     scoped_ptr<CompositorFrame> middle_frame(new CompositorFrame);
-    middle_frame->delegated_frame_data = middle_frame_data.Pass();
+    middle_frame->delegated_frame_data = std::move(middle_frame_data);
 
-    factory_.SubmitCompositorFrame(middle_surface_id, middle_frame.Pass(),
+    factory_.SubmitCompositorFrame(middle_surface_id, std::move(middle_frame),
                                    SurfaceFactory::DrawCallback());
   }
 
   // Root surface.
   test::Quad secondary_quads[] = {
       test::Quad::SolidColorQuad(1),
       test::Quad::SurfaceQuad(middle_surface_id, 1.f)};
   test::Quad root_quads[] = {test::Quad::SolidColorQuad(1)};
   test::Pass root_passes[] = {
       test::Pass(secondary_quads, arraysize(secondary_quads)),
@@ skipping 13 matching lines @@
       ->quad_to_target_transform.Translate(0, 10);
   root_pass_list[0]->quad_list.ElementAt(1)->visible_rect =
       gfx::Rect(0, 0, 8, 100);
 
   root_pass_list[0]->transform_to_root_target.Translate(10, 5);
 
   scoped_ptr<DelegatedFrameData> root_frame_data(new DelegatedFrameData);
   root_pass_list.swap(root_frame_data->render_pass_list);
 
   scoped_ptr<CompositorFrame> root_frame(new CompositorFrame);
-  root_frame->delegated_frame_data = root_frame_data.Pass();
+  root_frame->delegated_frame_data = std::move(root_frame_data);
 
-  factory_.SubmitCompositorFrame(root_surface_id_, root_frame.Pass(),
+  factory_.SubmitCompositorFrame(root_surface_id_, std::move(root_frame),
                                  SurfaceFactory::DrawCallback());
 
   EXPECT_FALSE(surface_aggregator_client_.HasSurface(root_surface_));
   EXPECT_FALSE(surface_aggregator_client_.HasSurface(child_surface));
   EXPECT_FALSE(surface_aggregator_client_.HasSurface(middle_surface));
 
   scoped_ptr<CompositorFrame> aggregated_frame =
       aggregator_.Aggregate(root_surface_id_);
 
   EXPECT_TRUE(surface_aggregator_client_.HasSurface(root_surface_));
@@ skipping 92 matching lines @@
 
   RenderPass* child_root_pass = child_pass_list[0].get();
   SharedQuadState* child_root_pass_sqs =
       child_root_pass->shared_quad_state_list.front();
   child_root_pass_sqs->quad_to_target_transform.Translate(8, 0);
 
   scoped_ptr<DelegatedFrameData> child_frame_data(new DelegatedFrameData);
   child_pass_list.swap(child_frame_data->render_pass_list);
 
   scoped_ptr<CompositorFrame> child_frame(new CompositorFrame);
-  child_frame->delegated_frame_data = child_frame_data.Pass();
+  child_frame->delegated_frame_data = std::move(child_frame_data);
 
   SurfaceId child_surface_id = allocator_.GenerateId();
   factory_.Create(child_surface_id);
   Surface* child_surface = manager_.GetSurfaceForId(child_surface_id);
-  factory_.SubmitCompositorFrame(child_surface_id, child_frame.Pass(),
+  factory_.SubmitCompositorFrame(child_surface_id, std::move(child_frame),
                                  SurfaceFactory::DrawCallback());
 
   test::Quad parent_surface_quads[] = {
       test::Quad::SurfaceQuad(child_surface_id, 1.f)};
   test::Pass parent_surface_passes[] = {
       test::Pass(parent_surface_quads, arraysize(parent_surface_quads),
                  RenderPassId(1, 1))};
 
   RenderPassList parent_surface_pass_list;
   AddPasses(&parent_surface_pass_list,
             gfx::Rect(SurfaceSize()),
             parent_surface_passes,
             arraysize(parent_surface_passes));
 
   // Parent surface is only used to test if the transform is applied correctly
   // to the child surface's damage.
   scoped_ptr<DelegatedFrameData> parent_surface_frame_data(
       new DelegatedFrameData);
   parent_surface_pass_list.swap(parent_surface_frame_data->render_pass_list);
 
   scoped_ptr<CompositorFrame> parent_surface_frame(new CompositorFrame);
-  parent_surface_frame->delegated_frame_data = parent_surface_frame_data.Pass();
+  parent_surface_frame->delegated_frame_data =
+      std::move(parent_surface_frame_data);
 
   SurfaceId parent_surface_id = allocator_.GenerateId();
   factory_.Create(parent_surface_id);
   Surface* parent_surface = manager_.GetSurfaceForId(parent_surface_id);
-  factory_.SubmitCompositorFrame(parent_surface_id, parent_surface_frame.Pass(),
+  factory_.SubmitCompositorFrame(parent_surface_id,
+                                 std::move(parent_surface_frame),
                                  SurfaceFactory::DrawCallback());
 
   test::Quad root_surface_quads[] = {
       test::Quad::SurfaceQuad(parent_surface_id, 1.f)};
   test::Quad root_render_pass_quads[] = {
       test::Quad::RenderPassQuad(RenderPassId(1, 1))};
 
   test::Pass root_passes[] = {
       test::Pass(root_surface_quads, arraysize(root_surface_quads),
                  RenderPassId(1, 1)),
       test::Pass(root_render_pass_quads, arraysize(root_render_pass_quads),
                  RenderPassId(2, 1))};
 
   RenderPassList root_pass_list;
   AddPasses(&root_pass_list,
             gfx::Rect(SurfaceSize()),
             root_passes,
             arraysize(root_passes));
 
   root_pass_list[0]
       ->shared_quad_state_list.front()
       ->quad_to_target_transform.Translate(0, 10);
   root_pass_list[0]->damage_rect = gfx::Rect(5, 5, 10, 10);
   root_pass_list[1]->damage_rect = gfx::Rect(5, 5, 100, 100);
 
   scoped_ptr<DelegatedFrameData> root_frame_data(new DelegatedFrameData);
   root_pass_list.swap(root_frame_data->render_pass_list);
 
   scoped_ptr<CompositorFrame> root_frame(new CompositorFrame);
-  root_frame->delegated_frame_data = root_frame_data.Pass();
+  root_frame->delegated_frame_data = std::move(root_frame_data);
 
-  factory_.SubmitCompositorFrame(root_surface_id_, root_frame.Pass(),
+  factory_.SubmitCompositorFrame(root_surface_id_, std::move(root_frame),
                                  SurfaceFactory::DrawCallback());
 
   EXPECT_FALSE(surface_aggregator_client_.HasSurface(root_surface_));
   EXPECT_FALSE(surface_aggregator_client_.HasSurface(child_surface));
   EXPECT_FALSE(surface_aggregator_client_.HasSurface(parent_surface));
 
   scoped_ptr<CompositorFrame> aggregated_frame =
       aggregator_.Aggregate(root_surface_id_);
 
   EXPECT_TRUE(surface_aggregator_client_.HasSurface(root_surface_));
@@ skipping 22 matching lines @@
     RenderPass* child_root_pass = child_pass_list[0].get();
     SharedQuadState* child_root_pass_sqs =
         child_root_pass->shared_quad_state_list.front();
     child_root_pass_sqs->quad_to_target_transform.Translate(8, 0);
     child_root_pass->damage_rect = gfx::Rect(10, 10, 10, 10);
 
     scoped_ptr<DelegatedFrameData> child_frame_data(new DelegatedFrameData);
     child_pass_list.swap(child_frame_data->render_pass_list);
 
     scoped_ptr<CompositorFrame> child_frame(new CompositorFrame);
-    child_frame->delegated_frame_data = child_frame_data.Pass();
+    child_frame->delegated_frame_data = std::move(child_frame_data);
 
-    factory_.SubmitCompositorFrame(child_surface_id, child_frame.Pass(),
+    factory_.SubmitCompositorFrame(child_surface_id, std::move(child_frame),
                                    SurfaceFactory::DrawCallback());
 
     EXPECT_TRUE(surface_aggregator_client_.HasSurface(root_surface_));
     EXPECT_TRUE(surface_aggregator_client_.HasSurface(child_surface));
     EXPECT_TRUE(surface_aggregator_client_.HasSurface(parent_surface));
 
     scoped_ptr<CompositorFrame> aggregated_frame =
         aggregator_.Aggregate(root_surface_id_);
 
     EXPECT_TRUE(surface_aggregator_client_.HasSurface(root_surface_));
@@ skipping 25 matching lines @@
 
     root_pass_list[0]
         ->shared_quad_state_list.front()
         ->quad_to_target_transform.Translate(0, 10);
     root_pass_list[0]->damage_rect = gfx::Rect(0, 0, 1, 1);
 
     scoped_ptr<DelegatedFrameData> root_frame_data(new DelegatedFrameData);
     root_pass_list.swap(root_frame_data->render_pass_list);
 
     scoped_ptr<CompositorFrame> root_frame(new CompositorFrame);
-    root_frame->delegated_frame_data = root_frame_data.Pass();
+    root_frame->delegated_frame_data = std::move(root_frame_data);
 
-    factory_.SubmitCompositorFrame(root_surface_id_, root_frame.Pass(),
+    factory_.SubmitCompositorFrame(root_surface_id_, std::move(root_frame),
                                    SurfaceFactory::DrawCallback());
   }
 
   {
     RenderPassList root_pass_list;
     AddPasses(&root_pass_list,
               gfx::Rect(SurfaceSize()),
               root_passes,
               arraysize(root_passes));
 
     root_pass_list[0]
         ->shared_quad_state_list.front()
         ->quad_to_target_transform.Translate(0, 10);
     root_pass_list[0]->damage_rect = gfx::Rect(1, 1, 1, 1);
 
     scoped_ptr<DelegatedFrameData> root_frame_data(new DelegatedFrameData);
     root_pass_list.swap(root_frame_data->render_pass_list);
 
     scoped_ptr<CompositorFrame> root_frame(new CompositorFrame);
-    root_frame->delegated_frame_data = root_frame_data.Pass();
+    root_frame->delegated_frame_data = std::move(root_frame_data);
 
-    factory_.SubmitCompositorFrame(root_surface_id_, root_frame.Pass(),
+    factory_.SubmitCompositorFrame(root_surface_id_, std::move(root_frame),
                                    SurfaceFactory::DrawCallback());
 
     EXPECT_TRUE(surface_aggregator_client_.HasSurface(root_surface_));
     EXPECT_TRUE(surface_aggregator_client_.HasSurface(child_surface));
     EXPECT_TRUE(surface_aggregator_client_.HasSurface(parent_surface));
 
     scoped_ptr<CompositorFrame> aggregated_frame =
         aggregator_.Aggregate(root_surface_id_);
 
     EXPECT_TRUE(surface_aggregator_client_.HasSurface(root_surface_));
@@ skipping 371 matching lines @@
     const gfx::PointF uv_bottom_right;
     SkColor background_color = SK_ColorGREEN;
     const float vertex_opacity[4] = {0.f, 0.f, 1.f, 1.f};
     bool flipped = false;
     bool nearest_neighbor = false;
     quad->SetAll(sqs, rect, opaque_rect, visible_rect, needs_blending,
                  resource_ids[i], gfx::Size(), premultiplied_alpha, uv_top_left,
                  uv_bottom_right, background_color, vertex_opacity, flipped,
                  nearest_neighbor);
   }
-  frame_data->render_pass_list.push_back(pass.Pass());
+  frame_data->render_pass_list.push_back(std::move(pass));
   scoped_ptr<CompositorFrame> frame(new CompositorFrame);
-  frame->delegated_frame_data = frame_data.Pass();
-  factory->SubmitCompositorFrame(surface_id, frame.Pass(),
+  frame->delegated_frame_data = std::move(frame_data);
+  factory->SubmitCompositorFrame(surface_id, std::move(frame),
                                  SurfaceFactory::DrawCallback());
 }
 
 TEST_F(SurfaceAggregatorWithResourcesTest, TakeResourcesOneSurface) {
   ResourceTrackingSurfaceFactoryClient client;
   SurfaceFactory factory(&manager_, &client);
   SurfaceId surface_id(7u);
   factory.Create(surface_id);
   Surface* surface = manager_.GetSurfaceForId(surface_id);
 
@@ skipping 38 matching lines @@
 
   scoped_ptr<DelegatedFrameData> frame_data(new DelegatedFrameData);
   scoped_ptr<RenderPass> pass = RenderPass::Create();
   pass->id = RenderPassId(1, 1);
   TransferableResource resource;
   resource.id = 11;
   // ResourceProvider is software but resource is not, so it should be
   // ignored.
   resource.is_software = false;
   frame_data->resource_list.push_back(resource);
-  frame_data->render_pass_list.push_back(pass.Pass());
+  frame_data->render_pass_list.push_back(std::move(pass));
   scoped_ptr<CompositorFrame> frame(new CompositorFrame);
-  frame->delegated_frame_data = frame_data.Pass();
-  factory.SubmitCompositorFrame(surface_id, frame.Pass(),
+  frame->delegated_frame_data = std::move(frame_data);
+  factory.SubmitCompositorFrame(surface_id, std::move(frame),
                                 SurfaceFactory::DrawCallback());
 
   EXPECT_FALSE(surface_aggregator_client_.HasSurface(surface));
 
   scoped_ptr<CompositorFrame> returned_frame =
       aggregator_->Aggregate(surface_id);
 
   EXPECT_TRUE(surface_aggregator_client_.HasSurface(surface));
 
   // Nothing should be available to be returned yet.
@@ skipping 125 matching lines @@
   EXPECT_EQ(9u, pass_list->back()->quad_list.size());
 
   factory.Destroy(root_surface_id);
   factory.Destroy(child_surface_id);
   factory.Destroy(middle_surface_id);
 }
 
 }  // namespace
 }  // namespace cc