cc: Early out of UpdateTiles for resoureceless draw

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 249 matching lines @@
 
     pending_layer_ = static_cast<FakePictureLayerImpl*>(
         host_impl_.pending_tree()->LayerById(id_));
 
     // Add tilings/tiles for the layer.
     bool update_lcd_text = false;
     RebuildPropertyTreesOnPendingTree();
     host_impl_.pending_tree()->UpdateDrawProperties(update_lcd_text);
   }
 
-  void SetupDrawPropertiesAndUpdateTiles(
-      FakePictureLayerImpl* layer,
-      float ideal_contents_scale,
-      float device_scale_factor,
-      float page_scale_factor,
-      float maximum_animation_contents_scale,
-      float starting_animation_contents_scale,
-      bool animating_transform_to_screen) {
+  void SetupDrawProperties(FakePictureLayerImpl* layer,
+                           float ideal_contents_scale,
+                           float device_scale_factor,
+                           float page_scale_factor,
+                           float maximum_animation_contents_scale,
+                           float starting_animation_contents_scale,
+                           bool animating_transform_to_screen) {
     layer->layer_tree_impl()->SetDeviceScaleFactor(device_scale_factor);
     host_impl_.active_tree()->SetPageScaleOnActiveTree(page_scale_factor);
 
     gfx::Transform scale_transform;
     scale_transform.Scale(ideal_contents_scale, ideal_contents_scale);
     layer->draw_properties().target_space_transform = scale_transform;
     DCHECK_EQ(layer->GetIdealContentsScale(), ideal_contents_scale);
     layer->draw_properties().maximum_animation_contents_scale =
         maximum_animation_contents_scale;
     layer->draw_properties().starting_animation_contents_scale =
         starting_animation_contents_scale;
     layer->draw_properties().screen_space_transform_is_animating =
         animating_transform_to_screen;
-    bool resourceless_software_draw = false;
-    layer->UpdateTiles(resourceless_software_draw);
   }
+
+  void SetupDrawPropertiesAndUpdateTiles(
+      FakePictureLayerImpl* layer,
+      float ideal_contents_scale,
+      float device_scale_factor,
+      float page_scale_factor,
+      float maximum_animation_contents_scale,
+      float starting_animation_contents_scale,
+      bool animating_transform_to_screen) {
+    SetupDrawProperties(layer, ideal_contents_scale, device_scale_factor,
+                        page_scale_factor, maximum_animation_contents_scale,
+                        starting_animation_contents_scale,
+                        animating_transform_to_screen);
+    layer->UpdateTiles();
+  }
+
   static void VerifyAllPrioritizedTilesExistAndHaveRasterSource(
       const PictureLayerTiling* tiling,
       DisplayListRasterSource* raster_source) {
     auto prioritized_tiles =
         tiling->UpdateAndGetAllPrioritizedTilesForTesting();
     for (PictureLayerTiling::CoverageIterator iter(
              tiling,
              tiling->contents_scale(),
              gfx::Rect(tiling->tiling_size()));
          iter;
@@ skipping 235 matching lines @@
   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()));
   }
 }
 
