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

This hits the following:
cc/layers/
cc/output/
cc/quads/
cc/resources/
cc/scheduler/
cc/surfaces/
cc/trees/

R=enne, vmpstr
BUG=557422
CQ_INCLUDE_TRYBOTS=tryserver.blink:linux_blink_rel

Review URL: https://codereview.chromium.org/1455023002

Cr-Commit-Position: refs/heads/master@{#360405}

cc/layers/delegated_frame_provider.cc

@@ -18,7 +18,7 @@ DelegatedFrameProvider::DelegatedFrameProvider(
   RenderPass* root_pass = frame->render_pass_list.back().get();
   frame_size_ = root_pass->output_rect.size();
   DCHECK(!frame_size_.IsEmpty());
-  SetFrameData(frame.Pass());
+  SetFrameData(std::move(frame));
 }
 
 DelegatedFrameProvider::~DelegatedFrameProvider() {
@@ -61,7 +61,7 @@ void DelegatedFrameProvider::SetFrameData(
     resource_collection_->UnrefResources(returned);
   }
 
-  frame_ = frame.Pass();
+  frame_ = std::move(frame);
 
   resource_collection_->ReceivedResources(frame_->resource_list);
   resource_collection_->RefResources(frame_->resource_list);

cc/layers/delegated_frame_provider_unittest.cc

@@ -32,8 +32,8 @@ class DelegatedFrameProviderTest
                       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;
   }
 
   void AddTransferableResource(DelegatedFrameData* frame,
@@ -84,7 +84,7 @@ class DelegatedFrameProviderTest
 
   void SetFrameProvider(scoped_ptr<DelegatedFrameData> frame_data) {
     frame_provider_ =
-        new DelegatedFrameProvider(resource_collection_, frame_data.Pass());
+        new DelegatedFrameProvider(resource_collection_, std::move(frame_data));
   }
 
   scoped_refptr<DelegatedFrameResourceCollection> resource_collection_;
@@ -99,12 +99,12 @@ TEST_F(DelegatedFrameProviderTest, SameResources) {
       CreateFrameData(gfx::Rect(1, 1), gfx::Rect(1, 1));
   AddTextureQuad(frame.get(), 444);
   AddTransferableResource(frame.get(), 444);
-  SetFrameProvider(frame.Pass());
+  SetFrameProvider(std::move(frame));
 
   frame = CreateFrameData(gfx::Rect(1, 1), gfx::Rect(1, 1));
   AddTextureQuad(frame.get(), 444);
   AddTransferableResource(frame.get(), 444);
-  SetFrameProvider(frame.Pass());
+  SetFrameProvider(std::move(frame));
 
   EXPECT_FALSE(ReturnAndResetResourcesAvailable());
   EXPECT_EQ(0u, resources_.size());
@@ -121,14 +121,14 @@ TEST_F(DelegatedFrameProviderTest, ReplaceResources) {
       CreateFrameData(gfx::Rect(1, 1), gfx::Rect(1, 1));
   AddTextureQuad(frame.get(), 444);
   AddTransferableResource(frame.get(), 444);
-  SetFrameProvider(frame.Pass());
+  SetFrameProvider(std::move(frame));
 
   EXPECT_FALSE(ReturnAndResetResourcesAvailable());
 
   frame = CreateFrameData(gfx::Rect(1, 1), gfx::Rect(1, 1));
   AddTextureQuad(frame.get(), 555);
   AddTransferableResource(frame.get(), 555);
-  SetFrameProvider(frame.Pass());
+  SetFrameProvider(std::move(frame));
 
   EXPECT_TRUE(ReturnAndResetResourcesAvailable());
   EXPECT_EQ(1u, resources_.size());
@@ -152,7 +152,7 @@ TEST_F(DelegatedFrameProviderTest, RefResources) {
   ReturnedResourceArray returned;
   TransferableResource::ReturnResources(reffed, &returned);
 
-  SetFrameProvider(frame.Pass());
+  SetFrameProvider(std::move(frame));
 
   scoped_refptr<DelegatedRendererLayer> observer1 =
       DelegatedRendererLayer::Create(layer_settings_, frame_provider_);
@@ -179,7 +179,7 @@ TEST_F(DelegatedFrameProviderTest, RefResources) {
   frame = CreateFrameData(gfx::Rect(5, 5), gfx::Rect(2, 2));
   AddTextureQuad(frame.get(), 555);
   AddTransferableResource(frame.get(), 555);
-  frame_provider_->SetFrameData(frame.Pass());
+  frame_provider_->SetFrameData(std::move(frame));
 
   // The resources from the first frame are still reffed by the observers.
   EXPECT_FALSE(ReturnAndResetResourcesAvailable());
@@ -210,7 +210,7 @@ TEST_F(DelegatedFrameProviderTest, RefResourcesInFrameProvider) {
   ReturnedResourceArray returned;
   TransferableResource::ReturnResources(reffed, &returned);
 
-  SetFrameProvider(frame.Pass());
+  SetFrameProvider(std::move(frame));
 
   scoped_refptr<DelegatedRendererLayer> observer1 =
       DelegatedRendererLayer::Create(layer_settings_, frame_provider_);
@@ -235,7 +235,7 @@ TEST_F(DelegatedFrameProviderTest, RefResourcesInFrameProvider) {
   frame = CreateFrameData(gfx::Rect(5, 5), gfx::Rect(2, 2));
   AddTextureQuad(frame.get(), 555);
   AddTransferableResource(frame.get(), 555);
-  frame_provider_->SetFrameData(frame.Pass());
+  frame_provider_->SetFrameData(std::move(frame));
 
   EXPECT_TRUE(ReturnAndResetResourcesAvailable());
   EXPECT_EQ(1u, resources_.size());
@@ -252,7 +252,7 @@ TEST_F(DelegatedFrameProviderTest, RefResourcesInFrameProviderUntilDestroy) {
   ReturnedResourceArray returned;
   TransferableResource::ReturnResources(reffed, &returned);
 
-  SetFrameProvider(frame.Pass());
+  SetFrameProvider(std::move(frame));
 
   scoped_refptr<DelegatedRendererLayer> observer1 =
       DelegatedRendererLayer::Create(layer_settings_, frame_provider_);
@@ -296,7 +296,7 @@ TEST_F(DelegatedFrameProviderTest, Damage) {
   ReturnedResourceArray returned;
   TransferableResource::ReturnResources(reffed, &returned);
 
-  SetFrameProvider(frame.Pass());
+  SetFrameProvider(std::move(frame));
 
   scoped_refptr<DelegatedRendererLayer> observer1 =
       DelegatedRendererLayer::Create(layer_settings_, frame_provider_);
@@ -320,7 +320,7 @@ TEST_F(DelegatedFrameProviderTest, Damage) {
   frame = CreateFrameData(gfx::Rect(5, 5), gfx::Rect(2, 2));
   AddTextureQuad(frame.get(), 555);
   AddTransferableResource(frame.get(), 555);
-  frame_provider_->SetFrameData(frame.Pass());
+  frame_provider_->SetFrameData(std::move(frame));
 
   // Both observers get the damage for the new frame.
   frame_provider_->GetFrameDataAndRefResources(observer1.get(), &damage);
@@ -341,7 +341,7 @@ TEST_F(DelegatedFrameProviderTest, LostNothing) {
 
   TransferableResourceArray reffed = frame->resource_list;
 
-  SetFrameProvider(frame.Pass());
+  SetFrameProvider(std::move(frame));
 
   // There is nothing to lose.
   EXPECT_FALSE(ReturnAndResetResourcesAvailable());
@@ -356,14 +356,14 @@ TEST_F(DelegatedFrameProviderTest, LostSomething) {
   AddTextureQuad(frame.get(), 444);
   AddTransferableResource(frame.get(), 444);
 
-  SetFrameProvider(frame.Pass());
+  SetFrameProvider(std::move(frame));
 
   // Add a second reference on the resource.
   frame = CreateFrameData(gfx::Rect(5, 5), gfx::Rect(5, 5));
   AddTextureQuad(frame.get(), 444);
   AddTransferableResource(frame.get(), 444);
 
-  SetFrameProvider(frame.Pass());
+  SetFrameProvider(std::move(frame));
 
   // There is something to lose.
   EXPECT_FALSE(ReturnAndResetResourcesAvailable());
@@ -380,7 +380,7 @@ TEST_F(DelegatedFrameProviderTest, NothingReturnedAfterLoss) {
       CreateFrameData(gfx::Rect(1, 1), gfx::Rect(1, 1));
   AddTextureQuad(frame.get(), 444);
   AddTransferableResource(frame.get(), 444);
-  SetFrameProvider(frame.Pass());
+  SetFrameProvider(std::move(frame));
 
   EXPECT_FALSE(ReturnAndResetResourcesAvailable());
 

cc/layers/delegated_renderer_layer_impl.cc

@@ -175,12 +175,12 @@ void DelegatedRendererLayerImpl::SetRenderPasses(
     RenderPassList* render_passes_in_draw_order) {
   ClearRenderPasses();
 
-  for (size_t i = 0; i < render_passes_in_draw_order->size(); ++i) {
-    RenderPassList::iterator to_take =
-        render_passes_in_draw_order->begin() + i;
+  size_t i = 0;
+  for (auto& render_pass : *render_passes_in_draw_order) {
     render_passes_index_by_id_.insert(
-        RenderPassToIndexMap::value_type((*to_take)->id, i));
-    render_passes_in_draw_order_.push_back(to_take->Pass());
+        RenderPassToIndexMap::value_type(render_pass->id, i));
+    render_passes_in_draw_order_.push_back(std::move(render_pass));
+    ++i;
   }
 
   // Give back an empty array instead of nulls.
@@ -265,7 +265,7 @@ void DelegatedRendererLayerImpl::AppendContributingRenderPasses(
         render_passes_in_draw_order_[i]->Copy(output_render_pass_id);
     copy_pass->transform_to_root_target.ConcatTransform(
         delegated_frame_to_root_transform);
-    render_pass_sink->AppendRenderPass(copy_pass.Pass());
+    render_pass_sink->AppendRenderPass(std::move(copy_pass));
   }
 }
 

cc/layers/delegated_renderer_layer_impl_unittest.cc

@@ -118,13 +118,13 @@ class DelegatedRendererLayerImplTestSimple
 
     // Force the delegated RenderPasses to come before the RenderPass from
     // layer_after.
-    layer_after->AddChild(delegated_renderer_layer.Pass());
-    root_layer->AddChild(layer_after.Pass());
+    layer_after->AddChild(std::move(delegated_renderer_layer));
+    root_layer->AddChild(std::move(layer_after));
 
     // Get the RenderPass generated by layer_before to come before the delegated
     // RenderPasses.
-    root_layer->AddChild(layer_before.Pass());
-    host_impl_->active_tree()->SetRootLayer(root_layer.Pass());
+    root_layer->AddChild(std::move(layer_before));
+    host_impl_->active_tree()->SetRootLayer(std::move(root_layer));
   }
 
  protected:
@@ -174,9 +174,9 @@ TEST_F(DelegatedRendererLayerImplTest,
 
     fake_delegated_renderer_layer_impl = delegated_renderer_layer.get();
 
-    root_layer->AddChild(delegated_renderer_layer.Pass());
+    root_layer->AddChild(std::move(delegated_renderer_layer));
 
-    host_impl_->active_tree()->SetRootLayer(root_layer.Pass());
+    host_impl_->active_tree()->SetRootLayer(std::move(root_layer));
 
     LayerTreeHostImpl::FrameData frame;
     EXPECT_EQ(DRAW_SUCCESS, PrepareToDrawFrame(&frame));
@@ -253,9 +253,9 @@ TEST_F(DelegatedRendererLayerImplTest,
 
     fake_delegated_renderer_layer_impl = delegated_renderer_layer.get();
 
-    root_layer->AddChild(delegated_renderer_layer.Pass());
+    root_layer->AddChild(std::move(delegated_renderer_layer));
 
-    host_impl_->pending_tree()->SetRootLayer(root_layer.Pass());
+    host_impl_->pending_tree()->SetRootLayer(std::move(root_layer));
     host_impl_->ActivateSyncTree();
 
     LayerTreeHostImpl::FrameData frame;
@@ -740,8 +740,8 @@ class DelegatedRendererLayerImplTestTransform
     root_layer_ = root_layer.get();
     delegated_renderer_layer_ = delegated_renderer_layer.get();
 
-    root_layer->AddChild(delegated_renderer_layer.Pass());
-    host_impl_->active_tree()->SetRootLayer(root_layer.Pass());
+    root_layer->AddChild(std::move(delegated_renderer_layer));
+    host_impl_->active_tree()->SetRootLayer(std::move(root_layer));
   }
 
   void VerifyRenderPasses(
@@ -1169,14 +1169,14 @@ class DelegatedRendererLayerImplTestClip
       origin_layer->SetPosition(
           gfx::PointF(-clip_origin.x(), -clip_origin.y()));
 
-      origin_layer->AddChild(delegated_renderer_layer.Pass());
-      clip_layer->AddChild(origin_layer.Pass());
-      root_layer->AddChild(clip_layer.Pass());
+      origin_layer->AddChild(std::move(delegated_renderer_layer));
+      clip_layer->AddChild(std::move(origin_layer));
+      root_layer->AddChild(std::move(clip_layer));
     } else {
-      root_layer->AddChild(delegated_renderer_layer.Pass());
+      root_layer->AddChild(std::move(delegated_renderer_layer));
     }
 
-    host_impl_->active_tree()->SetRootLayer(root_layer.Pass());
+    host_impl_->active_tree()->SetRootLayer(std::move(root_layer));
   }
 
  protected:

cc/layers/delegated_renderer_layer_unittest.cc

@@ -43,9 +43,9 @@ class DelegatedRendererLayerTestSimple : public DelegatedRendererLayerTest {
     root_pass->SetNew(
         RenderPassId(1, 1), gfx::Rect(1, 1), gfx::Rect(1, 1), gfx::Transform());
     scoped_ptr<DelegatedFrameData> frame_data(new DelegatedFrameData);
-    frame_data->render_pass_list.push_back(root_pass.Pass());
+    frame_data->render_pass_list.push_back(std::move(root_pass));
     resources_ = new DelegatedFrameResourceCollection;
-    provider_ = new DelegatedFrameProvider(resources_, frame_data.Pass());
+    provider_ = new DelegatedFrameProvider(resources_, std::move(frame_data));
     LayerSettings layer_settings;
     root_layer_ = SolidColorLayer::Create(layer_settings);
     layer_before_ = SolidColorLayer::Create(layer_settings);

cc/layers/heads_up_display_layer_impl.cc

@@ -103,7 +103,7 @@ void HeadsUpDisplayLayerImpl::AcquireResource(
   resource->Allocate(internal_content_bounds_,
                      ResourceProvider::TEXTURE_HINT_IMMUTABLE,
                      resource_provider->best_texture_format());
-  resources_.push_back(resource.Pass());
+  resources_.push_back(std::move(resource));
 }
 
 void HeadsUpDisplayLayerImpl::ReleaseUnmatchedSizeResources(

cc/layers/layer.cc

@@ -422,7 +422,7 @@ void Layer::RequestCopyOfOutput(
   }
   if (request->IsEmpty())
     return;
-  copy_requests_.push_back(request.Pass());
+  copy_requests_.push_back(std::move(request));
   if (had_no_copy_requests) {
     UpdateNumCopyRequestsForSubtree(1);
   }
@@ -1161,7 +1161,7 @@ void Layer::SetPositionConstraint(const LayerPositionConstraint& constraint) {
 
 static void RunCopyCallbackOnMainThread(scoped_ptr<CopyOutputRequest> request,
                                         scoped_ptr<CopyOutputResult> result) {
-  request->SendResult(result.Pass());
+  request->SendResult(std::move(result));
 }
 
 static void PostCopyCallbackToMainThread(
@@ -1309,7 +1309,7 @@ void Layer::PushPropertiesTo(LayerImpl* layer) {
             base::Bind(&PostCopyCallbackToMainThread,
                        main_thread_task_runner,
                        base::Passed(&original_request)));
-    main_thread_copy_requests.push_back(main_thread_request.Pass());
+    main_thread_copy_requests.push_back(std::move(main_thread_request));
   }
   if (!copy_requests_.empty() && layer_tree_host_)
     layer_tree_host_->property_trees()->needs_rebuild = true;
@@ -1659,7 +1659,7 @@ bool Layer::AddAnimation(scoped_ptr <Animation> animation) {
 
   UMA_HISTOGRAM_BOOLEAN("Renderer.AnimationAddedToOrphanLayer",
                         !layer_tree_host_);
-  layer_animation_controller_->AddAnimation(animation.Pass());
+  layer_animation_controller_->AddAnimation(std::move(animation));
   SetNeedsCommit();
   return true;
 }

cc/layers/layer_impl.cc

@@ -127,7 +127,7 @@ LayerImpl::~LayerImpl() {
 void LayerImpl::AddChild(scoped_ptr<LayerImpl> child) {
   child->SetParent(this);
   DCHECK_EQ(layer_tree_impl(), child->layer_tree_impl());
-  children_.push_back(child.Pass());
+  children_.push_back(std::move(child));
   layer_tree_impl()->set_needs_update_draw_properties();
 }
 
@@ -1023,7 +1023,7 @@ void LayerImpl::SetMaskLayer(scoped_ptr<LayerImpl> mask_layer) {
     return;
   }
 
-  mask_layer_ = mask_layer.Pass();
+  mask_layer_ = std::move(mask_layer);
   mask_layer_id_ = new_layer_id;
   if (mask_layer_)
     mask_layer_->SetParent(this);
@@ -1032,7 +1032,7 @@ void LayerImpl::SetMaskLayer(scoped_ptr<LayerImpl> mask_layer) {
 
 scoped_ptr<LayerImpl> LayerImpl::TakeMaskLayer() {
   mask_layer_id_ = -1;
-  return mask_layer_.Pass();
+  return std::move(mask_layer_);
 }
 
 void LayerImpl::SetReplicaLayer(scoped_ptr<LayerImpl> replica_layer) {
@@ -1045,7 +1045,7 @@ void LayerImpl::SetReplicaLayer(scoped_ptr<LayerImpl> replica_layer) {
     return;
   }
 
-  replica_layer_ = replica_layer.Pass();
+  replica_layer_ = std::move(replica_layer);
   replica_layer_id_ = new_layer_id;
   if (replica_layer_)
     replica_layer_->SetParent(this);
@@ -1054,7 +1054,7 @@ void LayerImpl::SetReplicaLayer(scoped_ptr<LayerImpl> replica_layer) {
 
 scoped_ptr<LayerImpl> LayerImpl::TakeReplicaLayer() {
   replica_layer_id_ = -1;
-  return replica_layer_.Pass();
+  return std::move(replica_layer_);
 }
 
 ScrollbarLayerImplBase* LayerImpl::ToScrollbarLayer() {

cc/layers/layer_impl_unittest.cc

@@ -99,7 +99,7 @@ TEST(LayerImplTest, VerifyLayerChangesAreTrackedProperly) {
   scoped_ptr<LayerImpl> root_ptr =
       LayerImpl::Create(host_impl.active_tree(), 2);
   LayerImpl* root = root_ptr.get();
-  root_clip->AddChild(root_ptr.Pass());
+  root_clip->AddChild(std::move(root_ptr));
   scoped_ptr<LayerImpl> scroll_parent =
       LayerImpl::Create(host_impl.active_tree(), 3);
   LayerImpl* scroll_child = LayerImpl::Create(host_impl.active_tree(), 4).get();
@@ -261,7 +261,7 @@ TEST(LayerImplTest, VerifyNeedsUpdateDrawProperties) {
   scoped_ptr<LayerImpl> layer_ptr =
       LayerImpl::Create(host_impl.active_tree(), 2);
   LayerImpl* layer = layer_ptr.get();
-  root->AddChild(layer_ptr.Pass());
+  root->AddChild(std::move(layer_ptr));
   layer->SetScrollClipLayer(root->id());
   host_impl.active_tree()->BuildPropertyTreesForTesting();
   DCHECK(host_impl.CanDraw());