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

cc/tiles/tile_manager_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 <stddef.h>
 #include <stdint.h>
 
 #include "base/run_loop.h"
 #include "base/thread_task_runner_handle.h"
 #include "cc/playback/display_list_raster_source.h"
@@ skipping 478 matching lines @@
     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,
+       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));
   SetupDefaultTrees(layer_bounds);
 
   // Use a tile's content rect as an invalidation. We should inset it a bit to
   // ensure that border math doesn't invalidate neighbouring tiles.
   gfx::Rect invalidation =
       active_layer_->HighResTiling()->TileAt(1, 0)->content_rect();
   invalidation.Inset(2, 2);
@@ skipping 1444 matching lines @@
 
 // Ensures that the tile manager does not attempt to reuse tiles when partial
 // raster is disabled.
 TEST_F(TileManagerTest, PartialRasterSuccessfullyDisabled) {
   RunPartialRasterCheck(std::move(host_impl_),
                         false /* partial_raster_enabled */);
 }
 
 }  // namespace
 }  // namespace cc