-TEST_F(PictureLayerImplTest, InvalidViewportForPrioritizingTiles) {
-  host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
-  gfx::Size layer_bounds(400, 400);
-  SetupDefaultTrees(layer_bounds);
-
-  SetupDrawPropertiesAndUpdateTiles(active_layer_, 1.f, 1.f, 1.f, 1.f, 0.f,
-                                    false);
-
-  // UpdateTiles with valid viewport. Should update tile viewport.
-  // Note viewport is considered invalid if and only if in resourceless
-  // software draw.
-  bool resourceless_software_draw = false;
-  gfx::Rect viewport = gfx::Rect(layer_bounds);
-  gfx::Transform draw_transform;
-  gfx::Transform tile_priority_transform;
-  host_impl_.SetExternalTilePriorityConstraints(viewport,
-                                                tile_priority_transform);
-  active_layer_->draw_properties().visible_layer_rect = viewport;
-  active_layer_->draw_properties().screen_space_transform = draw_transform;
-  active_layer_->UpdateTiles(resourceless_software_draw);
-
-  gfx::Rect visible_rect_for_tile_priority =
-      active_layer_->visible_rect_for_tile_priority();
-  EXPECT_FALSE(visible_rect_for_tile_priority.IsEmpty());
-  gfx::Transform screen_space_transform_for_tile_priority =
-      active_layer_->draw_properties().screen_space_transform;
-
-  // Expand viewport and set it as invalid for prioritizing tiles.
-  // Should update viewport and transform, but not update visible rect.
-  host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(200));
-  resourceless_software_draw = true;
-  viewport = gfx::ScaleToEnclosingRect(viewport, 2);
-  tile_priority_transform.Translate(1.f, 0.f);
-  draw_transform.Translate(0.f, 1.f);
-  active_layer_->draw_properties().visible_layer_rect = viewport;
-  active_layer_->draw_properties().screen_space_transform = draw_transform;
-  host_impl_.SetExternalTilePriorityConstraints(viewport,
-                                                tile_priority_transform);
-  active_layer_->UpdateTiles(resourceless_software_draw);
-
-  // Transform for tile priority is not updated.
-  EXPECT_TRANSFORMATION_MATRIX_EQ(
-      screen_space_transform_for_tile_priority,
-      active_layer_->screen_space_transform_for_tile_priority());
-  // Visible rect for tile priority retains old value.
-  EXPECT_EQ(visible_rect_for_tile_priority,
-            active_layer_->visible_rect_for_tile_priority());
-  ASSERT_GT(active_layer_->picture_layer_tiling_set()->num_tilings(), 0u);
-  EXPECT_EQ(active_layer_->viewport_rect_for_tile_priority_in_content_space(),
-            active_layer_->picture_layer_tiling_set()
-                ->tiling_at(0)
-                ->GetCurrentVisibleRectForTesting());
-
-  // Keep expanded viewport but mark it valid. Should update tile viewport.
-  host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(200));
-  resourceless_software_draw = false;
-  host_impl_.SetExternalTilePriorityConstraints(viewport,
-                                                tile_priority_transform);
-  active_layer_->UpdateTiles(resourceless_software_draw);
-
-  EXPECT_TRANSFORMATION_MATRIX_EQ(
-      draw_transform,
-      active_layer_->screen_space_transform_for_tile_priority());
-  EXPECT_EQ(viewport, active_layer_->visible_rect_for_tile_priority());
-
-  gfx::RectF visible_rect_in_content_space(viewport);
-  gfx::Transform inverse_draw_transform;
-  gfx::Transform inverse_tile_priority_transform;
-  EXPECT_TRUE(draw_transform.GetInverse(&inverse_draw_transform));
-  EXPECT_TRUE(
-      tile_priority_transform.GetInverse(&inverse_tile_priority_transform));
-  visible_rect_in_content_space = MathUtil::ProjectClippedRect(
-      inverse_tile_priority_transform, visible_rect_in_content_space);
-  visible_rect_in_content_space = MathUtil::ProjectClippedRect(
-      inverse_draw_transform, visible_rect_in_content_space);
-
-  ASSERT_GT(active_layer_->picture_layer_tiling_set()->num_tilings(), 0u);
-  EXPECT_EQ(gfx::ToEnclosingRect(visible_rect_in_content_space),
-            active_layer_->picture_layer_tiling_set()
-                ->tiling_at(0)
-                ->GetCurrentVisibleRectForTesting());
-}
-
 TEST_F(PictureLayerImplTest, ViewportRectForTilePriorityIsCached) {
   host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
   gfx::Size layer_bounds(400, 400);
   SetupDefaultTrees(layer_bounds);
 
   SetupDrawPropertiesAndUpdateTiles(active_layer_, 1.f, 1.f, 1.f, 1.f, 0.f,
                                     false);
 
   host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(200));
 
