cc: Rename visible_content_rect and content stuff on quads.

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 525 matching lines @@
   // software draw.
   bool resourceless_software_draw = false;
   gfx::Rect viewport = gfx::Rect(layer_bounds);
   gfx::Transform transform;
   host_impl_.SetExternalDrawConstraints(transform,
                                         viewport,
                                         viewport,
                                         viewport,
                                         transform,
                                         resourceless_software_draw);
-  active_layer_->draw_properties().visible_content_rect = viewport;
+  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_->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_content_rect = viewport;
+  active_layer_->draw_properties().visible_layer_rect = viewport;
   active_layer_->draw_properties().screen_space_transform = transform;
   host_impl_.SetExternalDrawConstraints(transform,
                                         viewport,
                                         viewport,
                                         viewport,
                                         transform,
                                         resourceless_software_draw);
   active_layer_->UpdateTiles(resourceless_software_draw);
 
   // Transform for tile priority is updated.
@@ skipping 1041 matching lines @@
   gfx::Size layer_bounds(1300, 1900);
 
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
   scoped_refptr<FakePicturePileImpl> active_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
   gfx::Rect layer_invalidation(150, 200, 30, 180);
   SetupTreesWithInvalidation(pending_pile, active_pile, layer_invalidation);
 
-  active_layer_->draw_properties().visible_content_rect =
-      gfx::Rect(layer_bounds);
+  active_layer_->draw_properties().visible_layer_rect = gfx::Rect(layer_bounds);
 
   AppendQuadsData data;
   active_layer_->WillDraw(DRAW_MODE_RESOURCELESS_SOFTWARE, nullptr);
   active_layer_->AppendQuads(render_pass.get(), &data);
   active_layer_->DidDraw(nullptr);
 
   ASSERT_EQ(1U, render_pass->quad_list.size());
   EXPECT_EQ(DrawQuad::PICTURE_CONTENT,
             render_pass->quad_list.front()->material);
 }
 
 TEST_F(PictureLayerImplTest, SolidColorLayerHasVisibleFullCoverage) {
   scoped_ptr<RenderPass> render_pass = RenderPass::Create();
 
   gfx::Size tile_size(1000, 1000);
   gfx::Size layer_bounds(1500, 1500);
   gfx::Rect visible_rect(250, 250, 1000, 1000);
 
   scoped_ptr<FakePicturePile> empty_recording =
       FakePicturePile::CreateEmptyPile(tile_size, layer_bounds);
   empty_recording->SetIsSolidColor(true);
 
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFromPile(empty_recording.get(), nullptr);
   scoped_refptr<FakePicturePileImpl> active_pile =
       FakePicturePileImpl::CreateFromPile(empty_recording.get(), nullptr);
 
   SetupTrees(pending_pile, active_pile);
 
-  active_layer_->draw_properties().visible_content_rect = visible_rect;
+  active_layer_->draw_properties().visible_layer_rect = visible_rect;
 
   AppendQuadsData data;
   active_layer_->WillDraw(DRAW_MODE_SOFTWARE, nullptr);
   active_layer_->AppendQuads(render_pass.get(), &data);
   active_layer_->DidDraw(nullptr);
 
   Region remaining = visible_rect;
   for (const auto& quad : render_pass->quad_list) {
     EXPECT_TRUE(visible_rect.Contains(quad->rect));
     EXPECT_TRUE(remaining.Contains(quad->rect));
@@ skipping 71 matching lines @@
   EXPECT_GT(num_offscreen, 0);
 }
 
 TEST_F(NoLowResPictureLayerImplTest,
        TileOutsideOfViewportForTilePriorityNotRequired) {
   host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
 
   gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(400, 400);
   gfx::Rect external_viewport_for_tile_priority(400, 200);
-  gfx::Rect visible_content_rect(200, 400);
+  gfx::Rect visible_layer_rect(200, 400);
 
   scoped_refptr<FakePicturePileImpl> active_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
   SetupTreesWithFixedTileSize(pending_pile, active_pile, 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_.SetExternalDrawConstraints(transform,
                                         viewport,
                                         viewport,
                                         external_viewport_for_tile_priority,
                                         transform_for_tile_priority,
                                         resourceless_software_draw);
   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_content_rect = visible_content_rect;
+  pending_layer_->draw_properties().visible_layer_rect = visible_layer_rect;
   host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(200));
   pending_layer_->UpdateTiles(resourceless_software_draw);
 
   // 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_content_rect());
+  viewport_for_tile_priority.Intersect(pending_layer_->visible_layer_rect());
 
   EXPECT_TRUE(pending_layer_->HighResTiling()->AllTilesForTesting().empty());
 
   int num_inside = 0;
   int num_outside = 0;
   for (PictureLayerTiling::CoverageIterator iter(active_layer_->HighResTiling(),
                                                  1.f, gfx::Rect(layer_bounds));
        iter; ++iter) {
     if (!*iter)
       continue;
     Tile* tile = *iter;
     if (viewport_for_tile_priority.Intersects(iter.geometry_rect())) {
       num_inside++;
       // Mark everything in viewport for tile priority as ready to draw.
       TileDrawInfo& draw_info = tile->draw_info();
       draw_info.SetSolidColorForTesting(SK_ColorRED);
     } else {
       num_outside++;
       EXPECT_FALSE(tile->required_for_activation());
     }
   }
 
   EXPECT_GT(num_inside, 0);
   EXPECT_GT(num_outside, 0);
 
   // Activate and draw active layer.
   host_impl_.ActivateSyncTree();
   host_impl_.active_tree()->UpdateDrawProperties(update_lcd_text);
-  active_layer_->draw_properties().visible_content_rect = visible_content_rect;
+  active_layer_->draw_properties().visible_layer_rect = visible_layer_rect;
 
   scoped_ptr<RenderPass> render_pass = RenderPass::Create();
   AppendQuadsData data;
   active_layer_->WillDraw(DRAW_MODE_SOFTWARE, nullptr);
   active_layer_->AppendQuads(render_pass.get(), &data);
   active_layer_->DidDraw(nullptr);
 
   // All tiles in activation rect is ready to draw.
   EXPECT_EQ(0u, data.num_missing_tiles);
   EXPECT_EQ(0u, data.num_incomplete_tiles);
@@ skipping 1085 matching lines @@
     required_queue->Pop();
   }
 
   // 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_content_rect =
+  pending_layer_->draw_properties().visible_layer_rect =
       gfx::Rect(1100, 1100, 500, 500);
   bool resourceless_software_draw = false;
   pending_layer_->UpdateTiles(resourceless_software_draw);
 
   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_content_rect =
+  pending_layer_->draw_properties().visible_layer_rect =
       gfx::Rect(0, 0, 500, 500);
   pending_layer_->UpdateTiles(resourceless_software_draw);
 
   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();
@@ skipping 99 matching lines @@
   }
 
   std::set<Tile*> all_tiles_set(all_tiles.begin(), all_tiles.end());
 
   bool mark_required = false;
   size_t number_of_marked_tiles = 0u;
   size_t number_of_unmarked_tiles = 0u;
   for (size_t i = 0; i < pending_layer_->num_tilings(); ++i) {
     PictureLayerTiling* tiling = pending_layer_->tilings()->tiling_at(i);
     for (PictureLayerTiling::CoverageIterator iter(
-             tiling, 1.f, pending_layer_->visible_content_rect());
+             tiling, 1.f, pending_layer_->visible_layer_rect());
          iter; ++iter) {
       if (mark_required) {
         number_of_marked_tiles++;
         iter->set_required_for_activation(true);
       } else {
         number_of_unmarked_tiles++;
       }
       mark_required = !mark_required;
     }
   }
