cc: Fixup cc to not use auto to deduce a raw pointer.

cc/tiles/picture_layer_tiling_set_unittest.cc

 // Copyright 2012 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/tiles/picture_layer_tiling_set.h"
 
 #include <map>
 #include <vector>
 
 #include "cc/resources/resource_provider.h"
@@ skipping 339 matching lines @@
 
   // Set a priority rect so we get tiles.
   pending_set->UpdateTilePriorities(gfx::Rect(layer_bounds), 1.f, 1.0,
                                     Occlusion(), false);
   EXPECT_EQ(tile_size1, pending_set->tiling_at(0)->tile_size());
 
   // The tiles should get the correct size.
   std::vector<Tile*> pending_tiles =
       pending_set->tiling_at(0)->AllTilesForTesting();
   EXPECT_GT(pending_tiles.size(), 0u);
-  for (const auto& tile : pending_tiles)
+  for (auto* tile : pending_tiles)
     EXPECT_EQ(tile_size1, tile->content_rect().size());
 
   // Update to a new source frame with a new tile size.
   // Note that setting a new raster source can typically only happen after
   // activation, since we can't set the raster source twice on the pending tree
   // without activating. For test, just remove and add a new tiling instead.
   pending_set->RemoveAllTilings();
   pending_set->AddTiling(1.f, raster_source);
   pending_set->tiling_at(0)->set_resolution(HIGH_RESOLUTION);
   pending_client.SetTileSize(tile_size2);
   pending_set->UpdateTilingsToCurrentRasterSourceForCommit(raster_source.get(),
                                                            Region(), 1.f, 1.f);
   // The tiling should get the correct tile size.
   EXPECT_EQ(tile_size2, pending_set->tiling_at(0)->tile_size());
 
   // Set a priority rect so we get tiles.
   pending_set->UpdateTilePriorities(gfx::Rect(layer_bounds), 1.f, 2.0,
                                     Occlusion(), false);
   EXPECT_EQ(tile_size2, pending_set->tiling_at(0)->tile_size());
 
   // Tiles should have the new correct size.
   pending_tiles = pending_set->tiling_at(0)->AllTilesForTesting();
   EXPECT_GT(pending_tiles.size(), 0u);
-  for (const auto& tile : pending_tiles)
+  for (auto* tile : pending_tiles)
     EXPECT_EQ(tile_size2, tile->content_rect().size());
 
   // Clone from the pending to the active tree.
   active_client.SetTileSize(tile_size2);
   active_set->UpdateTilingsToCurrentRasterSourceForActivation(
       raster_source.get(), pending_set.get(), Region(), 1.f, 1.f);
   // The active tiling should get the right tile size.
   EXPECT_EQ(tile_size2, active_set->tiling_at(0)->tile_size());
 
   // Cloned tiles should have the right size.
   std::vector<Tile*> active_tiles =
       active_set->tiling_at(0)->AllTilesForTesting();
   EXPECT_GT(active_tiles.size(), 0u);
-  for (const auto& tile : active_tiles)
+  for (auto* tile : active_tiles)
     EXPECT_EQ(tile_size2, tile->content_rect().size());
 
   // A new source frame with a new tile size.
   pending_client.SetTileSize(tile_size3);
   pending_set->UpdateTilingsToCurrentRasterSourceForCommit(raster_source.get(),
                                                            Region(), 1.f, 1.f);
   // The tiling gets the new size correctly.
   EXPECT_EQ(tile_size3, pending_set->tiling_at(0)->tile_size());
 
   // Set a priority rect so we get tiles.
   pending_set->UpdateTilePriorities(gfx::Rect(layer_bounds), 1.f, 3.0,
                                     Occlusion(), false);
   EXPECT_EQ(tile_size3, pending_set->tiling_at(0)->tile_size());
 
   // Tiles are resized for the new size.
   pending_tiles = pending_set->tiling_at(0)->AllTilesForTesting();
   EXPECT_GT(pending_tiles.size(), 0u);
-  for (const auto& tile : pending_tiles)
+  for (auto* tile : pending_tiles)
     EXPECT_EQ(tile_size3, tile->content_rect().size());
 
   // Now we activate with a different tile size for the active tiling.
   active_client.SetTileSize(tile_size3);
   active_set->UpdateTilingsToCurrentRasterSourceForActivation(
       raster_source.get(), pending_set.get(), Region(), 1.f, 1.f);
   // The active tiling changes its tile size.
   EXPECT_EQ(tile_size3, active_set->tiling_at(0)->tile_size());
 
   // And its tiles are resized.
   active_tiles = active_set->tiling_at(0)->AllTilesForTesting();
   EXPECT_GT(active_tiles.size(), 0u);
-  for (const auto& tile : active_tiles)
+  for (auto* tile : active_tiles)
     EXPECT_EQ(tile_size3, tile->content_rect().size());
 }
 
 TEST(PictureLayerTilingSetTest, MaxContentScale) {
   FakePictureLayerTilingClient pending_client;
   FakePictureLayerTilingClient active_client;
   std::unique_ptr<PictureLayerTilingSet> pending_set =
       PictureLayerTilingSet::Create(PENDING_TREE, &pending_client, 1000, 1.f,
                                     1000);
   std::unique_ptr<PictureLayerTilingSet> active_set =
@@ skipping 539 matching lines @@
 
   // This will invalidate tilings.
   tiling_set->UpdateRasterSourceDueToLCDChange(raster_source, Region());
 
   EXPECT_TRUE(
       tiling_set->UpdateTilePriorities(viewport, 1.f, time, Occlusion(), true));
 }
 
 }  // namespace
 }  // namespace cc