@@ skipping 1162 matching lines @@
   // tilings.
   ActivateTree();
   EXPECT_TRUE(active_layer_->CanHaveTilings());
   EXPECT_GT(active_layer_->ideal_contents_scale(), 0.f);
 }
 
 TEST_F(NoLowResPictureLayerImplTest, MarkRequiredOffscreenTiles) {
   gfx::Size layer_bounds(200, 200);
 
   gfx::Transform transform;
-  bool resourceless_software_draw = false;
   gfx::Rect viewport(0, 0, 100, 200);
   host_impl_.SetExternalTilePriorityConstraints(viewport, transform);
 
   scoped_refptr<FakeDisplayListRasterSource> pending_raster_source =
       FakeDisplayListRasterSource::CreateFilled(layer_bounds);
   SetupPendingTreeWithFixedTileSize(pending_raster_source, gfx::Size(100, 100),
                                     Region());
 
   EXPECT_EQ(1u, pending_layer_->num_tilings());
   EXPECT_EQ(viewport,
             pending_layer_->viewport_rect_for_tile_priority_in_content_space());
 
   base::TimeTicks time_ticks;
   host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
-  pending_layer_->UpdateTiles(resourceless_software_draw);
+  pending_layer_->UpdateTiles();
 
   int num_visible = 0;
   int num_offscreen = 0;
 
   scoped_ptr<TilingSetRasterQueueAll> queue(new TilingSetRasterQueueAll(
       pending_layer_->picture_layer_tiling_set(), false));
   for (; !queue->IsEmpty(); queue->Pop()) {
     const PrioritizedTile& prioritized_tile = queue->Top();
     DCHECK(prioritized_tile.tile());
     if (prioritized_tile.priority().distance_to_visible == 0.f) {
@@ skipping 20 matching lines @@
 
   SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size, Region());
 
   ASSERT_EQ(1u, pending_layer_->num_tilings());
   ASSERT_EQ(1.f, pending_layer_->HighResTiling()->contents_scale());
 
   // Set external viewport for tile priority.
   gfx::Rect viewport = gfx::Rect(layer_bounds);
   gfx::Transform transform;
   gfx::Transform transform_for_tile_priority;
-  bool resourceless_software_draw = false;
   host_impl_.SetExternalTilePriorityConstraints(
       external_viewport_for_tile_priority, transform_for_tile_priority);
   host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
   bool update_lcd_text = false;
   host_impl_.pending_tree()->UpdateDrawProperties(update_lcd_text);
 
   // Set visible content rect that is different from
   // external_viewport_for_tile_priority.
   pending_layer_->draw_properties().visible_layer_rect = visible_layer_rect;
   host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(200));
-  pending_layer_->UpdateTiles(resourceless_software_draw);
+  pending_layer_->UpdateTiles();
 
   // Intersect the two rects. Any tile outside should not be required for
   // activation.
   gfx::Rect viewport_for_tile_priority =
       pending_layer_->viewport_rect_for_tile_priority_in_content_space();
   viewport_for_tile_priority.Intersect(pending_layer_->visible_layer_rect());
 
   EXPECT_TRUE(pending_layer_->HighResTiling()->AllTilesForTesting().empty());
 
   int num_inside = 0;
@@ skipping 1208 matching lines @@
 
   // All of the high res tiles should be required for activation, since there is
   // no active twin.
   EXPECT_EQ(high_res_now_tiles, required_for_activation_count);
 
   // No NOW tiles.
   host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(200));
 
   pending_layer_->draw_properties().visible_layer_rect =
       gfx::Rect(1100, 1100, 500, 500);
-  bool resourceless_software_draw = false;
-  pending_layer_->UpdateTiles(resourceless_software_draw);
+  pending_layer_->UpdateTiles();
 
   unique_tiles.clear();
   high_res_tile_count = 0u;
   queue.reset(new TilingSetRasterQueueAll(
       pending_layer_->picture_layer_tiling_set(), false));
   while (!queue->IsEmpty()) {
     PrioritizedTile prioritized_tile = queue->Top();
     TilePriority priority = prioritized_tile.priority();
 
     EXPECT_TRUE(prioritized_tile.tile());
 
     // Non-high res tiles only get visible tiles.
     EXPECT_EQ(HIGH_RESOLUTION, priority.resolution);
     EXPECT_NE(TilePriority::NOW, priority.priority_bin);
 
     high_res_tile_count += priority.resolution == HIGH_RESOLUTION;
 
     unique_tiles.insert(prioritized_tile.tile());
     queue->Pop();
   }
 
   EXPECT_EQ(16, high_res_tile_count);
   EXPECT_EQ(high_res_tile_count, static_cast<int>(unique_tiles.size()));
 
   host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(200));
 
   pending_layer_->draw_properties().visible_layer_rect =
       gfx::Rect(0, 0, 500, 500);
-  pending_layer_->UpdateTiles(resourceless_software_draw);
+  pending_layer_->UpdateTiles();
 
   std::vector<Tile*> high_res_tiles =
       pending_layer_->HighResTiling()->AllTilesForTesting();
   for (std::vector<Tile*>::iterator tile_it = high_res_tiles.begin();
        tile_it != high_res_tiles.end();
        ++tile_it) {
     Tile* tile = *tile_it;
     TileDrawInfo& draw_info = tile->draw_info();
     draw_info.SetSolidColorForTesting(SK_ColorRED);
   }
