[5/5] Add translated rasterization for PictureLayerImpl

cc/layers/picture_layer_impl_unittest.cc

 // Copyright 2013 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 <algorithm>
 #include <limits>
@@ skipping 399 matching lines @@
       FakeRasterSource::CreateFilled(layer_bounds);
   scoped_refptr<FakeRasterSource> active_raster_source =
       FakeRasterSource::CreateFilled(layer_bounds);
   scoped_refptr<FakeRasterSource> lost_raster_source =
       FakeRasterSource::CreateFilled(layer_bounds);
 
   SetupPendingTreeWithFixedTileSize(lost_raster_source, gfx::Size(50, 50),
                                     Region());
   ActivateTree();
   // Add a unique tiling on the active tree.
-  PictureLayerTiling* tiling = active_layer()->AddTiling(3.f);
+  PictureLayerTiling* tiling =
+      active_layer()->AddTiling(ScaleTranslate2d(3.f, gfx::Vector2dF()));
   tiling->set_resolution(HIGH_RESOLUTION);
   tiling->CreateAllTilesForTesting();
 
   // Ensure UpdateTiles won't remove any tilings.
   active_layer()->MarkAllTilingsUsed();
 
   // Then setup a new pending tree and activate it.
   SetupTreesWithFixedTileSize(pending_raster_source, active_raster_source,
                               gfx::Size(50, 50), layer_invalidation);
 
@@ skipping 3491 matching lines @@
   pending_layer()->test_properties()->AddChild(
       LayerImpl::Create(host_impl()->pending_tree(), 1));
   LayerImpl* layer1 = pending_layer()->test_properties()->children[0];
   layer1->SetBounds(layer_bounds);
   layer1->SetDrawsContent(true);
   layer1->SetContentsOpaque(true);
   layer1->SetPosition(occluding_layer_position);
 
   pending_layer()->tilings()->RemoveAllTilings();
   float low_res_factor = host_impl()->settings().low_res_contents_scale_factor;
-  pending_layer()->AddTiling(low_res_factor)->set_resolution(LOW_RESOLUTION);
-  pending_layer()->AddTiling(0.3f)->set_resolution(HIGH_RESOLUTION);
-  pending_layer()->AddTiling(0.7f)->set_resolution(HIGH_RESOLUTION);
-  pending_layer()->AddTiling(1.0f)->set_resolution(HIGH_RESOLUTION);
-  pending_layer()->AddTiling(2.0f)->set_resolution(HIGH_RESOLUTION);
+  pending_layer()
+      ->AddTiling(ScaleTranslate2d(low_res_factor, gfx::Vector2dF()))
+      ->set_resolution(LOW_RESOLUTION);
+  pending_layer()
+      ->AddTiling(ScaleTranslate2d(0.3f, gfx::Vector2dF()))
+      ->set_resolution(HIGH_RESOLUTION);
+  pending_layer()
+      ->AddTiling(ScaleTranslate2d(0.7f, gfx::Vector2dF()))
+      ->set_resolution(HIGH_RESOLUTION);
+  pending_layer()
+      ->AddTiling(ScaleTranslate2d(1.0f, gfx::Vector2dF()))
+      ->set_resolution(HIGH_RESOLUTION);
+  pending_layer()
+      ->AddTiling(ScaleTranslate2d(2.0f, gfx::Vector2dF()))
+      ->set_resolution(HIGH_RESOLUTION);
 
   RebuildPropertyTreesOnPendingTree();
   host_impl()->AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
   // UpdateDrawProperties with the occluding layer.
   bool update_lcd_text = false;
   host_impl()->pending_tree()->UpdateDrawProperties(update_lcd_text);
 
   EXPECT_EQ(5u, pending_layer()->num_tilings());
 
   int occluded_tile_count = 0;
@@ skipping 1021 matching lines @@
     SetupDrawPropertiesAndUpdateTiles(pending_layer_ptr, ideal_contents_scale,
                                       1.f, 1.f, 1.f, 1.f, false);
     EXPECT_FLOAT_EQ(expected_contents_scale,
                     pending_layer_ptr->picture_layer_tiling_set()
                         ->FindTilingWithResolution(HIGH_RESOLUTION)
                         ->contents_scale_key())
         << "ideal_contents_scale: " << ideal_contents_scale;
   }
 }
 
