cc: prevent TileManager raster/eviction tile iterators copy.

cc/resources/tile_manager_unittest.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/resources/tile.h"
 #include "cc/resources/tile_priority.h"
 #include "cc/test/fake_impl_proxy.h"
 #include "cc/test/fake_layer_tree_host_impl.h"
 #include "cc/test/fake_output_surface.h"
 #include "cc/test/fake_output_surface_client.h"
@@ skipping 804 matching lines @@
   active_layer_->CreateDefaultTilingsAndTiles();
   pending_layer_->CreateDefaultTilingsAndTiles();
 
   std::vector<TileManager::PairedPictureLayer> paired_layers;
   tile_manager->GetPairedPictureLayers(&paired_layers);
   EXPECT_EQ(1u, paired_layers.size());
 
   TileManager::RasterTileIterator it(tile_manager,
                                      SAME_PRIORITY_FOR_BOTH_TREES);
   EXPECT_TRUE(it);
+
+  size_t tile_count = 0;
   std::set<Tile*> all_tiles;
-  size_t tile_count = 0;
-
   for (; it; ++it) {
-    ++tile_count;
     EXPECT_TRUE(*it);
     all_tiles.insert(*it);
+    ++tile_count;
   }
 
   EXPECT_EQ(tile_count, all_tiles.size());
   EXPECT_EQ(17u, tile_count);
 
   // Sanity check, all tiles should be visible.
   std::set<Tile*> smoothness_tiles;
   for (TileManager::RasterTileIterator it(tile_manager,
                                           SMOOTHNESS_TAKES_PRIORITY);
        it;
@@ skipping 137 matching lines @@
   TileManager* tile_manager = TileManagerTileIteratorTest::tile_manager();
   EXPECT_TRUE(tile_manager);
 
   active_layer_->CreateDefaultTilingsAndTiles();
   pending_layer_->CreateDefaultTilingsAndTiles();
 
   std::vector<TileManager::PairedPictureLayer> paired_layers;
   tile_manager->GetPairedPictureLayers(&paired_layers);
   EXPECT_EQ(1u, paired_layers.size());
 
-  TileManager::EvictionTileIterator it(tile_manager,
-                                       SAME_PRIORITY_FOR_BOTH_TREES);
-  EXPECT_FALSE(it);
+  TileManager::EvictionTileIterator empty_it(tile_manager,
+                                             SAME_PRIORITY_FOR_BOTH_TREES);
+  EXPECT_FALSE(empty_it);
   std::set<Tile*> all_tiles;
   size_t tile_count = 0;
 
   for (TileManager::RasterTileIterator raster_it(tile_manager,
                                                  SAME_PRIORITY_FOR_BOTH_TREES);
        raster_it;
        ++raster_it) {
     ++tile_count;
     EXPECT_TRUE(*raster_it);
     all_tiles.insert(*raster_it);
   }
 
   EXPECT_EQ(tile_count, all_tiles.size());
   EXPECT_EQ(17u, tile_count);
 
   tile_manager->InitializeTilesWithResourcesForTesting(
       std::vector<Tile*>(all_tiles.begin(), all_tiles.end()));
 
-  it = TileManager::EvictionTileIterator(tile_manager,
-                                         SAME_PRIORITY_FOR_BOTH_TREES);
+  TileManager::EvictionTileIterator it(tile_manager, SMOOTHNESS_TAKES_PRIORITY);
   EXPECT_TRUE(it);
 
   // Sanity check, all tiles should be visible.
   std::set<Tile*> smoothness_tiles;
-  for (TileManager::EvictionTileIterator it(tile_manager,
-                                            SMOOTHNESS_TAKES_PRIORITY);
-       it;
-       ++it) {
+  for (; it; ++it) {
     Tile* tile = *it;
     EXPECT_TRUE(tile);
     EXPECT_EQ(TilePriority::NOW, tile->priority(ACTIVE_TREE).priority_bin);
     EXPECT_EQ(TilePriority::NOW, tile->priority(PENDING_TREE).priority_bin);
     EXPECT_TRUE(tile->HasResources());
     smoothness_tiles.insert(tile);
   }
   EXPECT_EQ(all_tiles, smoothness_tiles);
 
   tile_manager->ReleaseTileResourcesForTesting(
@@ skipping 99 matching lines @@
 
     last_tile = tile;
     new_content_tiles.insert(tile);
   }
 
   EXPECT_EQ(tile_count, new_content_tiles.size());
   EXPECT_EQ(all_tiles, new_content_tiles);
 }
 }  // namespace
 }  // namespace cc