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 540 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 const std::vector<PictureLayerImpl*>& GetPictureLayers() OVERRIDE {
+    return picture_layers_;
+  }
   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_;
+  std::vector<PictureLayerImpl*> picture_layers_;
 };
 
 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();
 
   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());
+  picture_layers_.push_back(active_layer.get());
+  picture_layers_.push_back(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);
@@ skipping 10 matching lines @@
 
   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());
+  picture_layers_.clear();

[vmpstr, 2014/06/05 22:38:02]

Do you need this?

[reveman, 2014/06/06 17:27:24]

Nope. Done.

 }
 
 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