cc: Give non-drawing layers that are rasterized a lower priority.

cc/tiles/raster_tile_priority_queue_all.cc

 // Copyright 2015 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/raster_tile_priority_queue_all.h"
 
 #include "base/memory/ptr_util.h"
 #include "cc/tiles/tiling_set_raster_queue_all.h"
 
 namespace cc {
 
 namespace {
 
 class RasterOrderComparator {
  public:
   explicit RasterOrderComparator(TreePriority tree_priority)
       : tree_priority_(tree_priority) {}
 
   bool operator()(

[danakj, 2017/05/25 15:49:02]

Can you put a comment here explaining when this returns true/false? true means b
takes priority right?

[Khushal, 2017/05/25 22:43:22]

Yup, this is true if a < b. The comment is already there at the beginning of the
function. You wanna move it up?

[danakj, 2017/05/26 15:46:20]

Oh that looks like its commenting on the first lines of the function, yes please
:)

[Khushal, 2017/05/26 18:09:21]

Done.

       const std::unique_ptr<TilingSetRasterQueueAll>& a_queue,
       const std::unique_ptr<TilingSetRasterQueueAll>& b_queue) const {
     // Note that in this function, we have to return true if and only if
     // a is strictly lower priority than b.
+
     const TilePriority& a_priority = a_queue->Top().priority();
     const TilePriority& b_priority = b_queue->Top().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_non_drawing_layer() != a_queue->is_non_drawing_layer()) {
+      return a_queue->is_non_drawing_layer();
+    }
+
     // 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;
 
@@ skipping 18 matching lines @@
     std::vector<std::unique_ptr<TilingSetRasterQueueAll>>* queues) {
   DCHECK(queues->empty());
 
   for (auto* layer : layers) {
     if (!layer->HasValidTilePriorities())
       continue;
 
     PictureLayerTilingSet* tiling_set = layer->picture_layer_tiling_set();
     bool prioritize_low_res = tree_priority == SMOOTHNESS_TAKES_PRIORITY;
     std::unique_ptr<TilingSetRasterQueueAll> tiling_set_queue =
-        base::MakeUnique<TilingSetRasterQueueAll>(tiling_set,
-                                                  prioritize_low_res);
+        base::MakeUnique<TilingSetRasterQueueAll>(
+            tiling_set, prioritize_low_res,
+            layer->raster_even_if_not_in_rsll());
     // 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(),
                  RasterOrderComparator(tree_priority));
 }
 
 }  // namespace
 
@@ skipping 95 matching lines @@
         return active_queues_;
       return pending_queues_;
     }
     default:
       NOTREACHED();
       return active_queues_;
   }
 }
 
 }  // namespace cc