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

cc/layers/picture_layer_impl.cc

 // Copyright 2012 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/layers/picture_layer_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 497 matching lines @@
   // - This layer produced a high-res or non-ideal-res tile last frame.
   // - We're in requires high res to draw mode.
   // - We're not in smoothness takes priority mode.
   // To put different, the tiling set can't require tiles for activation if
   // we're in smoothness mode and only used low-res or checkerboard to draw last
   // frame and we don't need high res to draw.
   //
   // The reason for this is that we should be able to activate sooner and get a
   // more up to date recording, so we don't run out of recording on the active
   // tree.
-  bool can_require_tiles_for_activation =
-      !only_used_low_res_last_append_quads_ || RequiresHighResToDraw() ||
-      !layer_tree_impl()->SmoothnessTakesPriority();
+  // A layer must be a drawing layer for it to require tiles for activation.
+  bool can_require_tiles_for_activation = false;
+  if (contributes_to_drawn_render_surface()) {
+    can_require_tiles_for_activation =
+        !only_used_low_res_last_append_quads_ || RequiresHighResToDraw() ||
+        !layer_tree_impl()->SmoothnessTakesPriority();
+  }
 
   static const Occlusion kEmptyOcclusion;
   const Occlusion& occlusion_in_content_space =
       layer_tree_impl()->settings().use_occlusion_for_tile_prioritization
           ? draw_properties().occlusion_in_content_space
           : kEmptyOcclusion;
 
   // Pass |occlusion_in_content_space| for |occlusion_in_layer_space| since
   // they are the same space in picture layer, as contents scale is always 1.
   bool updated = tilings_->UpdateTilePriorities(
@@ skipping 920 matching lines @@
 
 WhichTree PictureLayerImpl::GetTree() const {
   return layer_tree_impl()->IsActiveTree() ? ACTIVE_TREE : PENDING_TREE;
 }
 
 bool PictureLayerImpl::IsOnActiveOrPendingTree() const {
   return !layer_tree_impl()->IsRecycleTree();
 }
 
 bool PictureLayerImpl::HasValidTilePriorities() const {
-  return IsOnActiveOrPendingTree() && (contributes_to_drawn_render_surface() ||
-                                       raster_even_if_not_in_rsll());
+  return IsOnActiveOrPendingTree() &&
+         (contributes_to_drawn_render_surface() || raster_even_if_not_drawn());
 }
 
 void PictureLayerImpl::InvalidateRegionForImages(
     const PaintImageIdFlatSet& images_to_invalidate) {
   TRACE_EVENT_BEGIN0("cc", "PictureLayerImpl::InvalidateRegionForImages");
 
   InvalidationRegion image_invalidation;
   for (auto image_id : images_to_invalidate)
     image_invalidation.Union(raster_source_->GetRectForImage(image_id));
   Region invalidation;
   image_invalidation.Swap(&invalidation);
 
   if (invalidation.IsEmpty()) {
     TRACE_EVENT_END1("cc", "PictureLayerImpl::InvalidateRegionForImages",
                      "Invalidation", invalidation.ToString());
     return;
   }
 
   invalidation_.Union(invalidation);
   tilings_->UpdateTilingsForImplSideInvalidation(invalidation);
   SetNeedsPushProperties();
   TRACE_EVENT_END1("cc", "PictureLayerImpl::InvalidateRegionForImages",
                    "Invalidation", invalidation.ToString());
 }
 
 }  // namespace cc