+TEST_F(PictureLayerImplTest, ChangeRasterTranslationNukePendingLayerTiles) {
+  gfx::Size layer_bounds(200, 200);
+  gfx::Size tile_size(256, 256);
+  SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size, Region());
+  pending_layer()->SetUseTransformedRasterization(true);
+
+  // Start with scale & translation of * 2.25 + (0.25, 0.5).
+  SetupDrawProperties(pending_layer(), 2.25f, 1.5f, 1.f, 2.25f, 2.25f, false);
+  gfx::Transform translate1;
+  translate1.Translate(0.25f, 0.5f);
+  pending_layer()->draw_properties().screen_space_transform.ConcatTransform(
+      translate1);
+  pending_layer()->draw_properties().target_space_transform =
+      pending_layer()->draw_properties().screen_space_transform;
+  pending_layer()->UpdateTiles();
+  ASSERT_EQ(1u, pending_layer()->tilings()->num_tilings());
+  {
+    PictureLayerTiling* tiling = pending_layer()->tilings()->tiling_at(0);
+    EXPECT_EQ(ScaleTranslate2d(2.25f, gfx::Vector2dF(0.25f, 0.5f)),
+              tiling->raster_transform());
+    EXPECT_EQ(4u, tiling->AllTilesForTesting().size());
+    // Mark some arbitrary flags on the tiles for later checking.

[enne (OOO), 2017/03/29 13:28:59]

Are you trying to make sure that these tiles are the same tiles? Maybe create a
set of tiles and compare below?  This seems a little fragile, especially since
you're not testing that solid color analysis performed is false to start.

[trchen, 2017/03/30 21:48:47]

Yes. Okay I'll try if I can inject some fingerprinted tiles...

[trchen, 2017/03/30 22:40:47]

Actually the tiles remember its raster transform at creation. I'll just check
that instead.

+    for (auto* tile : tiling->AllTilesForTesting())
+      tile->set_solid_color_analysis_performed(true);
+  }
+
+  // Change to scale & translation of * 2.25 + (0.75, 0.25).
+  // Verifies there is a hysteresis that simple layer movement doesn't update
+  // raster translation.
+  SetupDrawProperties(pending_layer(), 2.25f, 1.5f, 1.f, 2.25f, 2.25f, false);
+  gfx::Transform translate2;
+  translate2.Translate(0.75f, 0.25f);
+  pending_layer()->draw_properties().screen_space_transform.ConcatTransform(
+      translate2);
+  pending_layer()->draw_properties().target_space_transform =
+      pending_layer()->draw_properties().screen_space_transform;
+  pending_layer()->UpdateTiles();
+  ASSERT_EQ(1u, pending_layer()->tilings()->num_tilings());
+  {
+    PictureLayerTiling* tiling = pending_layer()->tilings()->tiling_at(0);
+    EXPECT_EQ(ScaleTranslate2d(2.25f, gfx::Vector2dF(0.25f, 0.5f)),
+              tiling->raster_transform());
+    EXPECT_EQ(4u, tiling->AllTilesForTesting().size());
+    for (auto* tile : tiling->AllTilesForTesting())
+      EXPECT_TRUE(tile->is_solid_color_analysis_performed());
+  }
+
+  // Now change the device scale factor but keep the same total scale.
+  // Verifies the old tiles get evicted due to slot conflict.

[enne (OOO), 2017/03/29 13:28:59]

What does this mean?

[trchen, 2017/03/30 21:48:47]

The layer property change is significant enough to trigger raster scale
recomputation. The policy then also recomputes raster translation.

In this case the new raster scale remains the same as the old one, but the
raster translation changed. Ideally if we can create a set of tiles with the new
translation as ideal tile, while keeping the old ones as a backup, but there is
a slot conflict due to only scale is used as the key.

I just realized the tiles would be evicted no matter what, since pending layer
only keeps ideal tiles. I should change the comments to just say the old tiles
are gone for being non-ideal. 

[trchen, 2017/03/30 22:40:47]

Done.

