cc: Refactor how picture layers are exposed to the tile manager.

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 65 matching lines @@
   }
 
   virtual void TearDown() OVERRIDE {
     tile_manager_.reset(NULL);
     picture_pile_ = NULL;
 
     testing::Test::TearDown();
   }
 
   // TileManagerClient implementation.
+  virtual const std::vector<PictureLayerImpl*>& GetPictureLayers() OVERRIDE {
+    return picture_layers_;
+  }
   virtual void NotifyReadyToActivate() OVERRIDE { ready_to_activate_ = true; }
   virtual void NotifyTileStateChanged(const Tile* tile) OVERRIDE {}
 
   TileVector CreateTilesWithSize(int count,
                                  TilePriority active_priority,
                                  TilePriority pending_priority,
                                  const gfx::Size& tile_size) {
     TileVector tiles;
     for (int i = 0; i < count; ++i) {
       scoped_refptr<Tile> tile = tile_manager_->CreateTile(picture_pile_.get(),
@@ skipping 55 matching lines @@
   scoped_ptr<FakeTileManager> tile_manager_;
   scoped_refptr<FakePicturePileImpl> picture_pile_;
   FakeOutputSurfaceClient output_surface_client_;
   scoped_ptr<FakeOutputSurface> output_surface_;
   scoped_ptr<SharedBitmapManager> shared_bitmap_manager_;
   scoped_ptr<ResourceProvider> resource_provider_;
   scoped_ptr<ResourcePool> resource_pool_;
   TileMemoryLimitPolicy memory_limit_policy_;
   int max_tiles_;
   bool ready_to_activate_;
+  std::vector<PictureLayerImpl*> picture_layers_;
 };
 
 TEST_P(TileManagerTest, EnoughMemoryAllowAnything) {
   // A few tiles of each type of priority, with enough memory for all tiles.
 
   Initialize(10, ALLOW_ANYTHING, SMOOTHNESS_TAKES_PRIORITY);
   TileVector active_now =
       CreateTiles(3, TilePriorityForNowBin(), TilePriority());
   TileVector pending_now =
       CreateTiles(3, TilePriority(), TilePriorityForNowBin());
@@ skipping 441 matching lines @@
   // Allocated bytes should never be more than the memory limit.
   EXPECT_LE(memory_allocated_bytes, global_state_.hard_memory_limit_in_bytes);
 }
 
 // If true, the max tile limit should be applied as bytes; if false,
 // as num_resources_limit.
 INSTANTIATE_TEST_CASE_P(TileManagerTests,
                         TileManagerTest,
                         ::testing::Values(true, false));
 
-class TileManagerTileIteratorTest : public testing::Test,
-                                    public TileManagerClient {
+class TileManagerTileIteratorTest : public testing::Test {
  public:
   TileManagerTileIteratorTest()
       : memory_limit_policy_(ALLOW_ANYTHING),
         max_tiles_(10000),
         ready_to_activate_(false),
         id_(7),
         proxy_(base::MessageLoopProxy::current()),
         host_impl_(ImplSidePaintingSettings(),
                    &proxy_,
                    &shared_bitmap_manager_) {}
@@ skipping 76 matching lines @@
   }
 
   void CreateHighLowResAndSetAllTilesVisible() {
     // Active layer must get updated first so pending layer can share from it.
     active_layer_->CreateDefaultTilingsAndTiles();
     active_layer_->SetAllTilesVisible();
     pending_layer_->CreateDefaultTilingsAndTiles();
     pending_layer_->SetAllTilesVisible();
   }
 
-  // TileManagerClient implementation.
-  virtual void NotifyReadyToActivate() OVERRIDE { ready_to_activate_ = true; }
-  virtual void NotifyTileStateChanged(const Tile* tile) OVERRIDE {}
-
   TileManager* tile_manager() { return host_impl_.tile_manager(); }
 
  protected:
   GlobalStateThatImpactsTilePriority global_state_;
 
   TestSharedBitmapManager shared_bitmap_manager_;
   TileMemoryLimitPolicy memory_limit_policy_;
   int max_tiles_;
   bool ready_to_activate_;
   int id_;
   FakeImplProxy proxy_;
   FakeLayerTreeHostImpl host_impl_;
   FakePictureLayerImpl* pending_layer_;
   FakePictureLayerImpl* active_layer_;
 };
 
 TEST_F(TileManagerTileIteratorTest, PairedPictureLayers) {
-  FakeImplProxy proxy;
-  TestSharedBitmapManager shared_bitmap_manager;
-  FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
-  host_impl.CreatePendingTree();
-  host_impl.ActivatePendingTree();
-  host_impl.CreatePendingTree();
+  host_impl_.CreatePendingTree();
+  host_impl_.ActivatePendingTree();
+  host_impl_.CreatePendingTree();
 
-  LayerTreeImpl* active_tree = host_impl.active_tree();
-  LayerTreeImpl* pending_tree = host_impl.pending_tree();
+  LayerTreeImpl* active_tree = host_impl_.active_tree();
+  LayerTreeImpl* pending_tree = host_impl_.pending_tree();
   EXPECT_NE(active_tree, pending_tree);
 
   scoped_ptr<FakePictureLayerImpl> active_layer =
       FakePictureLayerImpl::Create(active_tree, 10);
   scoped_ptr<FakePictureLayerImpl> pending_layer =
       FakePictureLayerImpl::Create(pending_tree, 10);
 
   TileManager* tile_manager = TileManagerTileIteratorTest::tile_manager();
   EXPECT_TRUE(tile_manager);
 
-  tile_manager->RegisterPictureLayerImpl(active_layer.get());
-  tile_manager->RegisterPictureLayerImpl(pending_layer.get());
-
   std::vector<TileManager::PairedPictureLayer> paired_layers;
   tile_manager->GetPairedPictureLayers(&paired_layers);
 
   EXPECT_EQ(2u, paired_layers.size());
   if (paired_layers[0].active_layer) {
     EXPECT_EQ(active_layer.get(), paired_layers[0].active_layer);
     EXPECT_EQ(NULL, paired_layers[0].pending_layer);
   } else {
     EXPECT_EQ(pending_layer.get(), paired_layers[0].pending_layer);
     EXPECT_EQ(NULL, paired_layers[0].active_layer);
   }
 
   if (paired_layers[1].active_layer) {
     EXPECT_EQ(active_layer.get(), paired_layers[1].active_layer);
     EXPECT_EQ(NULL, paired_layers[1].pending_layer);
   } else {
     EXPECT_EQ(pending_layer.get(), paired_layers[1].pending_layer);
     EXPECT_EQ(NULL, paired_layers[1].active_layer);
   }
 
   active_layer->set_twin_layer(pending_layer.get());
   pending_layer->set_twin_layer(active_layer.get());
 
   tile_manager->GetPairedPictureLayers(&paired_layers);
   EXPECT_EQ(1u, paired_layers.size());
 
   EXPECT_EQ(active_layer.get(), paired_layers[0].active_layer);
   EXPECT_EQ(pending_layer.get(), paired_layers[0].pending_layer);
-
-  tile_manager->UnregisterPictureLayerImpl(active_layer.get());
-  tile_manager->UnregisterPictureLayerImpl(pending_layer.get());
 }
 
 TEST_F(TileManagerTileIteratorTest, RasterTileIterator) {
   SetupDefaultTrees(gfx::Size(1000, 1000));
   TileManager* tile_manager = TileManagerTileIteratorTest::tile_manager();
   EXPECT_TRUE(tile_manager);
 
   active_layer_->CreateDefaultTilingsAndTiles();
   pending_layer_->CreateDefaultTilingsAndTiles();
 
@@ skipping 307 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