cc: Use pointers for heaps in tile manager raster tile priority queue.

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"
 
 namespace cc {
 
 namespace {
 
 class RasterOrderComparator {
  public:
   explicit RasterOrderComparator(TreePriority tree_priority)
       : tree_priority_(tree_priority) {}
 
   bool operator()(
-      const RasterTilePriorityQueue::PairedPictureLayerQueue& a,
-      const RasterTilePriorityQueue::PairedPictureLayerQueue& b) const {
-    if (a.IsEmpty())
+      const RasterTilePriorityQueue::PairedPictureLayerQueue* a,
+      const RasterTilePriorityQueue::PairedPictureLayerQueue* b) const {
+    if (a->IsEmpty())
       return true;
 
-    if (b.IsEmpty())
+    if (b->IsEmpty())
       return false;
 
-    WhichTree a_tree = a.NextTileIteratorTree(tree_priority_);
+    WhichTree a_tree = a->NextTileIteratorTree(tree_priority_);
     const PictureLayerImpl::LayerRasterTileIterator* a_iterator =
-        a_tree == ACTIVE_TREE ? &a.active_iterator : &a.pending_iterator;
+        a_tree == ACTIVE_TREE ? &a->active_iterator : &a->pending_iterator;
 
-    WhichTree b_tree = b.NextTileIteratorTree(tree_priority_);
+    WhichTree b_tree = b->NextTileIteratorTree(tree_priority_);
     const PictureLayerImpl::LayerRasterTileIterator* b_iterator =
-        b_tree == ACTIVE_TREE ? &b.active_iterator : &b.pending_iterator;
+        b_tree == ACTIVE_TREE ? &b->active_iterator : &b->pending_iterator;
 
     const Tile* a_tile = **a_iterator;
     const 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;
 
@@ skipping 34 matching lines @@
 }
 
 void RasterTilePriorityQueue::Build(
     const std::vector<PictureLayerImpl::Pair>& paired_layers,
     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(PairedPictureLayerQueue(*it, tree_priority_));
+    paired_queues_heap_.push_back(
+        make_scoped_ptr(new PairedPictureLayerQueue(*it, tree_priority_)));
   }
 
-  std::make_heap(paired_queues_.begin(),
-                 paired_queues_.end(),
-                 RasterOrderComparator(tree_priority_));
+  paired_queues_heap_.make_heap(RasterOrderComparator(tree_priority_));
 }
 
 void RasterTilePriorityQueue::Reset() {
-  paired_queues_.clear();
+  paired_queues_heap_.clear();
 }
 
 bool RasterTilePriorityQueue::IsEmpty() const {
-  return paired_queues_.empty() || paired_queues_.front().IsEmpty();
+  return paired_queues_heap_.empty() || paired_queues_heap_.front()->IsEmpty();
 }
 
 Tile* RasterTilePriorityQueue::Top() {
   DCHECK(!IsEmpty());
-  return paired_queues_.front().Top(tree_priority_);
+  return paired_queues_heap_.front()->Top(tree_priority_);
 }
 
 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_));
+  paired_queues_heap_.pop_heap(RasterOrderComparator(tree_priority_));
+  PairedPictureLayerQueue* paired_queue = paired_queues_heap_.back();
+  paired_queue->Pop(tree_priority_);
+  paired_queues_heap_.push_heap(RasterOrderComparator(tree_priority_));
 }
 
 RasterTilePriorityQueue::PairedPictureLayerQueue::PairedPictureLayerQueue() {
 }
 
 RasterTilePriorityQueue::PairedPictureLayerQueue::PairedPictureLayerQueue(
     const PictureLayerImpl::Pair& layer_pair,
     TreePriority tree_priority)
     : active_iterator(layer_pair.active
                           ? PictureLayerImpl::LayerRasterTileIterator(
@@ skipping 92 matching lines @@
     default:
       NOTREACHED();
   }
 
   NOTREACHED();
   // Keep the compiler happy.
   return ACTIVE_TREE;
 }
 
 }  // namespace cc