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

This moves the vector of registered picture layers from
the tile manager to LTHI. Allows layers to be registered
in ctor and unregistered in dtor instead of having to
unregister them from the tile manager and then re-register
them as needed.

The picture layer vector is exposed to the tile manager
using a client function and this vector will include all
existing PictureLayerImpl instances. Whether it makes
sense for the tile manager to use a layer or not depends
on the return value of
PictureLayerImpl::HasValidTilePriorities().

BUG=

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

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@276665 0039d316-1c4b-4281-b951-d872f2087c98

4 files changed, 31 insertions, 78 deletions

diff --git a/cc/resources/tile_manager.cc b/cc/resources/tile_manager.cc
index 4a4cfea..c96b5e2 100644
--- a/cc/resources/tile_manager.cc
+++ b/cc/resources/tile_manager.cc
@@ -420,13 +420,6 @@ TileManager::~TileManager() {
 
   DCHECK_EQ(0u, bytes_releasable_);
   DCHECK_EQ(0u, resources_releasable_);
-
-  for (std::vector<PictureLayerImpl*>::iterator it = layers_.begin();
-       it != layers_.end();
-       ++it) {
-    (*it)->DidUnregisterLayer();
-  }
-  layers_.clear();
 }
 
 void TileManager::Release(Tile* tile) {
@@ -676,19 +669,6 @@ void TileManager::GetTilesWithAssignedBins(PrioritizedTileSet* tiles) {
   }
 }
 
