cc: Change TileManager iterators to be queues.

cc/resources/raster_tile_priority_queue.cc

Index: cc/resources/raster_tile_priority_queue.cc
diff --git a/cc/resources/raster_tile_priority_queue.cc b/cc/resources/raster_tile_priority_queue.cc
new file mode 100644
index 0000000000000000000000000000000000000000..6a2e2ce747880eb24f8d6a3eff4b6616ea3d250a
--- /dev/null
+++ b/cc/resources/raster_tile_priority_queue.cc
@@ -0,0 +1,218 @@
+// 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"
+
+namespace cc {
+
+namespace {
+
+class RasterOrderComparator {
+ public:
+  explicit RasterOrderComparator(TreePriority tree_priority)
+      : tree_priority_(tree_priority) {}
+
+  bool operator()(RasterTilePriorityQueue::PairedPictureLayerQueue& a,
+                  RasterTilePriorityQueue::PairedPictureLayerQueue& b) const {
+    if (a.IsEmpty())
+      return true;
+
+    if (b.IsEmpty())
+      return false;
+
+    PictureLayerImpl::LayerRasterTileIterator* a_iterator =
+        a.NextTileIterator(tree_priority_);
+    PictureLayerImpl::LayerRasterTileIterator* b_iterator =
+        b.NextTileIterator(tree_priority_);
+
+    Tile* a_tile = **a_iterator;
+    Tile* b_tile = **b_iterator;
+
+    const TilePriority& a_priority =
+        a_tile->priority_for_tree_priority(tree_priority_);
+    const TilePriority& b_priority =
+        b_tile->priority_for_tree_priority(tree_priority_);
+    bool prioritize_low_res = tree_priority_ == SMOOTHNESS_TAKES_PRIORITY;
+
+    // Now we have to return true iff b is higher priority than a.
+
+    // 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.
+      if (a_priority.resolution == NON_IDEAL_RESOLUTION)
+        return true;
+
+      if (b_priority.resolution == NON_IDEAL_RESOLUTION)
+        return false;
+
+      if (prioritize_low_res)
+        return b_priority.resolution == LOW_RESOLUTION;
+
+      return b_priority.resolution == HIGH_RESOLUTION;
+    }
+
+    return b_priority.IsHigherPriorityThan(a_priority);
+  }
+
+ private:
+  TreePriority tree_priority_;
+};
+
+}  // namespace
+
+RasterTilePriorityQueue::RasterTilePriorityQueue() {
+}
+
+RasterTilePriorityQueue::~RasterTilePriorityQueue() {
+}
+
+void RasterTilePriorityQueue::Build(
+    const std::vector<PictureLayerImpl::Pair>& paired_layers,
+    TreePriority tree_priority) {
+  tree_priority_ = tree_priority;
+  bool prioritize_low_res = tree_priority_ == SMOOTHNESS_TAKES_PRIORITY;
+
+  for (std::vector<PictureLayerImpl::Pair>::const_iterator it =
+           paired_layers.begin();
+       it != paired_layers.end();
+       ++it) {
+    PairedPictureLayerQueue paired_queue;
+    if (it->active) {
+      paired_queue.active_iterator = PictureLayerImpl::LayerRasterTileIterator(
+          it->active, prioritize_low_res);
+    }
+
+    if (it->pending) {
+      paired_queue.pending_iterator = PictureLayerImpl::LayerRasterTileIterator(
+          it->pending, prioritize_low_res);
+    }
+
+    paired_queues_.push_back(paired_queue);
+  }
+
+  std::make_heap(paired_queues_.begin(),
+                 paired_queues_.end(),
+                 RasterOrderComparator(tree_priority_));
+}
+
+void RasterTilePriorityQueue::Reset() {
+  paired_queues_.clear();
+}
+
+void RasterTilePriorityQueue::Pop() {
+  DCHECK(!IsEmpty());
+
+  std::pop_heap(paired_queues_.begin(),
+                paired_queues_.end(),
+                RasterOrderComparator(tree_priority_));
+  PairedPictureLayerQueue& paired_queue = paired_queues_.back();
+  paired_queue.Pop(tree_priority_);
+  std::push_heap(paired_queues_.begin(),
+                 paired_queues_.end(),
+                 RasterOrderComparator(tree_priority_));
+}
+
+bool RasterTilePriorityQueue::IsEmpty() const {
+  return paired_queues_.empty() || paired_queues_.front().IsEmpty();
+}
+
+Tile* RasterTilePriorityQueue::Top() {
+  DCHECK(!IsEmpty());
+  return paired_queues_.front().Top(tree_priority_);
+}
+
+RasterTilePriorityQueue::PairedPictureLayerQueue::PairedPictureLayerQueue() {
+}
+
+RasterTilePriorityQueue::PairedPictureLayerQueue::~PairedPictureLayerQueue() {
+}
+
+Tile* RasterTilePriorityQueue::PairedPictureLayerQueue::Top(
+    TreePriority tree_priority) {
+  DCHECK(!IsEmpty());
+
+  PictureLayerImpl::LayerRasterTileIterator* next_iterator =
+      NextTileIterator(tree_priority);
+  DCHECK(*next_iterator);
+
+  Tile* tile = **next_iterator;
+  DCHECK(std::find(returned_shared_tiles.begin(),
+                   returned_shared_tiles.end(),
+                   tile) == returned_shared_tiles.end());
+  return tile;
+}
+
+bool RasterTilePriorityQueue::PairedPictureLayerQueue::IsEmpty() const {
+  return !active_iterator && !pending_iterator;
+}
+
+void RasterTilePriorityQueue::PairedPictureLayerQueue::Pop(
+    TreePriority tree_priority) {
+  DCHECK(!IsEmpty());
+
+  PictureLayerImpl::LayerRasterTileIterator* next_iterator =
+      NextTileIterator(tree_priority);
+  DCHECK(*next_iterator);
+  returned_shared_tiles.push_back(**next_iterator);
+  ++(*next_iterator);
+
+  if (IsEmpty())
+    return;
+
+  next_iterator = NextTileIterator(tree_priority);
+  while (std::find(returned_shared_tiles.begin(),
+                   returned_shared_tiles.end(),
+                   **next_iterator) != returned_shared_tiles.end()) {
+    ++(*next_iterator);
+    if (IsEmpty())
+      break;
+    next_iterator = NextTileIterator(tree_priority);
+  }
+}
+
+PictureLayerImpl::LayerRasterTileIterator*
+RasterTilePriorityQueue::PairedPictureLayerQueue::NextTileIterator(
+    TreePriority tree_priority) {
+  DCHECK(!IsEmpty());
+
+  // If we only have one iterator with tiles, return it.
+  if (!active_iterator)
+    return &pending_iterator;
+  if (!pending_iterator)
+    return &active_iterator;
+
+  // Now both iterators have tiles, so we have to decide based on tree priority.
+  switch (tree_priority) {
+    case SMOOTHNESS_TAKES_PRIORITY:
+      return &active_iterator;
+    case NEW_CONTENT_TAKES_PRIORITY:
+      return &pending_iterator;
+    case SAME_PRIORITY_FOR_BOTH_TREES: {
+      Tile* active_tile = *active_iterator;
+      Tile* pending_tile = *pending_iterator;
+      if (active_tile == pending_tile)
+        return &active_iterator;
+
+      const TilePriority& active_priority = active_tile->priority(ACTIVE_TREE);
+      const TilePriority& pending_priority =
+          pending_tile->priority(PENDING_TREE);
+
+      if (active_priority.IsHigherPriorityThan(pending_priority))
+        return &active_iterator;
+      return &pending_iterator;
+    }
+    default:
+      NOTREACHED();
+  }
+
+  NOTREACHED();
+  // Keep the compiler happy.
+  return NULL;
+}
+
+}  // namespace cc