Upstream version 5.34.104.0

[platform/framework/web/crosswalk.git] / src / cc / layers / picture_layer_impl_unittest.cc

diff --git a/src/cc/layers/picture_layer_impl_unittest.cc b/src/cc/layers/picture_layer_impl_unittest.cc
index 8c6412d..f70e54e 100644 (file)
--- a/src/cc/layers/picture_layer_impl_unittest.cc
+++ b/src/cc/layers/picture_layer_impl_unittest.cc
@@ -54,10 +54,11 @@ class PictureLayerImplTest : public testing::Test {
   }
 
   virtual void InitializeRenderer() {
-    host_impl_.InitializeRenderer(CreateFakeOutputSurface());
+    host_impl_.InitializeRenderer(
+        FakeOutputSurface::Create3d().PassAs<OutputSurface>());
   }
 
-  void SetupDefaultTrees(gfx::Size layer_bounds) {
+  void SetupDefaultTrees(const gfx::Size& layer_bounds) {
     gfx::Size tile_size(100, 100);
 
     scoped_refptr<FakePicturePileImpl> pending_pile =
@@ -76,8 +77,8 @@ class PictureLayerImplTest : public testing::Test {
         host_impl_.active_tree()->LayerById(id_));
   }
 
-  void SetupDefaultTreesWithFixedTileSize(gfx::Size layer_bounds,
-                                          gfx::Size tile_size) {
+  void SetupDefaultTreesWithFixedTileSize(const gfx::Size& layer_bounds,
+                                          const gfx::Size& tile_size) {
     SetupDefaultTrees(layer_bounds);
     pending_layer_->set_fixed_tile_size(tile_size);
     active_layer_->set_fixed_tile_size(tile_size);
@@ -1195,7 +1196,7 @@ TEST_F(PictureLayerImplTest, MarkRequiredNullTiles) {
 
 TEST_F(PictureLayerImplTest, MarkRequiredOffscreenTiles) {
   gfx::Size tile_size(100, 100);
-  gfx::Size layer_bounds(200, 100);
+  gfx::Size layer_bounds(200, 200);
 
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
@@ -1207,12 +1208,12 @@ TEST_F(PictureLayerImplTest, MarkRequiredOffscreenTiles) {
   host_impl_.pending_tree()->UpdateDrawProperties();
   EXPECT_EQ(tiling->resolution(), HIGH_RESOLUTION);
 
+  pending_layer_->draw_properties().visible_content_rect =
+      gfx::Rect(0, 0, 100, 200);
+
   // Fake set priorities.
-  int tile_count = 0;
   for (PictureLayerTiling::CoverageIterator iter(
-           tiling,
-           pending_layer_->contents_scale_x(),
-           gfx::Rect(pending_layer_->visible_content_rect()));
+           tiling, pending_layer_->contents_scale_x(), gfx::Rect(layer_bounds));
        iter;
        ++iter) {
     if (!*iter)
@@ -1220,12 +1221,13 @@ TEST_F(PictureLayerImplTest, MarkRequiredOffscreenTiles) {
     Tile* tile = *iter;
     TilePriority priority;
     priority.resolution = HIGH_RESOLUTION;
-    if (++tile_count % 2) {
-      priority.time_to_visible_in_seconds = 0.f;
-      priority.distance_to_visible_in_pixels = 0.f;
+    gfx::Rect tile_bounds = iter.geometry_rect();
+    if (pending_layer_->visible_content_rect().Intersects(tile_bounds)) {
+      priority.priority_bin = TilePriority::NOW;
+      priority.distance_to_visible = 0.f;
     } else {
-      priority.time_to_visible_in_seconds = 1.f;
-      priority.distance_to_visible_in_pixels = 1.f;
+      priority.priority_bin = TilePriority::SOON;
+      priority.distance_to_visible = 1.f;
     }
     tile->SetPriority(PENDING_TREE, priority);
   }
@@ -1236,15 +1238,13 @@ TEST_F(PictureLayerImplTest, MarkRequiredOffscreenTiles) {
   int num_offscreen = 0;
 
   for (PictureLayerTiling::CoverageIterator iter(
-           tiling,
-           pending_layer_->contents_scale_x(),
-           gfx::Rect(pending_layer_->visible_content_rect()));
+           tiling, pending_layer_->contents_scale_x(), gfx::Rect(layer_bounds));
        iter;
        ++iter) {
     if (!*iter)
       continue;
     const Tile* tile = *iter;
-    if (tile->priority(PENDING_TREE).distance_to_visible_in_pixels == 0.f) {
+    if (tile->priority(PENDING_TREE).distance_to_visible == 0.f) {
       EXPECT_TRUE(tile->required_for_activation());
       num_visible++;
     } else {
@@ -1276,6 +1276,27 @@ TEST_F(PictureLayerImplTest, HighResRequiredWhenUnsharedActiveAllReady) {
   AssertNoTilesRequired(pending_layer_->LowResTiling());
 }
 
+TEST_F(PictureLayerImplTest, HighResRequiredWhenMissingHighResFlagOn) {
+  gfx::Size layer_bounds(400, 400);
+  gfx::Size tile_size(100, 100);
+  SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size);
+
+  // All tiles shared (no invalidation).
+  CreateHighLowResAndSetAllTilesVisible();
+
+  // Verify active tree not ready.
+  Tile* some_active_tile =
+      active_layer_->HighResTiling()->AllTilesForTesting()[0];
+  EXPECT_FALSE(some_active_tile->IsReadyToDraw());
+
+  // When high res are required, even if the active tree is not ready,
+  // the high res tiles must be ready.
+  host_impl_.active_tree()->SetRequiresHighResToDraw();
+  pending_layer_->MarkVisibleResourcesAsRequired();
+  AssertAllTilesRequired(pending_layer_->HighResTiling());
+  AssertNoTilesRequired(pending_layer_->LowResTiling());
+}
+
 TEST_F(PictureLayerImplTest, NothingRequiredIfAllHighResTilesShared) {
   gfx::Size layer_bounds(400, 400);
   gfx::Size tile_size(100, 100);