cc: Remove fixed raster scale, stop rasterizing with will-change.

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 51 matching lines @@
 PictureLayerImpl::PictureLayerImpl(LayerTreeImpl* tree_impl,
                                    int id,
                                    bool is_mask)
     : LayerImpl(tree_impl, id),
       twin_layer_(nullptr),
       tilings_(CreatePictureLayerTilingSet()),
       ideal_page_scale_(0.f),
       ideal_device_scale_(0.f),
       ideal_source_scale_(0.f),
       ideal_contents_scale_(0.f),
-      last_ideal_source_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_screen_space_transform_animating_(false),
       only_used_low_res_last_append_quads_(false),
       is_mask_(is_mask),
       nearest_neighbor_(false) {
   layer_tree_impl()->RegisterPictureLayerImpl(this);
 }
 
 PictureLayerImpl::~PictureLayerImpl() {
   if (twin_layer_)
     twin_layer_->twin_layer_ = nullptr;
@@ skipping 338 matching lines @@
   if (layer_tree_impl()->IsActiveTree())
     CleanUpTilingsOnActiveLayer(last_append_quads_tilings_);
 
   UpdateIdealScales();
 
   if (!raster_contents_scale_ || ShouldAdjustRasterScale()) {
     RecalculateRasterScales();
     AddTilingsForRasterScale();
   }
 
-  // Inform layer tree impl if we will have blurry content because of fixed
-  // raster scale (note that this check should happen after we
-  // ReclaculateRasterScales, since that's the function that will determine
-  // whether our raster scale is fixed.
-  if (raster_source_scale_is_fixed_ && !has_will_change_transform_hint()) {
-    if (raster_source_scale_ != ideal_source_scale_)
-      layer_tree_impl()->SetFixedRasterScaleHasBlurryContent();
-    if (ideal_source_scale_ != last_ideal_source_scale_)
-      layer_tree_impl()->SetFixedRasterScaleAttemptedToChangeScale();
-  }
-
   if (layer_tree_impl()->IsActiveTree())
     AddLowResolutionTilingIfNeeded();
 
   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_ =
@@ skipping 450 matching lines @@
   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 (!draw_properties().screen_space_transform_is_animating &&
-      !raster_source_scale_is_fixed_ &&
-      raster_source_scale_ != ideal_source_scale_)
-    return true;
-
   if (raster_contents_scale_ > MaximumContentsScale())
     return true;
   if (raster_contents_scale_ < MinimumContentsScale())
     return true;
 
-  return false;
+  // Don't change the raster scale if any of the following are true:
+  //  - We have an animating transform.
+  //  - We have a will-change transform hint.
+  //  - The raster scale is already ideal.
+  if (draw_properties().screen_space_transform_is_animating ||
+      has_will_change_transform_hint() ||
+      raster_source_scale_ == ideal_source_scale_) {
+    return false;
+  }
+
+  // Match the raster scale in all other cases.
+  return true;
 }
 
 void PictureLayerImpl::AddLowResolutionTilingIfNeeded() {
   DCHECK(layer_tree_impl()->IsActiveTree());
 
   if (!layer_tree_impl()->create_low_res_tiling())
     return;
 
   // We should have a high resolution tiling at raster_contents_scale, so if the
   // low res one is the same then we shouldn't try to override this tiling by
@@ skipping 13 matching lines @@
   if (!is_pinching && !is_animating) {
     if (!low_res)
       low_res = AddTiling(low_res_raster_contents_scale_);
     low_res->set_resolution(LOW_RESOLUTION);
   }
 }
 
 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 &&
-      !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. (crbug.com/413636)
-  if (raster_source_scale_is_fixed_) {
-    raster_contents_scale_ /= raster_source_scale_;
-    raster_source_scale_ = 1.f;
-  }
-
   // During pinch we completely ignore the current ideal scale, and just use
   // a multiple of the previous scale.
   bool is_pinching = layer_tree_impl()->PinchGestureActive();
   if (is_pinching && old_raster_contents_scale) {
     // See ShouldAdjustRasterScale:
     // - When zooming out, preemptively create new tiling at lower resolution.
     // - When zooming in, approximate ideal using multiple of kMaxScaleRatio.
     bool zooming_out = old_raster_page_scale > ideal_page_scale_;
     float desired_contents_scale = old_raster_contents_scale;
     if (zooming_out) {
@@ skipping 150 matching lines @@
   // up larger than |max_texture_size|.
   return nextafterf(max_scale, 0.f);
 }
 
 void PictureLayerImpl::ResetRasterScale() {
   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;
 }
 
 bool PictureLayerImpl::CanHaveTilings() const {
   if (raster_source_->IsSolidColor())
     return false;
   if (!DrawsContent())
     return false;
   if (!raster_source_->HasRecordings())
     return false;
   // If the |raster_source_| has a recording it should have non-empty bounds.
@@ skipping 41 matching lines @@
   DCHECK(CanHaveTilings());
 
   float min_contents_scale = MinimumContentsScale();
   DCHECK_GT(min_contents_scale, 0.f);
 
   ideal_page_scale_ = IsAffectedByPageScale()
                           ? layer_tree_impl()->current_page_scale_factor()
                           : 1.f;
   ideal_device_scale_ = layer_tree_impl()->device_scale_factor();
   ideal_contents_scale_ = std::max(GetIdealContentsScale(), min_contents_scale);
-  last_ideal_source_scale_ = ideal_source_scale_;
   ideal_source_scale_ =
       ideal_contents_scale_ / ideal_page_scale_ / ideal_device_scale_;
 }
 
 void PictureLayerImpl::GetDebugBorderProperties(
     SkColor* color,
     float* width) const {
   *color = DebugColors::TiledContentLayerBorderColor();
   *width = DebugColors::TiledContentLayerBorderWidth(layer_tree_impl());
 }
@@ skipping 59 matching lines @@
 bool PictureLayerImpl::IsOnActiveOrPendingTree() const {
   return !layer_tree_impl()->IsRecycleTree();
 }
 
 bool PictureLayerImpl::HasValidTilePriorities() const {
   return IsOnActiveOrPendingTree() &&
          is_drawn_render_surface_layer_list_member();
 }
 
 }  // namespace cc