cc: Use visible_rect_for_tile_priority_ where approriate

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 146 matching lines @@
                                          float page_scale_factor,
                                          float maximum_animation_contents_scale,
                                          bool animating_transform_to_screen) {
     layer->draw_properties().ideal_contents_scale = ideal_contents_scale;
     layer->draw_properties().device_scale_factor = device_scale_factor;
     layer->draw_properties().page_scale_factor = page_scale_factor;
     layer->draw_properties().maximum_animation_contents_scale =
         maximum_animation_contents_scale;
     layer->draw_properties().screen_space_transform_is_animating =
         animating_transform_to_screen;
-    layer->UpdateTiles(Occlusion());
+    bool resourceless_software_draw = false;
+    layer->UpdateTiles(Occlusion(), resourceless_software_draw);
   }
   static void VerifyAllTilesExistAndHavePile(
       const PictureLayerTiling* tiling,
       PicturePileImpl* pile) {
     for (PictureLayerTiling::CoverageIterator iter(
              tiling,
              tiling->contents_scale(),
              gfx::Rect(tiling->tiling_size()));
          iter;
          ++iter) {
@@ skipping 79 matching lines @@
     for (tile_iter = tiles.begin(); tile_iter < tiles.end(); tile_iter++) {
       MockCanvas mock_canvas(1000, 1000);
       active_pile->RasterDirect(
           &mock_canvas, (*tile_iter)->content_rect(), 1.0f, NULL);
 
       // This test verifies that when drawing the contents of a specific tile
       // at content scale 1.0, the playback canvas never receives content from
       // neighboring tiles which indicates that the tile grid embedded in
       // SkPicture is perfectly aligned with the compositor's tiles.
       EXPECT_EQ(1u, mock_canvas.rects_.size());
-      EXPECT_RECT_EQ(*rect_iter, mock_canvas.rects_[0]);
+      EXPECT_EQ(*rect_iter, mock_canvas.rects_[0]);
       rect_iter++;
     }
   }
 
   void TestQuadsForSolidColor(bool test_for_solid);
 
   FakeImplProxy proxy_;
   TestSharedBitmapManager shared_bitmap_manager_;
   FakeLayerTreeHostImpl host_impl_;
   int id_;
@@ skipping 69 matching lines @@
   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);
   active_layer_->draw_properties().visible_content_rect = viewport;
   active_layer_->draw_properties().screen_space_transform = transform;
-  active_layer_->UpdateTiles(Occlusion());
+  active_layer_->UpdateTiles(Occlusion(), resourceless_software_draw);
 
   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 impl.
   EXPECT_EQ(active_layer_->viewport_rect_for_tile_priority(),
             viewport_rect_for_tile_priority_in_view_space);
 
   // Verify the viewport rect for tile priority is used in picture layer tiling.
   PictureLayerTilingSet* tilings = active_layer_->tilings();
@@ skipping 17 matching lines @@
   transform_for_tile_priority.Translate(100, 100);
   transform_for_tile_priority.Rotate(45);
   host_impl_.SetExternalDrawConstraints(transform,
                                         viewport,
                                         viewport,
                                         viewport_rect_for_tile_priority,
                                         transform_for_tile_priority,
                                         resourceless_software_draw);
   active_layer_->draw_properties().visible_content_rect = viewport;
   active_layer_->draw_properties().screen_space_transform = transform;
-  active_layer_->UpdateTiles(Occlusion());
+  active_layer_->UpdateTiles(Occlusion(), resourceless_software_draw);
 
   gfx::Transform screen_to_view(gfx::Transform::kSkipInitialization);
   bool success = transform_for_tile_priority.GetInverse(&screen_to_view);
   EXPECT_TRUE(success);
 
   // 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));
 
   // Verify the viewport rect for tile priority is used in PictureLayerImpl.
   EXPECT_EQ(active_layer_->viewport_rect_for_tile_priority(),
             viewport_rect_for_tile_priority_in_view_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()));
   }
 }
 
