cc: Early out sooner in UpdateTilePriorities when !CanHaveTilings().

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 <algorithm>
 #include <limits>
 
 #include "base/time/time.h"
@@ skipping 372 matching lines @@
   // that this is at the expense of doing cause more frequent re-painting. A
   // better scheme would be to maintain a tighter visible_content_rect for the
   // finer tilings.
   CleanUpTilingsOnActiveLayer(seen_tilings);
 }
 
 void PictureLayerImpl::UpdateTilePriorities() {
   TRACE_EVENT0("cc", "PictureLayerImpl::UpdateTilePriorities");
 
   DoPostCommitInitializationIfNeeded();
-  UpdateIdealScales();
-  // TODO(sohanjg): Avoid needlessly update priorities when syncing to a
-  // non-updated tree which will then be updated immediately afterwards.
-  should_update_tile_priorities_ = true;
-  if (CanHaveTilings()) {
-    ManageTilings(draw_properties().screen_space_transform_is_animating,
-                  draw_properties().maximum_animation_contents_scale);
-  }
 
   if (layer_tree_impl()->device_viewport_valid_for_tile_management()) {
     visible_rect_for_tile_priority_ = visible_content_rect();
     viewport_size_for_tile_priority_ = layer_tree_impl()->DrawViewportSize();
     screen_space_transform_for_tile_priority_ = screen_space_transform();
   }
 
+  if (!CanHaveTilings()) {
+    ideal_page_scale_ = 0.f;
+    ideal_device_scale_ = 0.f;
+    ideal_contents_scale_ = 0.f;
+    ideal_source_scale_ = 0.f;
+    SanityCheckTilingState();
+    return;
+  }
+
+  // TODO(sohanjg): Avoid needlessly update priorities when syncing to a
+  // non-updated tree which will then be updated immediately afterwards.
+  should_update_tile_priorities_ = true;
+
+  UpdateIdealScales();
+  ManageTilings(draw_properties().screen_space_transform_is_animating,
+                draw_properties().maximum_animation_contents_scale);
+
   if (!tilings_->num_tilings())
     return;
 
   double current_frame_time_in_seconds =
       (layer_tree_impl()->CurrentFrameTimeTicks() -
        base::TimeTicks()).InSecondsF();
 
   bool tiling_needs_update = false;
   for (size_t i = 0; i < tilings_->num_tilings(); ++i) {
     if (tilings_->tiling_at(i)->NeedsUpdateForFrameAtTime(
@@ skipping 740 matching lines @@
   if (tilings_->num_tilings() == 0)
     return;
 
   float min_acceptable_high_res_scale = std::min(
       raster_contents_scale_, ideal_contents_scale_);
   float max_acceptable_high_res_scale = std::max(
       raster_contents_scale_, ideal_contents_scale_);
   float twin_low_res_scale = 0.f;
 
   PictureLayerImpl* twin = twin_layer_;
-  if (twin) {
+  if (twin && twin->CanHaveTilings()) {
     min_acceptable_high_res_scale = std::min(
         min_acceptable_high_res_scale,
         std::min(twin->raster_contents_scale_, twin->ideal_contents_scale_));
     max_acceptable_high_res_scale = std::max(
         max_acceptable_high_res_scale,
         std::max(twin->raster_contents_scale_, twin->ideal_contents_scale_));
 
     for (size_t i = 0; i < twin->tilings_->num_tilings(); ++i) {
       PictureLayerTiling* tiling = twin->tilings_->tiling_at(i);
       if (tiling->resolution() == LOW_RESOLUTION)
@@ skipping 102 matching lines @@
 float PictureLayerImpl::MaximumTilingContentsScale() const {
   float max_contents_scale = MinimumContentsScale();
   for (size_t i = 0; i < tilings_->num_tilings(); ++i) {
     const PictureLayerTiling* tiling = tilings_->tiling_at(i);
     max_contents_scale = std::max(max_contents_scale, tiling->contents_scale());
   }
   return max_contents_scale;
 }
 
 void PictureLayerImpl::UpdateIdealScales() {
-  if (!CanHaveTilings()) {

[enne (OOO), 2014/06/18 23:08:02]

I kind of liked this code being in UpdateIdealScales, because then the caller
doesn't have to think about whether something can or cannot have tilings.  I
think you can still call it prior to early-outting and setting
should_update_tile_priorities=true.

[danakj, 2014/06/19 01:03:52]

ok, i can leave it there. I liked the idea of moving it because
a) removed one check for CanHaveTilings() meaning we don't have this agreement
needed between UpdateTilePrios and UpdateIdealScales anymore regarding
CanHaveTilings()
b) no early out needed in UpdateIdealScales made it simpler in my mind.

If those things don't convince you, I'm uploading a CL without moving this, so
we can do that.

-    ideal_page_scale_ = draw_properties().page_scale_factor;
-    ideal_device_scale_ = draw_properties().device_scale_factor;
-    ideal_contents_scale_ = draw_properties().ideal_contents_scale;
-    ideal_source_scale_ =
-        ideal_contents_scale_ / ideal_page_scale_ / ideal_device_scale_;
-    return;
-  }
-
   float min_contents_scale = MinimumContentsScale();
   DCHECK_GT(min_contents_scale, 0.f);
   float min_page_scale = layer_tree_impl()->min_page_scale_factor();
   DCHECK_GT(min_page_scale, 0.f);
   float min_device_scale = 1.f;
   float min_source_scale =
       min_contents_scale / min_page_scale / min_device_scale;
 
   float ideal_page_scale = draw_properties().page_scale_factor;
   float ideal_device_scale = draw_properties().device_scale_factor;
@@ skipping 327 matching lines @@
   return iterator_index_ < iterators_.size();
 }
 
 bool PictureLayerImpl::LayerEvictionTileIterator::IsCorrectType(
     PictureLayerTiling::TilingEvictionTileIterator* it) const {
   return it->get_type() == iteration_stage_ &&
          (**it)->required_for_activation() == required_for_activation_;
 }
 
 }  // namespace cc