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

This hits the following:
cc/playback/
cc/raster/
cc/test/
cc/tiles/

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

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

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

9 files changed, 26 insertions, 24 deletions

diff --git a/cc/tiles/eviction_tile_priority_queue.cc b/cc/tiles/eviction_tile_priority_queue.cc
index 743c982..5668f0f 100644
--- a/cc/tiles/eviction_tile_priority_queue.cc
+++ b/cc/tiles/eviction_tile_priority_queue.cc
@@ -72,7 +72,7 @@ void CreateTilingSetEvictionQueues(
         new TilingSetEvictionQueue(layer->picture_layer_tiling_set()));
     // Queues will only contain non empty tiling sets.
     if (!tiling_set_queue->IsEmpty())
-      queues->push_back(tiling_set_queue.Pass());
+      queues->push_back(std::move(tiling_set_queue));
   }
   std::make_heap(queues->begin(), queues->end(),
                  EvictionOrderComparator(tree_priority));
diff --git a/cc/tiles/picture_layer_tiling.cc b/cc/tiles/picture_layer_tiling.cc
index 4cb66a5c..747dd94 100644
--- a/cc/tiles/picture_layer_tiling.cc
+++ b/cc/tiles/picture_layer_tiling.cc
@@ -115,7 +115,7 @@ Tile* PictureLayerTiling::CreateTile(const Tile::CreateInfo& info) {
   all_tiles_done_ = false;
   ScopedTilePtr tile = client_->CreateTile(info);
   Tile* raw_ptr = tile.get();
-  tiles_.add(key, tile.Pass());
+  tiles_.add(key, std::move(tile));
   return raw_ptr;
 }
 
diff --git a/cc/tiles/picture_layer_tiling_set.cc b/cc/tiles/picture_layer_tiling_set.cc
index 7e41bcf..77589c1 100644
--- a/cc/tiles/picture_layer_tiling_set.cc
+++ b/cc/tiles/picture_layer_tiling_set.cc
@@ -80,7 +80,7 @@ void PictureLayerTilingSet::CopyTilingsAndPropertiesFromPendingTwin(
           tree_, contents_scale, raster_source, client_,
           tiling_interest_area_padding_, skewport_target_time_in_seconds_,
           skewport_extrapolation_limit_in_content_pixels_);
-      tilings_.push_back(new_tiling.Pass());
+      tilings_.push_back(std::move(new_tiling));
       this_tiling = tilings_.back().get();
       tiling_sort_required = true;
     }
diff --git a/cc/tiles/raster_tile_priority_queue.cc b/cc/tiles/raster_tile_priority_queue.cc
index afa3755..0b47407 100644
--- a/cc/tiles/raster_tile_priority_queue.cc
+++ b/cc/tiles/raster_tile_priority_queue.cc
@@ -20,14 +20,14 @@ scoped_ptr<RasterTilePriorityQueue> RasterTilePriorityQueue::Create(
       scoped_ptr<RasterTilePriorityQueueAll> queue(
           new RasterTilePriorityQueueAll);
       queue->Build(active_layers, pending_layers, tree_priority);
-      return queue.Pass();
+      return std::move(queue);
     }
     case Type::REQUIRED_FOR_ACTIVATION:
     case Type::REQUIRED_FOR_DRAW: {
       scoped_ptr<RasterTilePriorityQueueRequired> queue(
           new RasterTilePriorityQueueRequired);
       queue->Build(active_layers, pending_layers, type);
-      return queue.Pass();
+      return std::move(queue);
     }
   }
   NOTREACHED();
diff --git a/cc/tiles/raster_tile_priority_queue_all.cc b/cc/tiles/raster_tile_priority_queue_all.cc
index beca4d5..09c5c78 100644
--- a/cc/tiles/raster_tile_priority_queue_all.cc
+++ b/cc/tiles/raster_tile_priority_queue_all.cc
@@ -64,7 +64,7 @@ void CreateTilingSetRasterQueues(
         new TilingSetRasterQueueAll(tiling_set, prioritize_low_res));
     // Queues will only contain non empty tiling sets.
     if (!tiling_set_queue->IsEmpty())
-      queues->push_back(tiling_set_queue.Pass());
+      queues->push_back(std::move(tiling_set_queue));
   }
   std::make_heap(queues->begin(), queues->end(),
                  RasterOrderComparator(tree_priority));
diff --git a/cc/tiles/raster_tile_priority_queue_required.cc b/cc/tiles/raster_tile_priority_queue_required.cc
index 5c5fd7e..24d9789 100644
--- a/cc/tiles/raster_tile_priority_queue_required.cc
+++ b/cc/tiles/raster_tile_priority_queue_required.cc
@@ -22,7 +22,7 @@ void AppendTilingSetRequiredQueues(
             layer->picture_layer_tiling_set(),
             RasterTilePriorityQueueRequired::Type::REQUIRED_FOR_ACTIVATION));
     if (!tiling_set_queue->IsEmpty())
