cc: Don't add new tilings while syncing a tiling.

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 43 matching lines @@
       ideal_page_scale_(0.f),
       ideal_device_scale_(0.f),
       ideal_source_scale_(0.f),
       ideal_contents_scale_(0.f),
       raster_page_scale_(0.f),
       raster_device_scale_(0.f),
       raster_source_scale_(0.f),
       raster_contents_scale_(0.f),
       low_res_raster_contents_scale_(0.f),
       raster_source_scale_is_fixed_(false),
-      was_animating_transform_to_screen_(false),
+      was_screen_space_transform_animating_(false),
       needs_post_commit_initialization_(true),
       should_update_tile_priorities_(false) {
   layer_tree_impl()->RegisterPictureLayerImpl(this);
 }
 
 PictureLayerImpl::~PictureLayerImpl() {
   layer_tree_impl()->UnregisterPictureLayerImpl(this);
 }
 
 const char* PictureLayerImpl::LayerTypeAsString() const {
@@ skipping 305 matching lines @@
                          on_demand_missing_tile_count);
   }
 
   // Aggressively remove any tilings that are not seen to save memory. Note
   // 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");
+void PictureLayerImpl::UpdateTiles() {
+  TRACE_EVENT0("cc", "PictureLayerImpl::UpdateTiles");
 
   DoPostCommitInitializationIfNeeded();
 
   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;
   }
 
+  UpdateIdealScales();
+
+  DCHECK(tilings_->num_tilings() > 0 || raster_contents_scale_ == 0.f)
+      << "A layer with no tilings shouldn't have valid raster scales";
+  if (!raster_contents_scale_ || ShouldAdjustRasterScale()) {
+    RecalculateRasterScales();
+    AddTilingsForRasterScale();
+  }
+
+  DCHECK(raster_page_scale_);
+  DCHECK(raster_device_scale_);
+  DCHECK(raster_source_scale_);
+  DCHECK(raster_contents_scale_);
+  DCHECK(low_res_raster_contents_scale_);
+
+  was_screen_space_transform_animating_ =
+      draw_properties().screen_space_transform_is_animating;
+
   // 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);
+  UpdateTilePriorities();
 
-  if (!tilings_->num_tilings())
-    return;
+  if (layer_tree_impl()->IsPendingTree())
+    MarkVisibleResourcesAsRequired();
+}
+
+void PictureLayerImpl::UpdateTilePriorities() {
+  TRACE_EVENT0("cc", "PictureLayerImpl::UpdateTilePriorities");
 
   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(
             current_frame_time_in_seconds)) {
       tiling_needs_update = true;
@@ skipping 14 matching lines @@
           gfx::ToEnclosingRect(MathUtil::ProjectClippedRect(
               screen_to_layer, gfx::Rect(viewport_size_for_tile_priority_)));
       visible_rect_in_content_space.Intersect(gfx::Rect(content_bounds()));
     }
   }
 
   gfx::Rect visible_layer_rect = gfx::ScaleToEnclosingRect(
       visible_rect_in_content_space, 1.f / contents_scale_x());
   WhichTree tree =
       layer_tree_impl()->IsActiveTree() ? ACTIVE_TREE : PENDING_TREE;
