cc: Rework how picture layer tiling set gets into raster queues.

cc/trees/layer_tree_host_impl.cc

 // Copyright 2011 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/trees/layer_tree_host_impl.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/basictypes.h"
@@ skipping 1184 matching lines @@
   DidModifyTilePriorities();
 }
 
 void LayerTreeHostImpl::DidModifyTilePriorities() {
   DCHECK(settings_.impl_side_painting);
   // Mark priorities as dirty and schedule a PrepareTiles().
   tile_priorities_dirty_ = true;
   client_->SetNeedsPrepareTilesOnImplThread();
 }
 
-void LayerTreeHostImpl::GetPictureLayerImplPairs(
-    std::vector<PictureLayerImpl::Pair>* layer_pairs,
-    bool need_valid_tile_priorities) const {
-  DCHECK(layer_pairs->empty());
-  for (std::vector<PictureLayerImpl*>::const_iterator it =
-           picture_layers_.begin();
-       it != picture_layers_.end();
-       ++it) {
-    PictureLayerImpl* layer = *it;
-
-    if (!layer->IsOnActiveOrPendingTree() ||
-        (need_valid_tile_priorities && !layer->HasValidTilePriorities()))
-      continue;
-
-    PictureLayerImpl* twin_layer = layer->GetPendingOrActiveTwinLayer();
-
-    // Ignore the twin layer when tile priorities are invalid.
-    if (need_valid_tile_priorities && twin_layer &&
-        !twin_layer->HasValidTilePriorities())
-      twin_layer = NULL;
-
-    // If the current tree is ACTIVE_TREE, then always generate a layer_pair.
-    // If current tree is PENDING_TREE, then only generate a layer_pair if
-    // there is no twin layer.
-    if (layer->GetTree() == ACTIVE_TREE) {
-      DCHECK_IMPLIES(twin_layer, twin_layer->GetTree() == PENDING_TREE);
-      layer_pairs->push_back(PictureLayerImpl::Pair(layer, twin_layer));
-    } else if (!twin_layer) {
-      DCHECK(layer->GetTree() == PENDING_TREE);
-      layer_pairs->push_back(PictureLayerImpl::Pair(NULL, layer));
-    }
-  }
-}
-
-scoped_ptr<RasterTilePriorityQueue> LayerTreeHostImpl::BuildRasterQueue(
-    TreePriority tree_priority,
-    RasterTilePriorityQueue::Type type) {
-  TRACE_EVENT0("cc", "LayerTreeHostImpl::BuildRasterQueue");
-  picture_layer_pairs_.clear();
-  GetPictureLayerImplPairs(&picture_layer_pairs_, true);
-  return RasterTilePriorityQueue::Create(picture_layer_pairs_, tree_priority,
-                                         type);
-}
-
-scoped_ptr<EvictionTilePriorityQueue> LayerTreeHostImpl::BuildEvictionQueue(
-    TreePriority tree_priority) {
-  TRACE_EVENT0("cc", "LayerTreeHostImpl::BuildEvictionQueue");
-  scoped_ptr<EvictionTilePriorityQueue> queue(new EvictionTilePriorityQueue);
-  picture_layer_pairs_.clear();
-  GetPictureLayerImplPairs(&picture_layer_pairs_, false);
-  queue->Build(picture_layer_pairs_, tree_priority);
-  return queue;
+bool LayerTreeHostImpl::PendingTreeExists() {
+  return !!pending_tree();
 }
 
 void LayerTreeHostImpl::SetIsLikelyToRequireADraw(
     bool is_likely_to_require_a_draw) {
   // Proactively tell the scheduler that we expect to draw within each vsync
   // until we get all the tiles ready to draw. If we happen to miss a required
   // for draw tile here, then we will miss telling the scheduler each frame that
   // we intend to draw so it may make worse scheduling decisions.
   is_likely_to_require_a_draw_ = is_likely_to_require_a_draw;
 }
 
-const std::vector<PictureLayerImpl*>& LayerTreeHostImpl::GetPictureLayers()
-    const {
-  return picture_layers_;
-}
-
 void LayerTreeHostImpl::NotifyReadyToActivate() {
   client_->NotifyReadyToActivate();
 }
 
 void LayerTreeHostImpl::NotifyReadyToDraw() {
   // Tiles that are ready will cause NotifyTileStateChanged() to be called so we
   // don't need to schedule a draw here. Just stop WillBeginImplFrame() from
   // causing optimistic requests to draw a frame.
   is_likely_to_require_a_draw_ = false;
 
@@ skipping 539 matching lines @@
 
     UpdateViewportContainerSizes();
   } else {
     active_tree_->ProcessUIResourceRequestQueue();
   }
 
   active_tree_->DidBecomeActive();
   ActivateAnimations();
   if (settings_.impl_side_painting) {
     client_->RenewTreePriority();
-    // If we have any picture layers, then by activating we also modified tile
-    // priorities.
-    if (!picture_layers_.empty())
+    // If tile manager has tiling sets (ie, it tree priority changes would
+    // potentially affect some tiles), then make sure to schedule PrepareTiles
+    // via DidModifyTilePriorities.
+    if (tile_manager()->HasPictureLayerTilingSets())
       DidModifyTilePriorities();
   }
 
   client_->OnCanDrawStateChanged(CanDraw());
   client_->DidActivateSyncTree();
   if (!tree_activation_callback_.is_null())
     tree_activation_callback_.Run();
 
   if (debug_state_.continuous_painting) {
     const RenderingStats& stats =
@@ skipping 1657 matching lines @@
   for (; it != swap_promise_monitor_.end(); it++)
     (*it)->OnSetNeedsRedrawOnImpl();
 }
 
 void LayerTreeHostImpl::NotifySwapPromiseMonitorsOfForwardingToMainThread() {
   std::set<SwapPromiseMonitor*>::iterator it = swap_promise_monitor_.begin();
   for (; it != swap_promise_monitor_.end(); it++)
     (*it)->OnForwardScrollUpdateToMainThreadOnImpl();
 }
 
-void LayerTreeHostImpl::RegisterPictureLayerImpl(PictureLayerImpl* layer) {
-  DCHECK(std::find(picture_layers_.begin(), picture_layers_.end(), layer) ==
-         picture_layers_.end());
-  picture_layers_.push_back(layer);
-}
-
-void LayerTreeHostImpl::UnregisterPictureLayerImpl(PictureLayerImpl* layer) {
-  std::vector<PictureLayerImpl*>::iterator it =
-      std::find(picture_layers_.begin(), picture_layers_.end(), layer);
-  DCHECK(it != picture_layers_.end());
-  picture_layers_.erase(it);
-}
-
 }  // namespace cc