cc: Keep tile eviction prioritization consistent with raster priorities.

cc/tiles/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/tiles/eviction_tile_priority_queue.h"
 
 #include "base/memory/ptr_util.h"
 
 namespace cc {
 
 namespace {
 
 class EvictionOrderComparator {
  public:
   explicit EvictionOrderComparator(TreePriority tree_priority)
       : tree_priority_(tree_priority) {}
 
+  // Note that in this function, we have to return true if and only if
+  // b is strictly lower priority than a.
   bool operator()(
       const std::unique_ptr<TilingSetEvictionQueue>& a_queue,
       const std::unique_ptr<TilingSetEvictionQueue>& b_queue) const {
-    // Note that in this function, we have to return true if and only if
-    // b is strictly lower priority than a.
     const PrioritizedTile& a_tile = a_queue->Top();
     const PrioritizedTile& b_tile = b_queue->Top();
 
     const TilePriority& a_priority = a_tile.priority();
     const TilePriority& b_priority = b_tile.priority();
     bool prioritize_low_res = tree_priority_ == SMOOTHNESS_TAKES_PRIORITY;
 
+    // If the priority bin is the same but one of the tiles is from a
+    // non-drawing layer, then the drawing layer has a higher priority.
+    if (b_priority.priority_bin == a_priority.priority_bin &&
+        b_queue->is_drawing_layer() != a_queue->is_drawing_layer()) {
+      return a_queue->is_drawing_layer();
+    }
+
     // If the priority bin differs, b is lower priority if it has the higher
     // priority bin.
     if (a_priority.priority_bin != b_priority.priority_bin)
       return b_priority.priority_bin > a_priority.priority_bin;
 
     // Otherwise if the resolution differs, 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.resolution != a_priority.resolution) {
@@ skipping 26 matching lines @@
 
 void CreateTilingSetEvictionQueues(
     const std::vector<PictureLayerImpl*>& layers,
     TreePriority tree_priority,
     std::vector<std::unique_ptr<TilingSetEvictionQueue>>* queues) {
   DCHECK(queues->empty());
 
   for (auto* layer : layers) {
     std::unique_ptr<TilingSetEvictionQueue> tiling_set_queue =
         base::MakeUnique<TilingSetEvictionQueue>(
-            layer->picture_layer_tiling_set());
+            layer->picture_layer_tiling_set(),
+            layer->contributes_to_drawn_render_surface());
     // Queues will only contain non empty tiling sets.
     if (!tiling_set_queue->IsEmpty())
       queues->push_back(std::move(tiling_set_queue));
   }
   std::make_heap(queues->begin(), queues->end(),
                  EvictionOrderComparator(tree_priority));
 }
 
 }  // namespace
 
@@ skipping 76 matching lines @@
                                                          : active_queues_;
   }
 
   // Return tile with a lower priority.
   if (pending_priority.IsHigherPriorityThan(active_priority))
     return active_queues_;
   return pending_queues_;
 }
 
 }  // namespace cc