-  // TODO(sohanjg): Passing MaximumContentsScale as layer contents scale
-  // in UpdateTilePriorities is wrong and should be ideal contents scale.
-  tilings_->UpdateTilePriorities(tree,
-                                 visible_layer_rect,
-                                 MaximumTilingContentsScale(),
-                                 current_frame_time_in_seconds);
-
-  if (layer_tree_impl()->IsPendingTree())
-    MarkVisibleResourcesAsRequired();
+  for (size_t i = 0; i < tilings_->num_tilings(); ++i) {
+    // TODO(sohanjg): Passing MaximumContentsScale as layer contents scale
+    // in UpdateTilePriorities is wrong and should be ideal contents scale.
+    tilings_->tiling_at(i)->UpdateTilePriorities(tree,
+                                                 visible_layer_rect,
+                                                 MaximumTilingContentsScale(),
+                                                 current_frame_time_in_seconds);
+  }
 
   // Tile priorities were modified.
   layer_tree_impl()->DidModifyTilePriorities();
 }
 
 void PictureLayerImpl::NotifyTileStateChanged(const Tile* tile) {
   if (layer_tree_impl()->IsActiveTree()) {
     gfx::RectF layer_damage_rect =
         gfx::ScaleRect(tile->content_rect(), 1.f / tile->contents_scale());
     AddDamageRect(layer_damage_rect);
@@ skipping 246 matching lines @@
       iter->GetTileVersionForDrawing();
   if (!tile_version.IsReadyToDraw() ||
       tile_version.mode() != ManagedTileState::TileVersion::RESOURCE_MODE)
     return 0;
 
   return tile_version.get_resource_id();
 }
 
 void PictureLayerImpl::MarkVisibleResourcesAsRequired() const {
   DCHECK(layer_tree_impl()->IsPendingTree());
-  DCHECK(!layer_tree_impl()->needs_update_draw_properties());
   DCHECK(ideal_contents_scale_);
   DCHECK_GT(tilings_->num_tilings(), 0u);
 
   // The goal of this function is to find the minimum set of tiles that need to
   // be ready to draw in order to activate without flashing content from a
   // higher res on the active tree to a lower res on the pending tree.
 
   // First, early out for layers with no visible content.
   if (visible_content_rect().IsEmpty())
     return;
@@ skipping 193 matching lines @@
 namespace {
 
 inline float PositiveRatio(float float1, float float2) {
   DCHECK_GT(float1, 0);
   DCHECK_GT(float2, 0);
   return float1 > float2 ? float1 / float2 : float2 / float1;
 }
 
 }  // namespace
 
-void PictureLayerImpl::ManageTilings(bool animating_transform_to_screen,
-                                     float maximum_animation_contents_scale) {
-  DCHECK(ideal_contents_scale_);
-  DCHECK(ideal_page_scale_);
-  DCHECK(ideal_device_scale_);
-  DCHECK(ideal_source_scale_);
-  DCHECK(CanHaveTilings());
-  DCHECK(!needs_post_commit_initialization_);
-
-  bool change_target_tiling =
-      raster_page_scale_ == 0.f ||
-      raster_device_scale_ == 0.f ||
-      raster_source_scale_ == 0.f ||
-      raster_contents_scale_ == 0.f ||
-      low_res_raster_contents_scale_ == 0.f ||
-      ShouldAdjustRasterScale(animating_transform_to_screen);
-
-  if (tilings_->num_tilings() == 0) {
-    DCHECK(change_target_tiling)
-        << "A layer with no tilings shouldn't have valid raster scales";
-  }
-
-  if (change_target_tiling) {
-    RecalculateRasterScales(animating_transform_to_screen,
-                            maximum_animation_contents_scale);
-  }
-
-  was_animating_transform_to_screen_ = animating_transform_to_screen;
-
-  if (!change_target_tiling)
-    return;
-
+void PictureLayerImpl::AddTilingsForRasterScale() {
   PictureLayerTiling* high_res = NULL;
   PictureLayerTiling* low_res = NULL;
 
   PictureLayerTiling* previous_low_res = NULL;
   for (size_t i = 0; i < tilings_->num_tilings(); ++i) {
     PictureLayerTiling* tiling = tilings_->tiling_at(i);
     if (tiling->contents_scale() == raster_contents_scale_)
       high_res = tiling;
     if (tiling->contents_scale() == low_res_raster_contents_scale_)
       low_res = tiling;
     if (tiling->resolution() == LOW_RESOLUTION)
       previous_low_res = tiling;
 
     // Reset all tilings to non-ideal until the end of this function.
     tiling->set_resolution(NON_IDEAL_RESOLUTION);
   }
 
   if (!high_res) {
     high_res = AddTiling(raster_contents_scale_);
     if (raster_contents_scale_ == low_res_raster_contents_scale_)
       low_res = high_res;
   }
 
   // Only create new low res tilings when the transform is static.  This
   // prevents wastefully creating a paired low res tiling for every new high res
   // tiling during a pinch or a CSS animation.
   bool is_pinching = layer_tree_impl()->PinchGestureActive();
   if (layer_tree_impl()->create_low_res_tiling() && !is_pinching &&
-      !animating_transform_to_screen && !low_res && low_res != high_res)
+      !draw_properties().screen_space_transform_is_animating && !low_res &&
+      low_res != high_res)
     low_res = AddTiling(low_res_raster_contents_scale_);
 
   // Set low-res if we have one.
   if (!low_res)
     low_res = previous_low_res;
   if (low_res && low_res != high_res)
     low_res->set_resolution(LOW_RESOLUTION);
 
   // Make sure we always have one high-res (even if high == low).
   high_res->set_resolution(HIGH_RESOLUTION);
 
   SanityCheckTilingState();
 }
 
-bool PictureLayerImpl::ShouldAdjustRasterScale(
-    bool animating_transform_to_screen) const {
-  if (was_animating_transform_to_screen_ != animating_transform_to_screen)
+bool PictureLayerImpl::ShouldAdjustRasterScale() const {
+  if (was_screen_space_transform_animating_ !=
+      draw_properties().screen_space_transform_is_animating)
     return true;
 
   bool is_pinching = layer_tree_impl()->PinchGestureActive();
   if (is_pinching && raster_page_scale_) {
     // We change our raster scale when it is:
     // - Higher than ideal (need a lower-res tiling available)
     // - Too far from ideal (need a higher-res tiling available)
     float ratio = ideal_page_scale_ / raster_page_scale_;
     if (raster_page_scale_ > ideal_page_scale_ ||
         ratio > kMaxScaleRatioDuringPinch)
       return true;
   }
 
   if (!is_pinching) {
     // When not pinching, match the ideal page scale factor.
     if (raster_page_scale_ != ideal_page_scale_)
       return true;
   }
 
   // Always match the ideal device scale factor.
   if (raster_device_scale_ != ideal_device_scale_)
     return true;
 
   // When the source scale changes we want to match it, but not when animating
   // or when we've fixed the scale in place.
-  if (!animating_transform_to_screen && !raster_source_scale_is_fixed_ &&
+  if (!draw_properties().screen_space_transform_is_animating &&
+      !raster_source_scale_is_fixed_ &&
       raster_source_scale_ != ideal_source_scale_)
     return true;
 
   return false;
 }
 
 float PictureLayerImpl::SnappedContentsScale(float scale) {
   // If a tiling exists within the max snapping ratio, snap to its scale.
   float snapped_contents_scale = scale;
   float snapped_ratio = kSnapToExistingTilingRatio;
   for (size_t i = 0; i < tilings_->num_tilings(); ++i) {
     float tiling_contents_scale = tilings_->tiling_at(i)->contents_scale();
     float ratio = PositiveRatio(tiling_contents_scale, scale);
     if (ratio < snapped_ratio) {
       snapped_contents_scale = tiling_contents_scale;
       snapped_ratio = ratio;
     }
   }
   return snapped_contents_scale;
 }
 
-void PictureLayerImpl::RecalculateRasterScales(
-    bool animating_transform_to_screen,
-    float maximum_animation_contents_scale) {
+void PictureLayerImpl::RecalculateRasterScales() {
   float old_raster_contents_scale = raster_contents_scale_;
   float old_raster_page_scale = raster_page_scale_;
   float old_raster_source_scale = raster_source_scale_;
 
   raster_device_scale_ = ideal_device_scale_;
   raster_page_scale_ = ideal_page_scale_;
   raster_source_scale_ = ideal_source_scale_;
   raster_contents_scale_ = ideal_contents_scale_;
 
   // If we're not animating, or leaving an animation, and the
   // ideal_source_scale_ changes, then things are unpredictable, and we fix
   // the raster_source_scale_ in place.
-  if (old_raster_source_scale && !animating_transform_to_screen &&
-      !was_animating_transform_to_screen_ &&
+  if (old_raster_source_scale &&
+      !draw_properties().screen_space_transform_is_animating &&
+      !was_screen_space_transform_animating_ &&
       old_raster_source_scale != ideal_source_scale_)
     raster_source_scale_is_fixed_ = true;
 
   // TODO(danakj): Adjust raster source scale closer to ideal source scale at
   // a throttled rate. Possibly make use of invalidation_.IsEmpty() on pending
   // tree. This will allow CSS scale changes to get re-rastered at an
   // appropriate rate.
   if (raster_source_scale_is_fixed_) {
     raster_contents_scale_ /= raster_source_scale_;
     raster_source_scale_ = 1.f;
@@ skipping 15 matching lines @@
     raster_page_scale_ =
         raster_contents_scale_ / raster_device_scale_ / raster_source_scale_;
   }
 
   raster_contents_scale_ =
       std::max(raster_contents_scale_, MinimumContentsScale());
 
   // Since we're not re-rasterizing during animation, rasterize at the maximum
   // scale that will occur during the animation, if the maximum scale is
   // known.
-  if (animating_transform_to_screen) {
-    if (maximum_animation_contents_scale > 0.f) {
+  if (draw_properties().screen_space_transform_is_animating) {
+    if (draw_properties().maximum_animation_contents_scale > 0.f) {
       raster_contents_scale_ =
-          std::max(raster_contents_scale_, maximum_animation_contents_scale);
+          std::max(raster_contents_scale_,
+                   draw_properties().maximum_animation_contents_scale);
     } else {
       raster_contents_scale_ =
           std::max(raster_contents_scale_,
                    1.f * ideal_page_scale_ * ideal_device_scale_);
     }
   }
 
   // If this layer would only create one tile at this content scale,
   // don't create a low res tiling.
   gfx::Size content_bounds =
@@ skipping 490 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