-TEST_F(PictureLayerImplTest,
-       ResourcelessSoftwareDrawHasValidViewportForTilePriority) {
+TEST_F(PictureLayerImplTest, InvalidViewportForPrioritizingTiles) {
   base::TimeTicks time_ticks;
   time_ticks += base::TimeDelta::FromMilliseconds(1);
   host_impl_.SetCurrentBeginFrameArgs(
       CreateBeginFrameArgsForTesting(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);
 
   SetupTrees(pending_pile, active_pile);
 
   Region invalidation;
   AddDefaultTilingsWithInvalidation(invalidation);
   SetupDrawPropertiesAndUpdateTiles(active_layer_, 1.f, 1.f, 1.f, 1.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_.SetExternalDrawConstraints(transform,
                                         viewport,
                                         viewport,
                                         viewport,
                                         transform,
                                         resourceless_software_draw);
   active_layer_->draw_properties().visible_content_rect = viewport;
   active_layer_->draw_properties().screen_space_transform = transform;
-  active_layer_->UpdateTiles(Occlusion());
+  active_layer_->UpdateTiles(Occlusion(), 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::Rect viewport_rect_for_tile_priority =
       active_layer_->viewport_rect_for_tile_priority();
   EXPECT_FALSE(viewport_rect_for_tile_priority.IsEmpty());
   gfx::Transform screen_space_transform_for_tile_priority =
       active_layer_->screen_space_transform_for_tile_priority();
 
-  // PictureLayerImpl does not make a special case for
-  // resource_less_software_draw, so the tile viewport and matrix should be
-  // respected.
+  // Expand viewport and set it as invalid for prioritizing tiles.
+  // Should update viewport and transform, but not update visible rect.
   time_ticks += base::TimeDelta::FromMilliseconds(200);
   host_impl_.SetCurrentBeginFrameArgs(
       CreateBeginFrameArgsForTesting(time_ticks));
   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().screen_space_transform = transform;
   host_impl_.SetExternalDrawConstraints(transform,
                                         viewport,
                                         viewport,
                                         viewport,
                                         transform,
                                         resourceless_software_draw);
-  active_layer_->UpdateTiles(Occlusion());
+  active_layer_->UpdateTiles(Occlusion(), resourceless_software_draw);
 
-  visible_rect_for_tile_priority =
-      gfx::ScaleToEnclosingRect(visible_rect_for_tile_priority, 2);
-  viewport_rect_for_tile_priority =
-      gfx::ScaleToEnclosingRect(viewport_rect_for_tile_priority, 2);
-  screen_space_transform_for_tile_priority = transform;
-  EXPECT_RECT_EQ(visible_rect_for_tile_priority,
-                 active_layer_->visible_rect_for_tile_priority());
-  EXPECT_RECT_EQ(viewport_rect_for_tile_priority,
-                 active_layer_->viewport_rect_for_tile_priority());
+  // Viewport and transform for tile priority are updated.
+  EXPECT_EQ(viewport, active_layer_->viewport_rect_for_tile_priority());
   EXPECT_TRANSFORMATION_MATRIX_EQ(
-      screen_space_transform_for_tile_priority,
-      active_layer_->screen_space_transform_for_tile_priority());
+      transform, 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());
+
+  // Keep expanded viewport but mark it valid. Should update tile viewport.
+  time_ticks += base::TimeDelta::FromMilliseconds(200);
+  host_impl_.SetCurrentBeginFrameArgs(
+      CreateBeginFrameArgsForTesting(time_ticks));
+  resourceless_software_draw = false;
+  host_impl_.SetExternalDrawConstraints(transform,
+                                        viewport,
+                                        viewport,
+                                        viewport,
+                                        transform,
+                                        resourceless_software_draw);
+  active_layer_->UpdateTiles(Occlusion(), resourceless_software_draw);
+
+  EXPECT_TRANSFORMATION_MATRIX_EQ(
+      transform, active_layer_->screen_space_transform_for_tile_priority());
+  EXPECT_EQ(viewport, active_layer_->visible_rect_for_tile_priority());
+
+  // Match the reverse translate in |transform|.
+  EXPECT_EQ(viewport - gfx::Vector2d(1, 1),
+            active_layer_->viewport_rect_for_tile_priority());
 }
 
 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 =
@@ skipping 904 matching lines @@
 }
 
 TEST_F(PictureLayerImplTest, MarkRequiredOffscreenTiles) {
   gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(200, 200);
 
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
   SetupPendingTree(pending_pile);
 
+  gfx::Transform transform;
+  gfx::Transform transform_for_tile_priority;
+  bool resourceless_software_draw = false;
+  gfx::Rect viewport(0, 0, 100, 200);
+  host_impl_.SetExternalDrawConstraints(transform,
+                                        viewport,
+                                        viewport,
+                                        viewport,
+                                        transform,
+                                        resourceless_software_draw);
+
   pending_layer_->set_fixed_tile_size(tile_size);
   ASSERT_TRUE(pending_layer_->CanHaveTilings());
   PictureLayerTiling* tiling = pending_layer_->AddTiling(1.f);
   host_impl_.pending_tree()->UpdateDrawProperties();
   EXPECT_EQ(tiling->resolution(), HIGH_RESOLUTION);
-
-  pending_layer_->draw_properties().visible_content_rect =
-      gfx::Rect(0, 0, 100, 200);
+  EXPECT_EQ(viewport, pending_layer_->visible_rect_for_tile_priority());
 
   // Fake set priorities.
   for (PictureLayerTiling::CoverageIterator iter(
            tiling, pending_layer_->contents_scale_x(), gfx::Rect(layer_bounds));
        iter;
        ++iter) {
     if (!*iter)
       continue;
     Tile* tile = *iter;
     TilePriority priority;
     priority.resolution = HIGH_RESOLUTION;
     gfx::Rect tile_bounds = iter.geometry_rect();
-    if (pending_layer_->visible_content_rect().Intersects(tile_bounds)) {
+    if (pending_layer_->visible_rect_for_tile_priority().Intersects(
+            tile_bounds)) {
       priority.priority_bin = TilePriority::NOW;
       priority.distance_to_visible = 0.f;
     } else {
       priority.priority_bin = TilePriority::SOON;
       priority.distance_to_visible = 1.f;
     }
     tile->SetPriority(PENDING_TREE, priority);
   }
 
   pending_layer_->MarkVisibleResourcesAsRequired();
@@ skipping 55 matching lines @@
                                         transform_for_tile_priority,
                                         resourceless_software_draw);
   host_impl_.pending_tree()->UpdateDrawProperties();
 
   // Set visible content rect that is different from
   // 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(time_ticks));
-  pending_layer_->UpdateTiles(Occlusion());
+  pending_layer_->UpdateTiles(Occlusion(), resourceless_software_draw);
 
   pending_layer_->MarkVisibleResourcesAsRequired();
 
   // Intersect the two rects. Any tile outside should not be required for
   // activation.
   gfx::Rect viewport_for_tile_priority =
       pending_layer_->GetViewportForTilePriorityInContentSpace();
   viewport_for_tile_priority.Intersect(pending_layer_->visible_content_rect());
 
   int num_inside = 0;
@@ skipping 1043 matching lines @@
   EXPECT_EQ(low_res_tile_count + high_res_tile_count + non_ideal_tile_count,
             unique_tiles.size());
 
   // No NOW tiles.
   time_ticks += base::TimeDelta::FromMilliseconds(200);
   host_impl_.SetCurrentBeginFrameArgs(
       CreateBeginFrameArgsForTesting(time_ticks));
 
   pending_layer_->draw_properties().visible_content_rect =
       gfx::Rect(1100, 1100, 500, 500);
-  pending_layer_->UpdateTiles(Occlusion());
+  bool resourceless_software_draw = false;
+  pending_layer_->UpdateTiles(Occlusion(), resourceless_software_draw);
 
   unique_tiles.clear();
   high_res_tile_count = 0u;
   for (it = PictureLayerImpl::LayerRasterTileIterator(pending_layer_, false);
        it;
        ++it) {
     Tile* tile = *it;
     TilePriority priority = tile->priority(PENDING_TREE);
 
     EXPECT_TRUE(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(tile);
   }
 
   EXPECT_EQ(16u, high_res_tile_count);
   EXPECT_EQ(high_res_tile_count, unique_tiles.size());
 
   time_ticks += base::TimeDelta::FromMilliseconds(200);
   host_impl_.SetCurrentBeginFrameArgs(
       CreateBeginFrameArgsForTesting(time_ticks));
 
   pending_layer_->draw_properties().visible_content_rect =
       gfx::Rect(0, 0, 500, 500);
-  pending_layer_->UpdateTiles(Occlusion());
+  pending_layer_->UpdateTiles(Occlusion(), resourceless_software_draw);
 
   std::vector<Tile*> high_res_tiles = high_res_tiling->AllTilesForTesting();
   for (std::vector<Tile*>::iterator tile_it = high_res_tiles.begin();
        tile_it != high_res_tiles.end();
        ++tile_it) {
     Tile* tile = *tile_it;
     ManagedTileState::DrawInfo& draw_info = tile->draw_info();
     draw_info.SetSolidColorForTesting(SK_ColorRED);
   }
 
@@ skipping 500 matching lines @@
   EXPECT_EQ(active_layer_->HighResTiling()->AllTilesForTesting().size(), 0u);
 
   // Since the active layer has no tiles at all, the pending layer doesn't
   // need content in order to activate.
   pending_layer_->MarkVisibleResourcesAsRequired();
   AssertNoTilesRequired(pending_layer_->HighResTiling());
   if (host_impl_.settings().create_low_res_tiling)
     AssertNoTilesRequired(pending_layer_->LowResTiling());
 }
 
-TEST_F(NoLowResPictureLayerImplTest,
-       ResourcelessSoftwareDrawHasValidViewportForTilePriority) {
+TEST_F(NoLowResPictureLayerImplTest, InvalidViewportForPrioritizingTiles) {
   base::TimeTicks time_ticks;
   time_ticks += base::TimeDelta::FromMilliseconds(1);
   host_impl_.SetCurrentBeginFrameArgs(
       CreateBeginFrameArgsForTesting(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);
 
   SetupTrees(pending_pile, active_pile);
 
   Region invalidation;
   AddDefaultTilingsWithInvalidation(invalidation);
   SetupDrawPropertiesAndUpdateTiles(active_layer_, 1.f, 1.f, 1.f, 1.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_.SetExternalDrawConstraints(transform,
                                         viewport,
                                         viewport,
                                         viewport,
                                         transform,
                                         resourceless_software_draw);
   active_layer_->draw_properties().visible_content_rect = viewport;
   active_layer_->draw_properties().screen_space_transform = transform;
-  active_layer_->UpdateTiles(Occlusion());
+  active_layer_->UpdateTiles(Occlusion(), 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::Rect viewport_rect_for_tile_priority =
       active_layer_->viewport_rect_for_tile_priority();
   EXPECT_FALSE(viewport_rect_for_tile_priority.IsEmpty());
   gfx::Transform screen_space_transform_for_tile_priority =
       active_layer_->screen_space_transform_for_tile_priority();
 
-  // PictureLayerImpl does not make a special case for
-  // resource_less_software_draw, so the tile viewport and matrix should be
-  // respected.
+  // Expand viewport and set it as invalid for prioritizing tiles.
+  // Should update viewport and transform, but not update visible rect.
   time_ticks += base::TimeDelta::FromMilliseconds(200);
   host_impl_.SetCurrentBeginFrameArgs(
       CreateBeginFrameArgsForTesting(time_ticks));
   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().screen_space_transform = transform;
   host_impl_.SetExternalDrawConstraints(transform,
                                         viewport,
                                         viewport,
                                         viewport,
                                         transform,
                                         resourceless_software_draw);
-  active_layer_->UpdateTiles(Occlusion());
+  active_layer_->UpdateTiles(Occlusion(), resourceless_software_draw);
 
-  visible_rect_for_tile_priority =
-      gfx::ScaleToEnclosingRect(visible_rect_for_tile_priority, 2);
-  viewport_rect_for_tile_priority =
-      gfx::ScaleToEnclosingRect(viewport_rect_for_tile_priority, 2);
-  screen_space_transform_for_tile_priority = transform;
+  // Viewport and transform for tile priority are updated.
+  EXPECT_EQ(viewport, active_layer_->viewport_rect_for_tile_priority());
+  EXPECT_TRANSFORMATION_MATRIX_EQ(
+      transform, 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());
 
-  EXPECT_RECT_EQ(visible_rect_for_tile_priority,
-                 active_layer_->visible_rect_for_tile_priority());
-  EXPECT_RECT_EQ(viewport_rect_for_tile_priority,
-                 active_layer_->viewport_rect_for_tile_priority());
+  // Keep expanded viewport but mark it valid. Should update tile viewport.
+  time_ticks += base::TimeDelta::FromMilliseconds(200);
+  host_impl_.SetCurrentBeginFrameArgs(
+      CreateBeginFrameArgsForTesting(time_ticks));
+  resourceless_software_draw = false;
+  host_impl_.SetExternalDrawConstraints(transform,
+                                        viewport,
+                                        viewport,
+                                        viewport,
+                                        transform,
+                                        resourceless_software_draw);
+  active_layer_->UpdateTiles(Occlusion(), resourceless_software_draw);
+
   EXPECT_TRANSFORMATION_MATRIX_EQ(
-      screen_space_transform_for_tile_priority,
-      active_layer_->screen_space_transform_for_tile_priority());
+      transform, active_layer_->screen_space_transform_for_tile_priority());
+  EXPECT_EQ(viewport, active_layer_->visible_rect_for_tile_priority());
+
+  gfx::Rect viewport_rect_in_layer =
+      active_layer_->viewport_rect_for_tile_priority();
+  viewport_rect_in_layer.Offset(1, 1);  // Match translate in |transform|.

[danakj, 2014/10/01 14:27:14]

can you make this look the same as what you did above?

[boliu, 2014/10/01 15:20:47]

Oops. Done.

+  EXPECT_EQ(viewport, viewport_rect_in_layer);
 }
 
 TEST_F(NoLowResPictureLayerImplTest, CleanUpTilings) {
   gfx::Size tile_size(400, 400);
   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);
@@ skipping 1139 matching lines @@
   SetupPendingTree(pending_pile2);
   ActivateTree();
 
   // We've switched to a solid color, so we should end up with no tilings.
   ASSERT_TRUE(active_layer_->tilings());
   EXPECT_EQ(0u, active_layer_->tilings()->num_tilings());
 }
 
 }  // namespace
 }  // namespace cc