-      queues->push_back(tiling_set_queue.Pass());
+      queues->push_back(std::move(tiling_set_queue));
   }
 }
 
@@ -55,7 +55,7 @@ void RasterTilePriorityQueueRequired::BuildRequiredForDraw(
         new TilingSetRasterQueueRequired(layer->picture_layer_tiling_set(),
                                          Type::REQUIRED_FOR_DRAW));
     if (!tiling_set_queue->IsEmpty())
-      tiling_set_queues_.push_back(tiling_set_queue.Pass());
+      tiling_set_queues_.push_back(std::move(tiling_set_queue));
   }
 }
 
diff --git a/cc/tiles/tile_manager.cc b/cc/tiles/tile_manager.cc
index 898b3e3..d7b91bfc 100644
--- a/cc/tiles/tile_manager.cc
+++ b/cc/tiles/tile_manager.cc
@@ -97,7 +97,7 @@ class RasterTaskImpl : public RasterTask {
         resource_, resource_content_id_, previous_content_id_);
   }
   void CompleteOnOriginThread(TileTaskClient* client) override {
-    client->ReleaseBufferForRaster(raster_buffer_.Pass());
+    client->ReleaseBufferForRaster(std::move(raster_buffer_));
     reply_.Run(analysis_, !HasFinishedRunning());
   }
 