@@ skipping 122 matching lines @@
     gfx::Rect occluded;
     impl.AppendQuadsWithOcclusion(active_layer_, occluded);
 
     LayerTestCommon::VerifyQuadsExactlyCoverRect(impl.quad_list(),
                                                  gfx::Rect(layer_bounds));
     EXPECT_EQ(100u, impl.quad_list().size());
   }
 
   {
     SCOPED_TRACE("Full occlusion");
-    gfx::Rect occluded(active_layer_->visible_content_rect());
+    gfx::Rect occluded(active_layer_->visible_layer_rect());
     impl.AppendQuadsWithOcclusion(active_layer_, occluded);
 
     LayerTestCommon::VerifyQuadsExactlyCoverRect(impl.quad_list(), gfx::Rect());
     EXPECT_EQ(impl.quad_list().size(), 0u);
   }
 
   {
     SCOPED_TRACE("Partial occlusion");
     gfx::Rect occluded(150, 0, 200, 1000);
     impl.AppendQuadsWithOcclusion(active_layer_, occluded);
@@ skipping 338 matching lines @@
   // software draw.
   bool resourceless_software_draw = false;
   gfx::Rect viewport = gfx::Rect(layer_bounds);
   gfx::Transform transform;
   host_impl_.SetExternalDrawConstraints(transform,
                                         viewport,
                                         viewport,
                                         viewport,
                                         transform,
                                         resourceless_software_draw);
-  active_layer_->draw_properties().visible_content_rect = viewport;
+  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_->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_content_rect = viewport;
+  active_layer_->draw_properties().visible_layer_rect = viewport;
   active_layer_->draw_properties().screen_space_transform = transform;
   host_impl_.SetExternalDrawConstraints(transform,
                                         viewport,
                                         viewport,
                                         viewport,
                                         transform,
                                         resourceless_software_draw);
   active_layer_->UpdateTiles(resourceless_software_draw);
 
   // Transform for tile priority is updated.
@@ skipping 194 matching lines @@
 
   gfx::Transform scaled_draw_transform = active_layer_->draw_transform();
   scaled_draw_transform.Scale(SK_MScalar1 / max_contents_scale,
                               SK_MScalar1 / max_contents_scale);
 
   AppendQuadsData data;
   active_layer_->AppendQuads(render_pass.get(), &data);
 
   // SharedQuadState should have be of size 1, as we are doing AppenQuad once.
   EXPECT_EQ(1u, render_pass->shared_quad_state_list.size());
-  // The content_to_target_transform should be scaled by the
+  // The quad_to_target_transform should be scaled by the
   // MaximumTilingContentsScale on the layer.
   EXPECT_EQ(scaled_draw_transform.ToString(),
             render_pass->shared_quad_state_list.front()
-                ->content_to_target_transform.ToString());
+                ->quad_to_target_transform.ToString());
   // The content_bounds should be scaled by the
   // MaximumTilingContentsScale on the layer.
