cc: Add test for the fix in https://codereview.chromium.org/1808043002/

This patch adds a unittest that fails without the patch, and passes
with it.

R=enne
CQ_INCLUDE_TRYBOTS=tryserver.blink:linux_blink_rel

Review URL: https://codereview.chromium.org/1814643002

Cr-Commit-Position: refs/heads/master@{#381748}

cc/tiles/tile_manager_unittest.cc

@@ -496,6 +496,73 @@ TEST_F(TileManagerTilePriorityQueueTest,
   EXPECT_EQ(all_expected_tiles, all_actual_tiles);
 }
 
+TEST_F(TileManagerTilePriorityQueueTest,
+       RasterTilePriorityQueueHighLowTilings) {
+  const gfx::Size layer_bounds(1000, 1000);
+  const gfx::Size viewport(800, 800);
+  host_impl_.SetViewportSize(viewport);
+  SetupDefaultTrees(layer_bounds);
+
+  pending_layer_->tilings()->AddTiling(1.5f, pending_layer_->raster_source());
+  active_layer_->tilings()->AddTiling(1.5f, active_layer_->raster_source());
+  pending_layer_->tilings()->AddTiling(1.7f, pending_layer_->raster_source());
+  active_layer_->tilings()->AddTiling(1.7f, active_layer_->raster_source());
+
+  pending_layer_->tilings()->UpdateTilePriorities(gfx::Rect(viewport), 1.f, 5.0,
+                                                  Occlusion(), true);
+  active_layer_->tilings()->UpdateTilePriorities(gfx::Rect(viewport), 1.f, 5.0,
+                                                 Occlusion(), true);
+
+  std::set<Tile*> all_expected_tiles;
+  for (size_t i = 0; i < pending_layer_->num_tilings(); ++i) {
+    PictureLayerTiling* tiling = pending_layer_->tilings()->tiling_at(i);
+    if (tiling->contents_scale() == 1.f) {
+      tiling->set_resolution(HIGH_RESOLUTION);
+      const auto& all_tiles = tiling->AllTilesForTesting();
+      all_expected_tiles.insert(all_tiles.begin(), all_tiles.end());
+    } else {
+      tiling->set_resolution(NON_IDEAL_RESOLUTION);
+    }
+  }
+
+  for (size_t i = 0; i < active_layer_->num_tilings(); ++i) {
+    PictureLayerTiling* tiling = active_layer_->tilings()->tiling_at(i);
+    if (tiling->contents_scale() == 1.5f) {
+      tiling->set_resolution(HIGH_RESOLUTION);
+      const auto& all_tiles = tiling->AllTilesForTesting();
+      all_expected_tiles.insert(all_tiles.begin(), all_tiles.end());
+    } else {
+      tiling->set_resolution(LOW_RESOLUTION);
+      // Low res tilings with a high res pending twin have to be processed
+      // because of possible activation tiles.
+      if (tiling->contents_scale() == 1.f) {
+        tiling->UpdateAndGetAllPrioritizedTilesForTesting();
+        const auto& all_tiles = tiling->AllTilesForTesting();
+        for (auto* tile : all_tiles)
+          EXPECT_TRUE(tile->required_for_activation());
+        all_expected_tiles.insert(all_tiles.begin(), all_tiles.end());
+      }
+    }
+  }
+
+  scoped_ptr<RasterTilePriorityQueue> queue(host_impl_.BuildRasterQueue(
+      SAME_PRIORITY_FOR_BOTH_TREES, RasterTilePriorityQueue::Type::ALL));
+  EXPECT_FALSE(queue->IsEmpty());
+
+  size_t tile_count = 0;
+  std::set<Tile*> all_actual_tiles;
+  while (!queue->IsEmpty()) {
+    EXPECT_TRUE(queue->Top().tile());
+    all_actual_tiles.insert(queue->Top().tile());
+    ++tile_count;
+    queue->Pop();
+  }
+
+  EXPECT_EQ(tile_count, all_actual_tiles.size());
+  EXPECT_EQ(all_expected_tiles.size(), all_actual_tiles.size());
+  EXPECT_EQ(all_expected_tiles, all_actual_tiles);
+}
+
 TEST_F(TileManagerTilePriorityQueueTest, RasterTilePriorityQueueInvalidation) {
   const gfx::Size layer_bounds(1000, 1000);
   host_impl_.SetViewportSize(gfx::Size(500, 500));