@@ -545,7 +545,7 @@ void TileManager::AssignGpuMemoryToTiles(
         tile_memory_limit - memory_required_by_tile_to_be_scheduled;
     eviction_priority_queue =
         FreeTileResourcesWithLowerPriorityUntilUsageIsWithinLimit(
-            eviction_priority_queue.Pass(), scheduled_tile_memory_limit,
+            std::move(eviction_priority_queue), scheduled_tile_memory_limit,
             priority, &memory_usage);
     bool memory_usage_is_within_limit =
         !memory_usage.Exceeds(scheduled_tile_memory_limit);
@@ -567,7 +567,7 @@ void TileManager::AssignGpuMemoryToTiles(
   // didn't reduce memory. This ensures that we always release as many resources
   // as possible to stay within the memory limit.
   eviction_priority_queue = FreeTileResourcesUntilUsageIsWithinLimit(
-      eviction_priority_queue.Pass(), hard_memory_limit, &memory_usage);
+      std::move(eviction_priority_queue), hard_memory_limit, &memory_usage);
 
   UMA_HISTOGRAM_BOOLEAN("TileManager.ExceededMemoryBudget",
                         !had_enough_memory_to_schedule_tiles_needed_now);
diff --git a/cc/tiles/tile_manager_perftest.cc b/cc/tiles/tile_manager_perftest.cc
index 6e7bed3..9bc3c18 100644
--- a/cc/tiles/tile_manager_perftest.cc
+++ b/cc/tiles/tile_manager_perftest.cc
@@ -172,7 +172,7 @@ class TileManagerPerfTest : public testing::Test {
                                                      raster_source);
     pending_layer->SetDrawsContent(true);
     pending_layer->SetHasRenderSurface(true);
-    pending_tree->SetRootLayer(pending_layer.Pass());
+    pending_tree->SetRootLayer(std::move(pending_layer));
 
     pending_root_layer_ = static_cast<FakePictureLayerImpl*>(
         host_impl_.pending_tree()->LayerById(id_));
@@ -360,7 +360,7 @@ class TileManagerPerfTest : public testing::Test {
       layer->SetBounds(layer_bounds);
       layer->SetDrawsContent(true);
       layers.push_back(layer.get());
-      pending_root_layer_->AddChild(layer.Pass());
+      pending_root_layer_->AddChild(std::move(layer));
       ++next_id;
     }
 
diff --git a/cc/tiles/tile_manager_unittest.cc b/cc/tiles/tile_manager_unittest.cc
index 347aa6d..5ca49b6 100644
--- a/cc/tiles/tile_manager_unittest.cc
+++ b/cc/tiles/tile_manager_unittest.cc
@@ -140,7 +140,7 @@ class TileManagerTilePriorityQueueTest : public testing::Test {
     }
     // The bounds() just mirror the raster source size.
     pending_layer->SetBounds(pending_layer->raster_source()->GetSize());
-    pending_tree->SetRootLayer(pending_layer.Pass());
+    pending_tree->SetRootLayer(std::move(pending_layer));
 
     pending_layer_ = static_cast<FakePictureLayerImpl*>(
         host_impl_.pending_tree()->LayerById(id_));
@@ -614,7 +614,7 @@ TEST_F(TileManagerTilePriorityQueueTest, ActivationComesBeforeEventually) {
           host_impl_.pending_tree(), id_ + 1, pending_raster_source);
   FakePictureLayerImpl* pending_child_raw = pending_child.get();
   pending_child_raw->SetDrawsContent(true);
-  pending_layer_->AddChild(pending_child.Pass());
+  pending_layer_->AddChild(std::move(pending_child));
 
   // Set a small viewport, so we have soon and eventually tiles.
   host_impl_.SetViewportSize(gfx::Size(200, 200));
@@ -835,7 +835,7 @@ TEST_F(TileManagerTilePriorityQueueTest,
   scoped_ptr<FakePictureLayerImpl> pending_child =
       FakePictureLayerImpl::CreateWithRasterSource(host_impl_.pending_tree(), 2,
                                                    pending_raster_source);
-  pending_layer_->AddChild(pending_child.Pass());
+  pending_layer_->AddChild(std::move(pending_child));
 
   FakePictureLayerImpl* pending_child_layer =
       static_cast<FakePictureLayerImpl*>(pending_layer_->children()[0].get());
@@ -952,7 +952,7 @@ TEST_F(TileManagerTilePriorityQueueTest,
       FakePictureLayerImpl::CreateWithRasterSource(host_impl_.pending_tree(), 2,
                                                    pending_raster_source);
   FakePictureLayerImpl* pending_child_layer = pending_child.get();
-  pending_layer_->AddChild(pending_child.Pass());
+  pending_layer_->AddChild(std::move(pending_child));
 
   // Create a fully transparent child layer so that its tile priorities are not
   // considered to be valid.
@@ -1053,7 +1053,7 @@ TEST_F(TileManagerTilePriorityQueueTest, RasterTilePriorityQueueEmptyLayers) {
         FakePictureLayerImpl::Create(host_impl_.pending_tree(), id_ + i);
     pending_layer->SetDrawsContent(true);
     pending_layer->set_has_valid_tile_priorities(true);
-    pending_layer_->AddChild(pending_layer.Pass());
+    pending_layer_->AddChild(std::move(pending_layer));
   }
 
   queue = host_impl_.BuildRasterQueue(SAME_PRIORITY_FOR_BOTH_TREES,
@@ -1100,7 +1100,7 @@ TEST_F(TileManagerTilePriorityQueueTest, EvictionTilePriorityQueueEmptyLayers) {
         FakePictureLayerImpl::Create(host_impl_.pending_tree(), id_ + i);
     pending_layer->SetDrawsContent(true);
     pending_layer->set_has_valid_tile_priorities(true);
-    pending_layer_->AddChild(pending_layer.Pass());
+    pending_layer_->AddChild(std::move(pending_layer));
   }
 
   scoped_ptr<EvictionTilePriorityQueue> queue(
@@ -1509,7 +1509,7 @@ class TileManagerTest : public testing::Test {
     }
     // The bounds() just mirror the raster source size.
     pending_layer->SetBounds(pending_layer->raster_source()->GetSize());
-    pending_tree->SetRootLayer(pending_layer.Pass());
+    pending_tree->SetRootLayer(std::move(pending_layer));
 
     // Add tilings/tiles for the layer.
     bool update_lcd_text = false;
@@ -1754,7 +1754,7 @@ TEST_F(PartialRasterTileManagerTest, CancelledTasksHaveNoContentId) {
 
   // The bounds() just mirror the raster source size.
   pending_layer->SetBounds(pending_layer->raster_source()->GetSize());
-  pending_tree->SetRootLayer(pending_layer.Pass());
+  pending_tree->SetRootLayer(std::move(pending_layer));
 
   // Add tilings/tiles for the layer.
   host_impl_->pending_tree()->BuildPropertyTreesForTesting();
@@ -1846,7 +1846,7 @@ void RunPartialRasterCheck(scoped_ptr<LayerTreeHostImpl> host_impl,
 
   // The bounds() just mirror the raster source size.
   pending_layer->SetBounds(pending_layer->raster_source()->GetSize());
-  pending_tree->SetRootLayer(pending_layer.Pass());
+  pending_tree->SetRootLayer(std::move(pending_layer));
 
   // Add tilings/tiles for the layer.
   host_impl->pending_tree()->BuildPropertyTreesForTesting();
@@ -1871,13 +1871,15 @@ void RunPartialRasterCheck(scoped_ptr<LayerTreeHostImpl> host_impl,
 // Ensures that the tile manager successfully reuses tiles when partial
 // raster is enabled.
 TEST_F(PartialRasterTileManagerTest, PartialRasterSuccessfullyEnabled) {
-  RunPartialRasterCheck(host_impl_.Pass(), true /* partial_raster_enabled */);
+  RunPartialRasterCheck(std::move(host_impl_),
+                        true /* partial_raster_enabled */);
 }
 
 // Ensures that the tile manager does not attempt to reuse tiles when partial
 // raster is disabled.
 TEST_F(TileManagerTest, PartialRasterSuccessfullyDisabled) {
-  RunPartialRasterCheck(host_impl_.Pass(), false /* partial_raster_enabled */);
+  RunPartialRasterCheck(std::move(host_impl_),
+                        false /* partial_raster_enabled */);
 }
 
 }  // namespace