cc: Fix tile priority inversion in picture layer tiling.

cc/tiles/picture_layer_tiling_unittest.cc

 // Copyright 2012 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/tiles/picture_layer_tiling.h"
 
 #include <stddef.h>
 
 #include <limits>
 #include <set>
@@ skipping 43 matching lines @@
     return base::WrapUnique(new TestablePictureLayerTiling(
         tree, contents_scale, raster_source, client,
         settings.tiling_interest_area_padding,
         settings.skewport_target_time_in_seconds,
         settings.skewport_extrapolation_limit_in_screen_pixels,
         312.f, /* min_preraster_distance */
         settings.max_preraster_distance_in_screen_pixels));
   }
 
   gfx::Rect live_tiles_rect() const { return live_tiles_rect_; }
+  PriorityRectType visible_rect_type() const {
+    return PriorityRectType::VISIBLE_RECT;
+  }
 
   using PictureLayerTiling::RemoveTileAt;
   using PictureLayerTiling::RemoveTilesInRegion;
+  using PictureLayerTiling::ComputePriorityRectTypeForTile;
 
  protected:
   TestablePictureLayerTiling(WhichTree tree,
                              float contents_scale,
                              scoped_refptr<RasterSource> raster_source,
                              PictureLayerTilingClient* client,
                              size_t tiling_interest_area_padding,
                              float skewport_target_time,
                              int skewport_extrapolation_limit,
                              float min_preraster_distance,
@@ skipping 871 matching lines @@
 
   EXPECT_TRUE(active_tiling->TileAt(0, 0));
   EXPECT_FALSE(recycle_tiling->TileAt(0, 0));
 
   // Reset the active tiling. The recycle tiles should be released too.
   active_tiling->Reset();
   EXPECT_FALSE(active_tiling->TileAt(0, 0));
   EXPECT_FALSE(recycle_tiling->TileAt(0, 0));
 }
 
+TEST(PictureLayerTilingTest, EdgeCaseTileNowAndRequired) {
+  FakePictureLayerTilingClient pending_client;
+  pending_client.SetTileSize(gfx::Size(100, 100));
+
+  scoped_refptr<FakeRasterSource> raster_source =
+      FakeRasterSource::CreateFilled(gfx::Size(500, 500));
+  std::unique_ptr<TestablePictureLayerTiling> pending_tiling =
+      TestablePictureLayerTiling::Create(PENDING_TREE, 1.0f, raster_source,
+                                         &pending_client, LayerTreeSettings());
+  pending_tiling->set_resolution(HIGH_RESOLUTION);
+  pending_tiling->set_can_require_tiles_for_activation(true);
+
+  // The tile at (1, 0) should be touching the visible rect, but not
+  // intersecting it.
+  gfx::Rect visible_rect = gfx::Rect(0, 0, 99, 99);
+  gfx::Rect eventually_rect = gfx::Rect(0, 0, 500, 500);
+  pending_tiling->ComputeTilePriorityRects(visible_rect, visible_rect,
+                                           visible_rect, eventually_rect, 1.f,
+                                           Occlusion());
+
+  Tile* tile = pending_tiling->TileAt(1, 0);
+  EXPECT_NE(pending_tiling->visible_rect_type(),
+            pending_tiling->ComputePriorityRectTypeForTile(tile));
+  EXPECT_FALSE(pending_tiling->IsTileRequiredForActivation(tile));
+  EXPECT_TRUE(tile->content_rect().Intersects(visible_rect));
+  EXPECT_FALSE(pending_tiling->tiling_data()
+                   ->TileBounds(tile->tiling_i_index(), tile->tiling_j_index())
+                   .Intersects(visible_rect));
+
+  // Now the tile at (1, 0) should be intersecting the visible rect.
+  visible_rect = gfx::Rect(0, 0, 100, 100);
+  pending_tiling->ComputeTilePriorityRects(visible_rect, visible_rect,
+                                           visible_rect, eventually_rect, 1.f,
+                                           Occlusion());
+  EXPECT_EQ(pending_tiling->visible_rect_type(),
+            pending_tiling->ComputePriorityRectTypeForTile(tile));
+  EXPECT_TRUE(pending_tiling->IsTileRequiredForActivation(tile));
+  EXPECT_TRUE(tile->content_rect().Intersects(visible_rect));
+  EXPECT_TRUE(pending_tiling->tiling_data()
+                  ->TileBounds(tile->tiling_i_index(), tile->tiling_j_index())
+                  .Intersects(visible_rect));
+}
+
 TEST_F(PictureLayerTilingIteratorTest, ResizeTilesAndUpdateToCurrent) {
   // The tiling has four rows and three columns.
   Initialize(gfx::Size(150, 100), 1.f, gfx::Size(250, 150));
   tiling_->CreateAllTilesForTesting();
   EXPECT_EQ(150, tiling_->TilingDataForTesting().max_texture_size().width());
   EXPECT_EQ(100, tiling_->TilingDataForTesting().max_texture_size().height());
   EXPECT_EQ(4u, tiling_->AllTilesForTesting().size());
 
   client_.SetTileSize(gfx::Size(250, 200));
 
@@ skipping 116 matching lines @@
 
   active_tiling->TakeTilesAndPropertiesFrom(tiling_.get(),
                                             Region(gfx::Rect(bounds)));
   for (const auto* tile : tiles) {
     EXPECT_EQ(tile->tiling(), active_tiling.get());
   }
 }
 
 }  // namespace
 }  // namespace cc