+  SetupDrawProperties(pending_layer(), 2.25f, 1.0f, 1.f, 2.25f, 2.25f, false);
+  pending_layer()->draw_properties().screen_space_transform.ConcatTransform(
+      translate2);
+  pending_layer()->draw_properties().target_space_transform =
+      pending_layer()->draw_properties().screen_space_transform;
+  pending_layer()->UpdateTiles();
+  ASSERT_EQ(1u, pending_layer()->tilings()->num_tilings());
+  {
+    PictureLayerTiling* tiling = pending_layer()->tilings()->tiling_at(0);
+    EXPECT_EQ(ScaleTranslate2d(2.25f, gfx::Vector2dF(0.75f, 0.25f)),
+              tiling->raster_transform());
+    EXPECT_EQ(4u, tiling->AllTilesForTesting().size());
+    for (auto* tile : tiling->AllTilesForTesting())
+      EXPECT_FALSE(tile->is_solid_color_analysis_performed());
+  }
+}
+
+TEST_F(PictureLayerImplTest, ChangeRasterTranslationNukeActiveLayerTiles) {
+  gfx::Size layer_bounds(200, 200);
+  gfx::Size tile_size(256, 256);
+  SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size, Region());
+  active_layer()->SetUseTransformedRasterization(true);
+  pending_layer()->SetUseTransformedRasterization(true);
+
+  // Start with scale & translation of * 2.25 + (0.25, 0.5) on the active layer.
+  SetupDrawProperties(active_layer(), 2.25f, 1.5f, 1.f, 2.25f, 2.25f, false);
+  gfx::Transform translate1;
+  translate1.Translate(0.25f, 0.5f);
+  active_layer()->draw_properties().screen_space_transform.ConcatTransform(
+      translate1);
+  active_layer()->draw_properties().target_space_transform =
+      active_layer()->draw_properties().screen_space_transform;
+  active_layer()->UpdateTiles();
+  ASSERT_EQ(3u, active_layer()->tilings()->num_tilings());
+  {
+    PictureLayerTiling* tiling =
+        active_layer()->tilings()->FindTilingWithScaleKey(2.25f);
+    EXPECT_EQ(ScaleTranslate2d(2.25f, gfx::Vector2dF(0.25f, 0.5f)),
+              tiling->raster_transform());
+    EXPECT_EQ(4u, tiling->AllTilesForTesting().size());
+    // Mark some arbitrary flags on the tiles for later checking.
+    for (auto* tile : tiling->AllTilesForTesting())
+      tile->set_solid_color_analysis_performed(true);
+  }
+
+  // Create a pending layer with the same scale but different translation.
+  SetupDrawProperties(pending_layer(), 2.25f, 1.5f, 1.f, 2.25f, 2.25f, false);
+  gfx::Transform translate2;
+  translate2.Translate(0.75f, 0.25f);
+  pending_layer()->draw_properties().screen_space_transform.ConcatTransform(
+      translate2);
+  pending_layer()->draw_properties().target_space_transform =
+      pending_layer()->draw_properties().screen_space_transform;
+  pending_layer()->UpdateTiles();
+  ASSERT_EQ(1u, pending_layer()->tilings()->num_tilings());
+  {
+    PictureLayerTiling* tiling = pending_layer()->tilings()->tiling_at(0);
+    EXPECT_EQ(ScaleTranslate2d(2.25f, gfx::Vector2dF(0.75f, 0.25f)),
+              tiling->raster_transform());
+    EXPECT_EQ(4u, tiling->AllTilesForTesting().size());
+  }
+
+  // Now push to the active layer.
+  // Verifies the active tiles get evicted due to slot conflict.

[enne (OOO), 2017/03/29 13:28:59]

I'm a little unclear what the behavior is here.  If the translation changes on
one tree, the tiles are kept.  But there's no coordination between pending and
active about raster scale? So...composited animations don't cause reraster but
non-composited animations do?  Or, high res recreates if the translation
changes, but not non-ideal scales?

Can you provide a summary of what the heuristics are for rerastering? I feel
like I've forgotten the discussions we've had in terms of what the goals are
here.

[trchen, 2017/03/30 21:48:47]

The general goal is to make indirectly composited layers have similar quality,
while having no-worse performance than non-composited layers.

The heuristics is to not updating raster translation if not updating raster
scale. However if raster scale gets recomputed but the result is the same, still
update raster translation and evict the old tiles if translation changed.

Yea I agree this policy is weird, but should be pretty safe in terms of
performance.

[enne (OOO), 2017/03/30 21:55:23]

Thanks for the reminder that this is indirectly composited content.  The author
doesn't expect translation to be fast here, so it's ok to reraster between
different source frames.  Sounds good.  Maybe it'd be good to leave a comment
about this nearer to the heuristics so other people can understand the
motivations here?

[enne (OOO), 2017/03/30 21:55:23]

Thanks for the reminder that this is indirectly composited content.  The author
doesn't expect translation to be fast here, so it's ok to reraster between
different source frames.  Sounds good.  Maybe it'd be good to leave a comment
about this nearer to the heuristics so other people can understand the
motivations here?

[trchen, 2017/03/30 22:40:47]

Done.

+  host_impl()->ActivateSyncTree();
+  ASSERT_EQ(3u, active_layer()->tilings()->num_tilings());
+  {
+    PictureLayerTiling* tiling =
+        active_layer()->tilings()->FindTilingWithScaleKey(2.25f);
+    EXPECT_EQ(ScaleTranslate2d(2.25f, gfx::Vector2dF(0.75f, 0.25f)),
+              tiling->raster_transform());
+    EXPECT_EQ(4u, tiling->AllTilesForTesting().size());
+    for (auto* tile : tiling->AllTilesForTesting())
+      EXPECT_FALSE(tile->is_solid_color_analysis_performed());
+  }
+}
+
 }  // namespace
 }  // namespace cc