cc: Split tiling set raster queues into all and required.

cc/resources/raster_tile_priority_queue.cc

 // Copyright 2014 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.h"
 
+#include "cc/resources/tiling_set_raster_queue_all.h"
+#include "cc/resources/tiling_set_raster_queue_required.h"
+
 namespace cc {
 
 namespace {
 
 class RasterOrderComparator {
  public:
   explicit RasterOrderComparator(TreePriority tree_priority)
       : tree_priority_(tree_priority) {}
 
   bool operator()(
@@ skipping 100 matching lines @@
       if (active_priority.IsHigherPriorityThan(pending_priority))
         return ACTIVE_TREE;
       return PENDING_TREE;
     }
     default:
       NOTREACHED();
       return ACTIVE_TREE;
   }
 }
 
+scoped_ptr<TilingSetRasterQueue> CreateTilingSetRasterQueue(
+    PictureLayerImpl* layer,
+    TreePriority tree_priority,
+    RasterTilePriorityQueue::Type type) {
+  if (!layer)
+    return nullptr;
+  PictureLayerTilingSet* tiling_set = layer->picture_layer_tiling_set();
+  if (!tiling_set)

[danakj, 2015/01/08 23:24:40]

dont think this can be null anymore can it?

+    return nullptr;
+
+  if (type == RasterTilePriorityQueue::Type::ALL) {
+    return make_scoped_ptr(new TilingSetRasterQueueAll(
+        tiling_set, tree_priority == SMOOTHNESS_TAKES_PRIORITY));

[danakj, 2015/01/08 23:24:40]

can you use a temp var to give this bool a name related to what it means for the
RTPQ?

+  }
+  return make_scoped_ptr(new TilingSetRasterQueueRequired(tiling_set, type));
+}
+
 }  // namespace
 
 RasterTilePriorityQueue::RasterTilePriorityQueue() {
 }
 
 RasterTilePriorityQueue::~RasterTilePriorityQueue() {
 }
 
 void RasterTilePriorityQueue::Build(
     const std::vector<PictureLayerImpl::Pair>& paired_layers,
-    TreePriority tree_priority) {
+    TreePriority tree_priority,
+    Type type) {
   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_)));
+        make_scoped_ptr(new PairedTilingSetQueue(*it, tree_priority_, type)));
   }
   paired_queues_.make_heap(RasterOrderComparator(tree_priority_));
 }
 
 void RasterTilePriorityQueue::Reset() {
   paired_queues_.clear();
 }
 
 bool RasterTilePriorityQueue::IsEmpty() const {
   return paired_queues_.empty() || paired_queues_.front()->IsEmpty();
@@ skipping 11 matching lines @@
   PairedTilingSetQueue* paired_queue = paired_queues_.back();
   paired_queue->Pop(tree_priority_);
   paired_queues_.push_heap(RasterOrderComparator(tree_priority_));
 }
 
 RasterTilePriorityQueue::PairedTilingSetQueue::PairedTilingSetQueue() {
 }
 
 RasterTilePriorityQueue::PairedTilingSetQueue::PairedTilingSetQueue(
     const PictureLayerImpl::Pair& layer_pair,
-    TreePriority tree_priority)
-    : has_both_layers(layer_pair.active && layer_pair.pending) {
-  if (layer_pair.active) {
-    active_queue = layer_pair.active->CreateRasterQueue(
-        tree_priority == SMOOTHNESS_TAKES_PRIORITY);
+    TreePriority tree_priority,
+    Type type)
+    : has_both_layers(false) {
+  switch (type) {
+    case RasterTilePriorityQueue::Type::ALL:
+      has_both_layers = layer_pair.active && layer_pair.pending;
+      active_queue =
+          CreateTilingSetRasterQueue(layer_pair.active, tree_priority, type);
+      pending_queue =
+          CreateTilingSetRasterQueue(layer_pair.pending, tree_priority, type);
+      break;

[danakj, 2015/01/08 23:24:40]

maybe dhceck that if has_both_layers then both queues are non-null?

+    case RasterTilePriorityQueue::Type::REQUIRED_FOR_ACTIVATION:
+      pending_queue =
+          CreateTilingSetRasterQueue(layer_pair.pending, tree_priority, type);
+      break;
+    case RasterTilePriorityQueue::Type::REQUIRED_FOR_DRAW:
+      active_queue =
+          CreateTilingSetRasterQueue(layer_pair.active, tree_priority, type);
+      break;
   }
 
-  if (layer_pair.pending) {
-    pending_queue = layer_pair.pending->CreateRasterQueue(
-        tree_priority == SMOOTHNESS_TAKES_PRIORITY);
-  }
-
-  if (has_both_layers)
-    SkipTilesReturnedByTwin(tree_priority);
+  SkipTilesReturnedByTwin(tree_priority);
 
   TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
                        "PairedTilingSetQueue::PairedTilingSetQueue",
                        TRACE_EVENT_SCOPE_THREAD, "state", StateAsValue());
 }
 
 RasterTilePriorityQueue::PairedTilingSetQueue::~PairedTilingSetQueue() {
   TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
                        "PairedTilingSetQueue::~PairedTilingSetQueue",
                        TRACE_EVENT_SCOPE_THREAD, "state", StateAsValue());
@@ skipping 21 matching lines @@
     TreePriority tree_priority) {
   DCHECK(!IsEmpty());
 
   WhichTree next_tree = NextTileIteratorTree(tree_priority);
   TilingSetRasterQueue* next_queue =
       next_tree == ACTIVE_TREE ? active_queue.get() : pending_queue.get();
   DCHECK(next_queue && !next_queue->IsEmpty());
   DCHECK(returned_tiles_for_debug.insert(next_queue->Top()).second);
   next_queue->Pop();
 
-  if (has_both_layers)
-    SkipTilesReturnedByTwin(tree_priority);
+  SkipTilesReturnedByTwin(tree_priority);
 
   // If no empty, use Top to do DCHECK the next iterator.
   DCHECK(IsEmpty() || Top(tree_priority));
 }
 
 void RasterTilePriorityQueue::PairedTilingSetQueue::SkipTilesReturnedByTwin(
     TreePriority tree_priority) {
+  if (!has_both_layers)
+    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);
     TilingSetRasterQueue* next_queue =
         next_tree == ACTIVE_TREE ? active_queue.get() : pending_queue.get();
     DCHECK(next_queue && !next_queue->IsEmpty());
 
     // Accept all non-shared tiles.
     const Tile* tile = next_queue->Top();
@@ skipping 58 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