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

cc/resources/raster_tile_priority_queue_all.cc

 // Copyright 2015 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/raster_tile_priority_queue_all.h"
 
+#include "base/containers/hash_tables.h"
 #include "cc/resources/tiling_set_raster_queue_all.h"
 
 namespace cc {
 
 namespace {
 
 class RasterOrderComparator {
  public:
   explicit RasterOrderComparator(TreePriority tree_priority)
       : tree_priority_(tree_priority) {}
@@ skipping 103 matching lines @@
         return ACTIVE_TREE;
       return PENDING_TREE;
     }
     default:
       NOTREACHED();
       return ACTIVE_TREE;
   }
 }
 
 scoped_ptr<TilingSetRasterQueueAll> CreateTilingSetRasterQueue(
-    PictureLayerImpl* layer,
+    PictureLayerTilingSet* tiling_set,
     TreePriority tree_priority) {
-  if (!layer)
+  if (!tiling_set)
     return nullptr;
-  PictureLayerTilingSet* tiling_set = layer->picture_layer_tiling_set();
   bool prioritize_low_res = tree_priority == SMOOTHNESS_TAKES_PRIORITY;
   return make_scoped_ptr(
       new TilingSetRasterQueueAll(tiling_set, prioritize_low_res));
 }
 
 }  // namespace
 
 RasterTilePriorityQueueAll::RasterTilePriorityQueueAll() {
 }
 
 RasterTilePriorityQueueAll::~RasterTilePriorityQueueAll() {
 }
 
 void RasterTilePriorityQueueAll::Build(
-    const std::vector<PictureLayerImpl::Pair>& paired_layers,
+    const base::hash_map<int, PictureLayerTilingSet::Pair>&
+        paired_picture_layer_tiling_sets,
+    bool has_pending_tree,
     TreePriority tree_priority) {
   tree_priority_ = tree_priority;
-  for (std::vector<PictureLayerImpl::Pair>::const_iterator it =
-           paired_layers.begin();
-       it != paired_layers.end(); ++it) {
-    paired_queues_.push_back(
-        make_scoped_ptr(new PairedTilingSetQueue(*it, tree_priority_)));
+  for (const auto& paired_tiling_set_pair : paired_picture_layer_tiling_sets) {
+    const auto& paired_tiling_set = paired_tiling_set_pair.second;
+    PictureLayerTilingSet* active = paired_tiling_set.active;
+    // Reset |active| if it doesn't have valid tile priorities.
+    if (active && !active->HasValidTilePriorities())

[enne (OOO), 2015/02/10 21:28:31]

Would it make sense to unregister/register when there aren't valid tile
priorities vs checking every time?  I don't feel strongly about that, but am
curious what you think.

[vmpstr, 2015/02/11 21:37:16]

We process non-valid-tile-priority layers in eviction iterators though. Also,
this would just add an extra register/unregister pair that i'm trying really
hard to avoid :)

[enne (OOO), 2015/02/11 21:46:16]

Aha, ok! That makes sense.

+      active = nullptr;
+
+    PictureLayerTilingSet* pending =
+        has_pending_tree ? paired_tiling_set.pending : nullptr;
+    // Reset |pending| if it doesn't have valid tile priorities.
+    if (pending && !pending->HasValidTilePriorities())
+      pending = nullptr;
+
+    paired_queues_.push_back(make_scoped_ptr(
+        new PairedTilingSetQueue(active, pending, tree_priority_)));
   }
   paired_queues_.make_heap(RasterOrderComparator(tree_priority_));
 }
 
 bool RasterTilePriorityQueueAll::IsEmpty() const {
   return paired_queues_.empty() || paired_queues_.front()->IsEmpty();
 }
 
 Tile* RasterTilePriorityQueueAll::Top() {
   DCHECK(!IsEmpty());
   return paired_queues_.front()->Top(tree_priority_);
 }
 
 void RasterTilePriorityQueueAll::Pop() {
   DCHECK(!IsEmpty());
 
   paired_queues_.pop_heap(RasterOrderComparator(tree_priority_));
   PairedTilingSetQueue* paired_queue = paired_queues_.back();
   paired_queue->Pop(tree_priority_);
   paired_queues_.push_heap(RasterOrderComparator(tree_priority_));
 }
 
 RasterTilePriorityQueueAll::PairedTilingSetQueue::PairedTilingSetQueue() {
 }
 
 RasterTilePriorityQueueAll::PairedTilingSetQueue::PairedTilingSetQueue(
-    const PictureLayerImpl::Pair& layer_pair,
+    PictureLayerTilingSet* active_set,
+    PictureLayerTilingSet* pending_set,
     TreePriority tree_priority)
-    : active_queue_(
-          CreateTilingSetRasterQueue(layer_pair.active, tree_priority)),
-      pending_queue_(
-          CreateTilingSetRasterQueue(layer_pair.pending, tree_priority)),
-      has_both_layers_(layer_pair.active && layer_pair.pending) {
+    : active_queue_(CreateTilingSetRasterQueue(active_set, tree_priority)),
+      pending_queue_(CreateTilingSetRasterQueue(pending_set, tree_priority)),
+      has_both_tiling_sets_(active_set && pending_set) {
   SkipTilesReturnedByTwin(tree_priority);
 
   TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
                        "PairedTilingSetQueue::PairedTilingSetQueue",
                        TRACE_EVENT_SCOPE_THREAD, "state", StateAsValue());
 }
 
 RasterTilePriorityQueueAll::PairedTilingSetQueue::~PairedTilingSetQueue() {
   TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
                        "PairedTilingSetQueue::~PairedTilingSetQueue",
@@ skipping 31 matching lines @@
   next_queue->Pop();
 
   SkipTilesReturnedByTwin(tree_priority);
 
   // If no empty, use Top to do DCHECK the next iterator.
   DCHECK(IsEmpty() || Top(tree_priority));
 }
 
 void RasterTilePriorityQueueAll::PairedTilingSetQueue::SkipTilesReturnedByTwin(
     TreePriority tree_priority) {
-  if (!has_both_layers_)
+  if (!has_both_tiling_sets_)
     return;
 
   // We have both layers (active and pending) thus we can encounter shared
   // tiles twice (from the active iterator and from the pending iterator).
   while (!IsEmpty()) {
     WhichTree next_tree = NextTileIteratorTree(tree_priority);
     TilingSetRasterQueueAll* next_queue =
         next_tree == ACTIVE_TREE ? active_queue_.get() : pending_queue_.get();
     DCHECK(next_queue && !next_queue->IsEmpty());
 
@@ skipping 61 matching lines @@
 
   state->BeginDictionary("pending_queue");
   state->SetBoolean("has_tile", active_queue_has_tile);
   state->SetInteger("active_priority_bin", active_priority_bin);
   state->SetInteger("pending_priority_bin", pending_priority_bin);
   state->EndDictionary();
   return state;
 }
 
 }  // namespace cc