Cache viewport rect for tile priority in UpdateTiles

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 <algorithm>
 #include <limits>
 #include <set>
 #include <utility>
@@ skipping 410 matching lines @@
                                         viewport_rect_for_tile_priority,
                                         transform_for_tile_priority,
                                         resourceless_software_draw);
   host_impl_.active_tree()->UpdateDrawProperties();
 
   gfx::Rect viewport_rect_for_tile_priority_in_view_space =
       viewport_rect_for_tile_priority;
 
   // Verify the viewport rect for tile priority is used in picture layer tiling.
   EXPECT_EQ(viewport_rect_for_tile_priority_in_view_space,
-            active_layer_->GetViewportForTilePriorityInContentSpace());
+            active_layer_->viewport_rect_for_tile_priority_in_content_space());
   PictureLayerTilingSet* tilings = active_layer_->tilings();
   for (size_t i = 0; i < tilings->num_tilings(); i++) {
     PictureLayerTiling* tiling = tilings->tiling_at(i);
     EXPECT_EQ(
         tiling->GetCurrentVisibleRectForTesting(),
         gfx::ScaleToEnclosingRect(viewport_rect_for_tile_priority_in_view_space,
                                   tiling->contents_scale()));
   }
 
   // Update tiles with viewport for tile priority as (200, 200, 100, 100) in
@@ skipping 21 matching lines @@
 
   // Note that we don't clip this to the layer bounds, since it is expected that
   // the rect will sometimes be outside of the layer bounds. If we clip to
   // bounds, then tile priorities will end up being incorrect in cases of fully
   // offscreen layer.
   viewport_rect_for_tile_priority_in_view_space =
       gfx::ToEnclosingRect(MathUtil::ProjectClippedRect(
           screen_to_view, viewport_rect_for_tile_priority));
 
   EXPECT_EQ(viewport_rect_for_tile_priority_in_view_space,
-            active_layer_->GetViewportForTilePriorityInContentSpace());
+            active_layer_->viewport_rect_for_tile_priority_in_content_space());
   tilings = active_layer_->tilings();
   for (size_t i = 0; i < tilings->num_tilings(); i++) {
     PictureLayerTiling* tiling = tilings->tiling_at(i);
     EXPECT_EQ(
         tiling->GetCurrentVisibleRectForTesting(),
         gfx::ScaleToEnclosingRect(viewport_rect_for_tile_priority_in_view_space,
                                   tiling->contents_scale()));
   }
 }
 
@@ skipping 73 matching lines @@
                                         viewport,
                                         transform,
                                         resourceless_software_draw);
   active_layer_->UpdateTiles(Occlusion(), resourceless_software_draw);
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(transform,
                                   active_layer_->screen_space_transform());
   EXPECT_EQ(viewport, active_layer_->visible_rect_for_tile_priority());
 }
 
+TEST_F(PictureLayerImplTest, ViewportRectForTilePriorityIsCached) {
+  base::TimeTicks time_ticks;
+  time_ticks += base::TimeDelta::FromMilliseconds(1);
+  host_impl_.SetCurrentBeginFrameArgs(
+      CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, time_ticks));
+  gfx::Size tile_size(100, 100);
+  gfx::Size layer_bounds(400, 400);
+
+  scoped_refptr<FakePicturePileImpl> pending_pile =
+      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
+  scoped_refptr<FakePicturePileImpl> active_pile =
+      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
+
+  SetupTreesWithInvalidation(pending_pile, active_pile, Region());
+
+  SetupDrawPropertiesAndUpdateTiles(active_layer_, 1.f, 1.f, 1.f, 1.f, false);
+
+  time_ticks += base::TimeDelta::FromMilliseconds(200);
+  host_impl_.SetCurrentBeginFrameArgs(
+      CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, time_ticks));
+
+  bool resourceless_software_draw = false;
+  gfx::Rect viewport = gfx::Rect(layer_bounds);
+  gfx::Rect viewport_rect_for_tile_priority(0, 0, 100, 100);
+  gfx::Transform transform, transform_for_tile_priority;
+
+  host_impl_.SetExternalDrawConstraints(
+      transform, viewport, viewport, viewport_rect_for_tile_priority,
+      transform_for_tile_priority, resourceless_software_draw);
+  host_impl_.active_tree()->UpdateDrawProperties();
+
+  EXPECT_EQ(viewport_rect_for_tile_priority,
+            active_layer_->viewport_rect_for_tile_priority_in_content_space());
+
+  time_ticks += base::TimeDelta::FromMilliseconds(200);
+  host_impl_.SetCurrentBeginFrameArgs(
+      CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, time_ticks));
+
+  gfx::Rect another_viewport_rect_for_tile_priority(11, 11, 50, 50);
+  host_impl_.SetExternalDrawConstraints(
+      transform, viewport, viewport, another_viewport_rect_for_tile_priority,
+      transform_for_tile_priority, resourceless_software_draw);
+
+  // Didn't call UpdateDrawProperties yet. The viewport rect for tile priority
+  // should remain to be the previously cached value.
+  EXPECT_EQ(viewport_rect_for_tile_priority,
+            active_layer_->viewport_rect_for_tile_priority_in_content_space());
+  host_impl_.active_tree()->UpdateDrawProperties();
+
+  // Now the UpdateDrawProperties is called. The viewport rect for tile
+  // priority should be the latest value.
+  EXPECT_EQ(another_viewport_rect_for_tile_priority,
+            active_layer_->viewport_rect_for_tile_priority_in_content_space());
+}
+
 TEST_F(PictureLayerImplTest, ClonePartialInvalidation) {
   gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(400, 400);
   gfx::Rect layer_invalidation(150, 200, 30, 180);
 
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
   scoped_refptr<FakePicturePileImpl> active_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
   scoped_refptr<FakePicturePileImpl> lost_pile =
@@ skipping 1097 matching lines @@
   // external_viewport_for_tile_priority.
   pending_layer_->draw_properties().visible_content_rect = visible_content_rect;
   time_ticks += base::TimeDelta::FromMilliseconds(200);
   host_impl_.SetCurrentBeginFrameArgs(
       CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, time_ticks));
   pending_layer_->UpdateTiles(Occlusion(), resourceless_software_draw);
 
   // Intersect the two rects. Any tile outside should not be required for
   // activation.
   gfx::Rect viewport_for_tile_priority =
-      pending_layer_->GetViewportForTilePriorityInContentSpace();
+      pending_layer_->viewport_rect_for_tile_priority_in_content_space();
   viewport_for_tile_priority.Intersect(pending_layer_->visible_content_rect());
 
   int num_inside = 0;
   int num_outside = 0;
   for (PictureLayerTiling::CoverageIterator iter(
            pending_layer_->HighResTiling(), 1.f, gfx::Rect(layer_bounds));
        iter; ++iter) {
     if (!*iter)
       continue;
     Tile* tile = *iter;
@@ skipping 3129 matching lines @@
   result = layer->CalculateTileSize(gfx::Size(447, 400));
   EXPECT_EQ(result.width(), 448);
   EXPECT_EQ(result.height(), 448);
   result = layer->CalculateTileSize(gfx::Size(500, 499));
   EXPECT_EQ(result.width(), 512);
   EXPECT_EQ(result.height(), 500 + 2);
 }
 
 }  // namespace
 }  // namespace cc