@@ skipping 511 matching lines @@
   // need content in order to activate.
   pending_layer_->HighResTiling()->UpdateAllRequiredStateForTesting();
   if (host_impl_.settings().create_low_res_tiling)
     pending_layer_->LowResTiling()->UpdateAllRequiredStateForTesting();
 
   AssertNoTilesRequired(pending_layer_->HighResTiling());
   if (host_impl_.settings().create_low_res_tiling)
     AssertNoTilesRequired(pending_layer_->LowResTiling());
 }
 
-TEST_F(NoLowResPictureLayerImplTest, InvalidViewportForPrioritizingTiles) {
-  host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
-  gfx::Size layer_bounds(400, 400);
-  SetupDefaultTrees(layer_bounds);
-
-  SetupDrawPropertiesAndUpdateTiles(active_layer_, 1.f, 1.f, 1.f, 1.f, 0.f,
-                                    false);
-
-  // UpdateTiles with valid viewport. Should update tile viewport.
-  // Note viewport is considered invalid if and only if in resourceless
-  // software draw.
-  bool resourceless_software_draw = false;
-  gfx::Rect viewport = gfx::Rect(layer_bounds);
-  gfx::Transform transform;
-  host_impl_.SetExternalTilePriorityConstraints(viewport, transform);
-  active_layer_->draw_properties().visible_layer_rect = viewport;
-  active_layer_->draw_properties().screen_space_transform = transform;
-  active_layer_->UpdateTiles(resourceless_software_draw);
-
-  gfx::Rect visible_rect_for_tile_priority =
-      active_layer_->visible_rect_for_tile_priority();
-  EXPECT_FALSE(visible_rect_for_tile_priority.IsEmpty());
-  gfx::Transform screen_space_transform_for_tile_priority =
-      active_layer_->draw_properties().screen_space_transform;
-
-  // Expand viewport and set it as invalid for prioritizing tiles.
-  // Should update viewport and transform, but not update visible rect.
-  host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(200));
-  resourceless_software_draw = true;
-  viewport = gfx::ScaleToEnclosingRect(viewport, 2);
-  transform.Translate(1.f, 1.f);
-  active_layer_->draw_properties().visible_layer_rect = viewport;
-  active_layer_->draw_properties().screen_space_transform = transform;
-  host_impl_.SetExternalTilePriorityConstraints(viewport, transform);
-  active_layer_->UpdateTiles(resourceless_software_draw);
-
-  // Transform for tile priority is updated.
-  EXPECT_TRANSFORMATION_MATRIX_EQ(
-      transform, active_layer_->draw_properties().screen_space_transform);
-  // Visible rect for tile priority retains old value.
-  EXPECT_EQ(visible_rect_for_tile_priority,
-            active_layer_->visible_rect_for_tile_priority());
-
-  // Keep expanded viewport but mark it valid. Should update tile viewport.
-  host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(200));
-  resourceless_software_draw = false;
-  host_impl_.SetExternalTilePriorityConstraints(viewport, transform);
-  active_layer_->UpdateTiles(resourceless_software_draw);
-
-  EXPECT_TRANSFORMATION_MATRIX_EQ(
-      transform, active_layer_->draw_properties().screen_space_transform);
-  EXPECT_EQ(viewport, active_layer_->visible_rect_for_tile_priority());
-}
-
 TEST_F(NoLowResPictureLayerImplTest, CleanUpTilings) {
   gfx::Size layer_bounds(1300, 1900);
   std::vector<PictureLayerTiling*> used_tilings;
   SetupDefaultTrees(layer_bounds);
 
   float low_res_factor = host_impl_.settings().low_res_contents_scale_factor;
   EXPECT_LT(low_res_factor, 1.f);
 
   float device_scale = 1.7f;
   float page_scale = 3.2f;
@@ skipping 1380 matching lines @@
   // New low res tiling.
   EXPECT_TRUE(tilings->tiling_at(2)->may_contain_low_resolution_tiles());
 
   // This tiling will be high res now, it won't contain low res content since it
   // was all destroyed.
   EXPECT_FALSE(tilings->tiling_at(1)->may_contain_low_resolution_tiles());
 }
 
 }  // namespace
 }  // namespace cc