-void TileManager::CleanUpLayers() {
-  for (size_t i = 0; i < layers_.size(); ++i) {
-    if (layers_[i]->IsDrawnRenderSurfaceLayerListMember())
-      continue;
-
-    layers_[i]->DidUnregisterLayer();
-    std::swap(layers_[i], layers_.back());
-    layers_.pop_back();
-    --i;
-    prioritized_tiles_dirty_ = true;
-  }
-}
-
 void TileManager::ManageTiles(const GlobalStateThatImpactsTilePriority& state) {
   TRACE_EVENT0("cc", "TileManager::ManageTiles");
 
@@ -698,8 +678,6 @@ void TileManager::ManageTiles(const GlobalStateThatImpactsTilePriority& state) {
     prioritized_tiles_dirty_ = true;
   }
 
-  CleanUpLayers();
-
   // We need to call CheckForCompletedTasks() once in-between each call
   // to ScheduleTasks() to prevent canceled tasks from being scheduled.
   if (!did_check_for_completed_tasks_since_last_schedule_tasks_) {
@@ -1219,38 +1197,28 @@ scoped_refptr<Tile> TileManager::CreateTile(PicturePileImpl* picture_pile,
   return tile;
 }
 
-void TileManager::RegisterPictureLayerImpl(PictureLayerImpl* layer) {
-  DCHECK(std::find(layers_.begin(), layers_.end(), layer) == layers_.end());
-  layers_.push_back(layer);
-}
-
-void TileManager::UnregisterPictureLayerImpl(PictureLayerImpl* layer) {
-  std::vector<PictureLayerImpl*>::iterator it =
-      std::find(layers_.begin(), layers_.end(), layer);
-  DCHECK(it != layers_.end());
-  layers_.erase(it);
-}
-
 void TileManager::GetPairedPictureLayers(
     std::vector<PairedPictureLayer>* paired_layers) const {
+  const std::vector<PictureLayerImpl*>& layers = client_->GetPictureLayers();
+
   paired_layers->clear();
   // Reserve a maximum possible paired layers.
-  paired_layers->reserve(layers_.size());
+  paired_layers->reserve(layers.size());
 
-  for (std::vector<PictureLayerImpl*>::const_iterator it = layers_.begin();
-       it != layers_.end();
+  for (std::vector<PictureLayerImpl*>::const_iterator it = layers.begin();
+       it != layers.end();
        ++it) {
     PictureLayerImpl* layer = *it;
 
-    // This is a recycle tree layer, we can safely skip since the tiles on this
-    // layer have to be accessible via the active tree.
-    if (!layer->IsOnActiveOrPendingTree())
+    // TODO(vmpstr): Iterators and should handle this instead. crbug.com/381704
+    if (!layer->HasValidTilePriorities())
       continue;
 
     PictureLayerImpl* twin_layer = layer->GetTwinLayer();
 
-    // If the twin layer is recycled, it is not a valid twin.
-    if (twin_layer && !twin_layer->IsOnActiveOrPendingTree())
+    // Ignore the twin layer when tile priorities are invalid.
+    // TODO(vmpstr): Iterators should handle this instead. crbug.com/381704
+    if (twin_layer && !twin_layer->HasValidTilePriorities())
       twin_layer = NULL;
 
     PairedPictureLayer paired_layer;
@@ -1450,6 +1418,8 @@ bool TileManager::RasterTileIterator::RasterOrderComparator::operator()(
 
   // If the bin is the same but the resolution is not, then the order will be
   // determined by whether we prioritize low res or not.
+  // TODO(vmpstr): Remove this when TilePriority is no longer a member of Tile
+  // class but instead produced by the iterators.
   if (b_priority.priority_bin == a_priority.priority_bin &&
       b_priority.resolution != a_priority.resolution) {
     // Non ideal resolution should be sorted lower than other resolutions.
@@ -1639,8 +1609,10 @@ void TileManager::SetRasterizerForTesting(Rasterizer* rasterizer) {
 }
 
 bool TileManager::IsReadyToActivate() const {
-  for (std::vector<PictureLayerImpl*>::const_iterator it = layers_.begin();
-       it != layers_.end();
+  const std::vector<PictureLayerImpl*>& layers = client_->GetPictureLayers();
+
+  for (std::vector<PictureLayerImpl*>::const_iterator it = layers.begin();
+       it != layers.end();
        ++it) {
     if (!(*it)->AllTilesRequiredForActivationAreReadyToDraw())
       return false;
diff --git a/cc/resources/tile_manager.h b/cc/resources/tile_manager.h
index 4c7360c..b36a6b4 100644
--- a/cc/resources/tile_manager.h
+++ b/cc/resources/tile_manager.h
@@ -31,6 +31,9 @@ class ResourceProvider;
 
 class CC_EXPORT TileManagerClient {
  public:
+  // Returns the set of layers that the tile manager should consider for raster.
+  virtual const std::vector<PictureLayerImpl*>& GetPictureLayers() = 0;
+
   // Called when all tiles marked as required for activation are ready to draw.
   virtual void NotifyReadyToActivate() = 0;
 
@@ -182,9 +185,6 @@ class CC_EXPORT TileManager : public RasterizerClient,
                                  int source_frame_number,
                                  int flags);
 
-  void RegisterPictureLayerImpl(PictureLayerImpl* layer);
-  void UnregisterPictureLayerImpl(PictureLayerImpl* layer);
-
   scoped_ptr<base::Value> BasicStateAsValue() const;
   scoped_ptr<base::Value> AllTilesAsValue() const;
   void GetMemoryStats(size_t* memory_required_bytes,
@@ -290,7 +290,6 @@ class CC_EXPORT TileManager : public RasterizerClient,
   scoped_refptr<RasterTask> CreateRasterTask(Tile* tile);
   scoped_ptr<base::Value> GetMemoryRequirementsAsValue() const;
   void UpdatePrioritizedTileSetIfNeeded();
-  void CleanUpLayers();
 
   bool IsReadyToActivate() const;
   void CheckIfReadyToActivate();
@@ -343,8 +342,6 @@ class CC_EXPORT TileManager : public RasterizerClient,
 
   std::vector<scoped_refptr<RasterTask> > orphan_raster_tasks_;
 
-  std::vector<PictureLayerImpl*> layers_;
-
   UniqueNotifier ready_to_activate_check_notifier_;
 
   DISALLOW_COPY_AND_ASSIGN(TileManager);
diff --git a/cc/resources/tile_manager_perftest.cc b/cc/resources/tile_manager_perftest.cc
index c7fa68f..0ac79b1 100644
--- a/cc/resources/tile_manager_perftest.cc
+++ b/cc/resources/tile_manager_perftest.cc
@@ -76,12 +76,11 @@ class FakeRasterizerImpl : public Rasterizer, public RasterizerTaskClient {
 base::LazyInstance<FakeRasterizerImpl> g_fake_rasterizer =
     LAZY_INSTANCE_INITIALIZER;
 
-class TileManagerPerfTest : public testing::Test, public TileManagerClient {
+class TileManagerPerfTest : public testing::Test {
  public:
   TileManagerPerfTest()
       : memory_limit_policy_(ALLOW_ANYTHING),
         max_tiles_(10000),
-        ready_to_activate_(false),
         id_(7),
         proxy_(base::MessageLoopProxy::current()),
         host_impl_(ImplSidePaintingSettings(10000),
@@ -291,10 +290,6 @@ class TileManagerPerfTest : public testing::Test, public TileManagerClient {
         "manage_tiles", "", test_name, timer_.LapsPerSecond(), "runs/s", true);
   }
 
-  // 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:
@@ -303,7 +298,6 @@ class TileManagerPerfTest : public testing::Test, public TileManagerClient {
   TestSharedBitmapManager shared_bitmap_manager_;
   TileMemoryLimitPolicy memory_limit_policy_;
   int max_tiles_;
-  bool ready_to_activate_;
   int id_;
   FakeImplProxy proxy_;
   FakeLayerTreeHostImpl host_impl_;
diff --git a/cc/resources/tile_manager_unittest.cc b/cc/resources/tile_manager_unittest.cc
index ce54d38..eccfb31 100644
--- a/cc/resources/tile_manager_unittest.cc
+++ b/cc/resources/tile_manager_unittest.cc
@@ -83,6 +83,9 @@ class TileManagerTest : public testing::TestWithParam<bool>,
   }
 
   // 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 {}
 
@@ -158,6 +161,7 @@ class TileManagerTest : public testing::TestWithParam<bool>,
   TileMemoryLimitPolicy memory_limit_policy_;
   int max_tiles_;
   bool ready_to_activate_;
+  std::vector<PictureLayerImpl*> picture_layers_;
 };
 
 TEST_P(TileManagerTest, EnoughMemoryAllowAnything) {
@@ -619,8 +623,7 @@ 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),
@@ -717,10 +720,6 @@ class TileManagerTileIteratorTest : public testing::Test,
     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:
@@ -738,15 +737,12 @@ class TileManagerTileIteratorTest : public testing::Test,
 };
 
 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();
+  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 =
@@ -757,9 +753,6 @@ TEST_F(TileManagerTileIteratorTest, PairedPictureLayers) {
   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);
 
@@ -788,9 +781,6 @@ TEST_F(TileManagerTileIteratorTest, PairedPictureLayers) {
 
   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) {