cc: Use reverse spiral iterator in tiling eviction.

cc/resources/eviction_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/eviction_tile_priority_queue.h"
 
 namespace cc {
 
 namespace {
 
@@ skipping 75 matching lines @@
 
 void EvictionTilePriorityQueue::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(
-        make_scoped_ptr(new PairedPictureLayerQueue(*it, tree_priority_)));
+    paired_queues_.push_back(make_scoped_ptr(new PairedPictureLayerQueue(*it)));
   }
 
   paired_queues_.make_heap(EvictionOrderComparator(tree_priority_));
 }
 
 void EvictionTilePriorityQueue::Reset() {
   paired_queues_.clear();
 }
 
 bool EvictionTilePriorityQueue::IsEmpty() const {
@@ skipping 11 matching lines @@
   paired_queues_.pop_heap(EvictionOrderComparator(tree_priority_));
   PairedPictureLayerQueue* paired_queue = paired_queues_.back();
   paired_queue->Pop(tree_priority_);
   paired_queues_.push_heap(EvictionOrderComparator(tree_priority_));
 }
 
 EvictionTilePriorityQueue::PairedPictureLayerQueue::PairedPictureLayerQueue() {
 }
 
 EvictionTilePriorityQueue::PairedPictureLayerQueue::PairedPictureLayerQueue(
-    const PictureLayerImpl::Pair& layer_pair,
-    TreePriority tree_priority)
+    const PictureLayerImpl::Pair& layer_pair)
     : active_iterator(
           layer_pair.active
-              ? PictureLayerImpl::LayerEvictionTileIterator(layer_pair.active,
-                                                            tree_priority)
+              ? PictureLayerImpl::LayerEvictionTileIterator(layer_pair.active)
               : PictureLayerImpl::LayerEvictionTileIterator()),
       pending_iterator(
           layer_pair.pending
-              ? PictureLayerImpl::LayerEvictionTileIterator(layer_pair.pending,
-                                                            tree_priority)
+              ? PictureLayerImpl::LayerEvictionTileIterator(layer_pair.pending)
               : PictureLayerImpl::LayerEvictionTileIterator()) {
 }
 
 EvictionTilePriorityQueue::PairedPictureLayerQueue::~PairedPictureLayerQueue() {
 }
 
 bool EvictionTilePriorityQueue::PairedPictureLayerQueue::IsEmpty() const {
   return !active_iterator && !pending_iterator;
 }
 
@@ skipping 62 matching lines @@
       active_tile->priority_for_tree_priority(tree_priority);
   const TilePriority& pending_priority =
       pending_tile->priority_for_tree_priority(tree_priority);
 
   if (pending_priority.IsHigherPriorityThan(active_priority))
     return ACTIVE_TREE;
   return PENDING_TREE;
 }
 
 }  // namespace cc