Re-raster during scale animations for GPU-rasterized layers without text

This re-rasters GPU-rasterized layers during scale animations in order to
keep content crisp, but only for layers that don't have text (since
re-rastering text at different scales leads to expensive glyph texture
uploads at each scale).

BUG=395760,372391

Review URL: https://codereview.chromium.org/422233008

Cr-Commit-Position: refs/heads/master@{#291068}
git-svn-id: svn://svn.chromium.org/chrome/trunk/src@291068 0039d316-1c4b-4281-b951-d872f2087c98

cc/layers/picture_layer_impl.cc

@@ -1046,6 +1046,11 @@ bool PictureLayerImpl::ShouldAdjustRasterScale() const {
       draw_properties().screen_space_transform_is_animating)
     return true;
 
+  if (draw_properties().screen_space_transform_is_animating &&
+      raster_contents_scale_ != ideal_contents_scale_ &&
+      ShouldAdjustRasterScaleDuringScaleAnimations())
+    return true;
+
   bool is_pinching = layer_tree_impl()->PinchGestureActive();
   if (is_pinching && raster_page_scale_) {
     // We change our raster scale when it is:
@@ -1140,11 +1145,12 @@ void PictureLayerImpl::RecalculateRasterScales() {
   raster_contents_scale_ =
       std::max(raster_contents_scale_, MinimumContentsScale());
 
-  // Since we're not re-rasterizing during animation, rasterize at the maximum
+  // If we're not re-rasterizing during animation, rasterize at the maximum
   // scale that will occur during the animation, if the maximum scale is
   // known. However, to avoid excessive memory use, don't rasterize at a scale
   // at which this layer would become larger than the viewport.
-  if (draw_properties().screen_space_transform_is_animating) {
+  if (draw_properties().screen_space_transform_is_animating &&
+      !ShouldAdjustRasterScaleDuringScaleAnimations()) {
     bool can_raster_at_maximum_scale = false;
     if (draw_properties().maximum_animation_contents_scale > 0.f) {
       gfx::Size bounds_at_maximum_scale = gfx::ToCeiledSize(gfx::ScaleSize(
@@ -1322,6 +1328,22 @@ void PictureLayerImpl::SanityCheckTilingState() const {
 #endif
 }
 
+bool PictureLayerImpl::ShouldAdjustRasterScaleDuringScaleAnimations() const {
+  if (!layer_tree_impl()->use_gpu_rasterization())
+    return false;
+
+  // Re-rastering text at different scales using GPU rasterization causes
+  // texture uploads for glyphs at each scale (see crbug.com/366225). To
+  // workaround this performance issue, we don't re-rasterize layers with
+  // text during scale animations.
+  // TODO(ajuma): Remove this workaround once text can be efficiently
+  // re-rastered at different scales (e.g. by using distance-field fonts).
+  if (pile_->has_text())
+    return false;
+
+  return true;
+}
+
 float PictureLayerImpl::MaximumTilingContentsScale() const {
   float max_contents_scale = MinimumContentsScale();
   for (size_t i = 0; i < tilings_->num_tilings(); ++i) {

cc/layers/picture_layer_impl.h

@@ -184,6 +184,8 @@ class CC_EXPORT PictureLayerImpl
   bool CanHaveTilingWithScale(float contents_scale) const;
   void SanityCheckTilingState() const;
 
+  bool ShouldAdjustRasterScaleDuringScaleAnimations() const;
+
   virtual void GetDebugBorderProperties(
       SkColor* color, float* width) const OVERRIDE;
   virtual void AsValueInto(base::debug::TracedValue* dict) const OVERRIDE;

cc/layers/picture_layer_impl_unittest.cc

@@ -2234,6 +2234,111 @@ TEST_F(PictureLayerImplTest, HighResTilingDuringAnimationForCpuRasterization) {
   EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 11.f);
 }
 
+TEST_F(PictureLayerImplTest, HighResTilingDuringAnimationForGpuRasterization) {
+  gfx::Size layer_bounds(100, 100);
+  gfx::Size viewport_size(1000, 1000);
+  SetupDefaultTrees(layer_bounds);
+  host_impl_.SetViewportSize(viewport_size);
+  host_impl_.SetUseGpuRasterization(true);
+
+  float contents_scale = 1.f;
+  float device_scale = 1.3f;
+  float page_scale = 1.4f;
+  float maximum_animation_scale = 1.f;
+  bool animating_transform = false;
+
+  SetContentsScaleOnBothLayers(contents_scale,
+                               device_scale,
+                               page_scale,
+                               maximum_animation_scale,
+                               animating_transform);
+  EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 1.f);
+
+  // Since we're GPU-rasterizing, starting an animation should cause tiling
+  // resolution to get set to the current contents scale.
+  animating_transform = true;
+  contents_scale = 2.f;
+  maximum_animation_scale = 4.f;
+
+  SetContentsScaleOnBothLayers(contents_scale,
+                               device_scale,
+                               page_scale,
+                               maximum_animation_scale,
+                               animating_transform);
+  EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 2.f);
+
+  // Further changes to scale during the animation should cause a new high-res
+  // tiling to get created.
+  contents_scale = 3.f;
+
+  SetContentsScaleOnBothLayers(contents_scale,
+                               device_scale,
+                               page_scale,
+                               maximum_animation_scale,
+                               animating_transform);
+  EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 3.f);
+
+  // Since we're re-rasterizing during the animation, scales smaller than 1
+  // should be respected.
+  contents_scale = 0.25f;
+
+  SetContentsScaleOnBothLayers(contents_scale,
+                               device_scale,
+                               page_scale,
+                               maximum_animation_scale,
+                               animating_transform);
+  EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 0.25f);
+
+  // Once we stop animating, a new high-res tiling should be created.
+  contents_scale = 4.f;
+  animating_transform = false;
+
+  SetContentsScaleOnBothLayers(contents_scale,
+                               device_scale,
+                               page_scale,
+                               maximum_animation_scale,
+                               animating_transform);
+  EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 4.f);
+
+  static_cast<FakePicturePileImpl*>(pending_layer_->pile())->set_has_text(true);
+  static_cast<FakePicturePileImpl*>(active_layer_->pile())->set_has_text(true);
+
+  // Since we're GPU-rasterizing but have text, starting an animation should
+  // cause tiling resolution to get set to the maximum animation scale.
+  animating_transform = true;
+  contents_scale = 2.f;
+  maximum_animation_scale = 3.f;
+
+  SetContentsScaleOnBothLayers(contents_scale,
+                               device_scale,
+                               page_scale,
+                               maximum_animation_scale,
+                               animating_transform);
+  EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 3.f);
+
+  // Further changes to scale during the animation should not cause a new
+  // high-res tiling to get created.
+  contents_scale = 4.f;
+  maximum_animation_scale = 5.f;
+
+  SetContentsScaleOnBothLayers(contents_scale,
+                               device_scale,
+                               page_scale,
+                               maximum_animation_scale,
+                               animating_transform);
+  EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 3.f);
+
+  // Once we stop animating, a new high-res tiling should be created.
+  animating_transform = false;
+
+  SetContentsScaleOnBothLayers(contents_scale,
+                               device_scale,
+                               page_scale,
+                               maximum_animation_scale,
+                               animating_transform);
+  EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 4.f);
+}
+
 TEST_F(PictureLayerImplTest, LayerRasterTileIterator) {
   gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(1000, 1000);

cc/resources/picture.cc

@@ -217,6 +217,11 @@ bool Picture::IsSuitableForGpuRasterization() const {
   return picture_->suitableForGpuRasterization(NULL);
 }
 
+bool Picture::HasText() const {
+  DCHECK(picture_);
+  return picture_->hasText();
+}
+
 void Picture::CloneForDrawing(int num_threads) {
   TRACE_EVENT1("cc", "Picture::CloneForDrawing", "num_threads", num_threads);
 

cc/resources/picture.h

@@ -75,6 +75,8 @@ class CC_EXPORT Picture
 
   bool IsSuitableForGpuRasterization() const;
 
+  bool HasText() const;
+
   // Apply this scale and raster the negated region into the canvas.
   // |negated_content_region| specifies the region to be clipped out of the
   // raster operation, i.e., the parts of the canvas which will not get drawn

cc/resources/picture_pile.cc

@@ -371,6 +371,7 @@ bool PicturePile::UpdateAndExpandInvalidation(
         // the pile after each invalidation.
         is_suitable_for_gpu_rasterization_ &=
             picture->IsSuitableForGpuRasterization();
+        has_text_ |= picture->HasText();
         base::TimeDelta duration =
             stats_instrumentation->EndRecording(start_time);
         best_duration = std::min(duration, best_duration);

cc/resources/picture_pile_base.cc

@@ -47,7 +47,8 @@ PicturePileBase::PicturePileBase()
       contents_fill_bounds_completely_(false),
       show_debug_picture_borders_(false),
       clear_canvas_with_debug_color_(kDefaultClearCanvasSetting),
-      has_any_recordings_(false) {
+      has_any_recordings_(false),
+      has_text_(false) {
   tiling_.SetMaxTextureSize(gfx::Size(kBasePictureSize, kBasePictureSize));
   tile_grid_info_.fTileInterval.setEmpty();
   tile_grid_info_.fMargin.setEmpty();
@@ -67,7 +68,9 @@ PicturePileBase::PicturePileBase(const PicturePileBase* other)
       contents_fill_bounds_completely_(other->contents_fill_bounds_completely_),
       show_debug_picture_borders_(other->show_debug_picture_borders_),
       clear_canvas_with_debug_color_(other->clear_canvas_with_debug_color_),
-      has_any_recordings_(other->has_any_recordings_) {}
+      has_any_recordings_(other->has_any_recordings_),
+      has_text_(other->has_text_) {
+}
 
 PicturePileBase::PicturePileBase(const PicturePileBase* other,
                                  unsigned thread_index)
@@ -82,7 +85,8 @@ PicturePileBase::PicturePileBase(const PicturePileBase* other,
       contents_fill_bounds_completely_(other->contents_fill_bounds_completely_),
       show_debug_picture_borders_(other->show_debug_picture_borders_),
       clear_canvas_with_debug_color_(other->clear_canvas_with_debug_color_),
-      has_any_recordings_(other->has_any_recordings_) {
+      has_any_recordings_(other->has_any_recordings_),
+      has_text_(other->has_text_) {
   for (PictureMap::const_iterator it = other->picture_map_.begin();
        it != other->picture_map_.end();
        ++it) {

cc/resources/picture_pile_base.h

@@ -49,6 +49,9 @@ class CC_EXPORT PicturePileBase : public base::RefCounted<PicturePileBase> {
   // If this pile contains any valid recordings. May have false positives.
   bool HasRecordings() const { return has_any_recordings_; }
 
+  // If this pile has ever contained any recordings with text.
+  bool has_text() const { return has_text_; }
+
   static void ComputeTileGridInfo(const gfx::Size& tile_grid_size,
                                   SkTileGridFactory::TileGridInfo* info);
 
@@ -117,6 +120,7 @@ class CC_EXPORT PicturePileBase : public base::RefCounted<PicturePileBase> {
   // A hint about whether there are any recordings. This may be a false
   // positive.
   bool has_any_recordings_;
+  bool has_text_;
 
  private:
   void SetBufferPixels(int buffer_pixels);

cc/test/fake_picture_pile_impl.h

@@ -68,6 +68,8 @@ class FakePicturePileImpl : public PicturePileImpl {
     clear_canvas_with_debug_color_ = clear;
   }
 
+  void set_has_text(bool has_text) { has_text_ = has_text; }
+
  protected:
   FakePicturePileImpl();
   virtual ~FakePicturePileImpl();