-  EXPECT_EQ(
-      gfx::Size(2500u, 5000u).ToString(),
-      render_pass->shared_quad_state_list.front()->content_bounds.ToString());
-  // The visible_content_rect should be scaled by the
+  EXPECT_EQ(gfx::Size(2500u, 5000u).ToString(),
+            render_pass->shared_quad_state_list.front()
+                ->quad_layer_bounds.ToString());
+  // The visible_layer_rect should be scaled by the
   // MaximumTilingContentsScale on the layer.
   EXPECT_EQ(gfx::Rect(0u, 0u, 2500u, 5000u).ToString(),
             render_pass->shared_quad_state_list.front()
-                ->visible_content_rect.ToString());
+                ->visible_quad_layer_rect.ToString());
 }
 
 class PictureLayerImplTestWithDelegatingRenderer : public PictureLayerImplTest {
  public:
   PictureLayerImplTestWithDelegatingRenderer() : PictureLayerImplTest() {}
 
   void InitializeRenderer() override {
     host_impl_.InitializeRenderer(FakeOutputSurface::CreateDelegating3d());
   }
 };
@@ skipping 123 matching lines @@
   while (!queue->IsEmpty()) {
     PrioritizedTile prioritized_tile = queue->Top();
     Tile* tile = prioritized_tile.tile();
 
     // Occluded tiles should not be iterated over.
     EXPECT_FALSE(prioritized_tile.is_occluded());
 
     // Some tiles may not be visible (i.e. outside the viewport). The rest are
     // visible and at least partially unoccluded, verified by the above expect.
     bool tile_is_visible =
-        tile->content_rect().Intersects(pending_layer_->visible_content_rect());
+        tile->content_rect().Intersects(pending_layer_->visible_layer_rect());
     if (tile_is_visible)
       unoccluded_tile_count++;
     queue->Pop();
   }
   EXPECT_EQ(unoccluded_tile_count, 25);
 
   // Partial occlusion.
   pending_layer_->AddChild(LayerImpl::Create(host_impl_.pending_tree(), 1));
   LayerImpl* layer1 = pending_layer_->children()[0];
   layer1->SetBounds(layer_bounds);
   layer1->SetDrawsContent(true);
   layer1->SetContentsOpaque(true);
   layer1->SetPosition(occluding_layer_position);
 
   host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(200));
   bool update_lcd_text = false;
   host_impl_.pending_tree()->UpdateDrawProperties(update_lcd_text);
 
   unoccluded_tile_count = 0;
   queue.reset(new TilingSetRasterQueueAll(
       pending_layer_->picture_layer_tiling_set(), false));
   while (!queue->IsEmpty()) {
     PrioritizedTile prioritized_tile = queue->Top();
     Tile* tile = prioritized_tile.tile();
 
     EXPECT_FALSE(prioritized_tile.is_occluded());
 
     bool tile_is_visible =
-        tile->content_rect().Intersects(pending_layer_->visible_content_rect());
+        tile->content_rect().Intersects(pending_layer_->visible_layer_rect());
     if (tile_is_visible)
       unoccluded_tile_count++;
     queue->Pop();
   }
   EXPECT_EQ(20, unoccluded_tile_count);
 
   // Full occlusion.
   layer1->SetPosition(gfx::Point(0, 0));
 
   host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(200));
   host_impl_.pending_tree()->UpdateDrawProperties(update_lcd_text);
 
   unoccluded_tile_count = 0;
   queue.reset(new TilingSetRasterQueueAll(
       pending_layer_->picture_layer_tiling_set(), false));
   while (!queue->IsEmpty()) {
     PrioritizedTile prioritized_tile = queue->Top();
     Tile* tile = prioritized_tile.tile();
 
     EXPECT_FALSE(prioritized_tile.is_occluded());
 
     bool tile_is_visible =
-        tile->content_rect().Intersects(pending_layer_->visible_content_rect());
+        tile->content_rect().Intersects(pending_layer_->visible_layer_rect());
     if (tile_is_visible)
       unoccluded_tile_count++;
     queue->Pop();
   }
   EXPECT_EQ(unoccluded_tile_count, 0);
 }
 
 TEST_F(OcclusionTrackingPictureLayerImplTest,
        OccludedTilesNotMarkedAsRequired) {
   host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
@@ skipping 577 matching lines @@
 
   SetupTrees(pending_pile, active_pile);
 
   Region invalidation;
   gfx::Rect viewport = gfx::Rect(0, 0, 100, 100);
   gfx::Transform transform;
 
   host_impl_.SetRequiresHighResToDraw();
 
   // Update tiles.
-  pending_layer_->draw_properties().visible_content_rect = viewport;
+  pending_layer_->draw_properties().visible_layer_rect = viewport;
   pending_layer_->draw_properties().screen_space_transform = transform;
   SetupDrawPropertiesAndUpdateTiles(pending_layer_, 1.f, 1.f, 1.f, 1.f, 0.f,
                                     false);
   pending_layer_->HighResTiling()->UpdateAllRequiredStateForTesting();
 
   // Ensure we can't activate.
   EXPECT_FALSE(host_impl_.tile_manager()->IsReadyToActivate());
 
   // Now in the same frame, move the viewport (this can happen during
   // animation).
   viewport = gfx::Rect(0, 2000, 100, 100);
 
   // Update tiles.
-  pending_layer_->draw_properties().visible_content_rect = viewport;
+  pending_layer_->draw_properties().visible_layer_rect = viewport;
   pending_layer_->draw_properties().screen_space_transform = transform;
   SetupDrawPropertiesAndUpdateTiles(pending_layer_, 1.f, 1.f, 1.f, 1.f, 0.f,
                                     false);
   pending_layer_->HighResTiling()->UpdateAllRequiredStateForTesting();
 
   // Make sure all viewport tiles (viewport from the tiling) are ready to draw.
   std::vector<Tile*> tiles;
   for (PictureLayerTiling::CoverageIterator iter(
            pending_layer_->HighResTiling(),
            1.f,
@@ skipping 318 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