cc: Switch tiling set eviction queue to consider combined priority.

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 71 matching lines @@
 EvictionTilePriorityQueue::~EvictionTilePriorityQueue() {
 }
 
 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) {

[vmpstr, 2015/04/02 17:30:29]

nit: keep the braces, since the for loop is two lines. Or change the for loop to
be range based for with const auto&

[USE eero AT chromium.org, 2015/04/07 13:17:07]

Done.

-    paired_queues_.push_back(
-        make_scoped_ptr(new PairedTilingSetQueue(*it, tree_priority_)));
-  }
+       it != paired_layers.end(); ++it)
+    paired_queues_.push_back(make_scoped_ptr(new PairedTilingSetQueue(*it)));
 
   paired_queues_.make_heap(EvictionOrderComparator(tree_priority_));
 }
 
 bool EvictionTilePriorityQueue::IsEmpty() const {
   return paired_queues_.empty() || paired_queues_.front()->IsEmpty();
 }
 
 Tile* EvictionTilePriorityQueue::Top() {
   DCHECK(!IsEmpty());
   return paired_queues_.front()->Top();
 }
 
 void EvictionTilePriorityQueue::Pop() {
   DCHECK(!IsEmpty());
 
   paired_queues_.pop_heap(EvictionOrderComparator(tree_priority_));
   PairedTilingSetQueue* paired_queue = paired_queues_.back();
   paired_queue->Pop();
   paired_queues_.push_heap(EvictionOrderComparator(tree_priority_));
 }
 
 EvictionTilePriorityQueue::PairedTilingSetQueue::PairedTilingSetQueue() {
 }
 
 EvictionTilePriorityQueue::PairedTilingSetQueue::PairedTilingSetQueue(
-    const PictureLayerImpl::Pair& layer_pair,
-    TreePriority tree_priority) {
+    const PictureLayerImpl::Pair& layer_pair) {
   bool skip_shared_out_of_order_tiles = layer_pair.active && layer_pair.pending;
   if (layer_pair.active) {
     active_queue = make_scoped_ptr(new TilingSetEvictionQueue(
-        layer_pair.active->picture_layer_tiling_set(), tree_priority,
+        layer_pair.active->picture_layer_tiling_set(),
         skip_shared_out_of_order_tiles));
   }
   if (layer_pair.pending) {
     pending_queue = make_scoped_ptr(new TilingSetEvictionQueue(
-        layer_pair.pending->picture_layer_tiling_set(), tree_priority,
+        layer_pair.pending->picture_layer_tiling_set(),
         skip_shared_out_of_order_tiles));
   }
 }
 
 EvictionTilePriorityQueue::PairedTilingSetQueue::~PairedTilingSetQueue() {
 }
 
 bool EvictionTilePriorityQueue::PairedTilingSetQueue::IsEmpty() const {
   return (!active_queue || active_queue->IsEmpty()) &&
          (!pending_queue || pending_queue->IsEmpty());
@@ skipping 54 matching lines @@
     return active_tile->required_for_activation() ? PENDING_TREE : ACTIVE_TREE;
   }
 
   // Return tile with a lower priority.
   if (pending_priority.IsHigherPriorityThan(active_priority))
     return ACTIVE_TREE;
   return PENDING_TREE;
 }
 
 }  // namespace cc