Improve PictureLayerTiling::CoverageIterator to handle rounding more precisely

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 <stddef.h>
 
 #include <algorithm>
 #include <limits>
@@ skipping 1911 matching lines @@
       high_tiles);
 
   std::unique_ptr<RenderPass> render_pass = RenderPass::Create();
   AppendQuadsData data;
   active_layer()->WillDraw(DRAW_MODE_SOFTWARE, nullptr);
   active_layer()->AppendQuads(render_pass.get(), &data);
   active_layer()->DidDraw(nullptr);
 
   // All high res tiles drew, and the one ideal res tile drew.
   ASSERT_GT(render_pass->quad_list.size(), 9u);
-  EXPECT_EQ(gfx::SizeF(99.f, 99.f),
+  EXPECT_EQ(gfx::Rect(0, 0, 99, 99), render_pass->quad_list.front()->rect);
+  EXPECT_EQ(gfx::RectF(0.f, 0.f, 99.f, 99.f),
             TileDrawQuad::MaterialCast(render_pass->quad_list.front())
-                ->tex_coord_rect.size());
-  EXPECT_EQ(gfx::SizeF(49.5f, 49.5f),
+                ->tex_coord_rect);
+  EXPECT_EQ(gfx::Rect(99, 0, 100, 99),
+            render_pass->quad_list.ElementAt(1)->rect);
+  EXPECT_EQ(gfx::RectF(49.5f, 0.f, 50.f, 49.5f),
             TileDrawQuad::MaterialCast(render_pass->quad_list.ElementAt(1))
-                ->tex_coord_rect.size());
+                ->tex_coord_rect);
 
   // Neither the high res nor the ideal tiles were considered as incomplete.
   EXPECT_EQ(0u, data.num_missing_tiles);
   EXPECT_EQ(0u, data.num_incomplete_tiles);
   EXPECT_FALSE(active_layer()->only_used_low_res_last_append_quads());
 }
 
 TEST_F(PictureLayerImplTest, AppendQuadsDataForCheckerboard) {
   host_impl()->AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
 
@@ skipping 2174 matching lines @@
 
   EXPECT_EQ(1u, pending_layer()->num_tilings());
   EXPECT_EQ(2u, active_layer()->num_tilings());
 
   RebuildPropertyTreesOnPendingTree();
   host_impl()->AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
   // UpdateDrawProperties with the occluding layer.
   bool update_lcd_text = false;
   host_impl()->pending_tree()->UpdateDrawProperties(update_lcd_text);
 
+  float dest_scale = std::max(active_layer()->MaximumTilingContentsScale(),
+                              pending_layer()->MaximumTilingContentsScale());
+  gfx::Rect dest_layer_bounds =
+      gfx::ScaleToEnclosingRect(gfx::Rect(layer_bounds), dest_scale);
+  gfx::Rect dest_invalidation_rect =
+      gfx::ScaleToEnclosingRect(invalidation_rect, dest_scale);
+
   // The expected number of occluded tiles on each of the 2 tilings for each of
   // the 3 tree priorities.
   size_t expected_occluded_tile_count_on_pending[] = {4u, 0u};
   size_t expected_occluded_tile_count_on_active[] = {12u, 3u};
   size_t total_expected_occluded_tile_count_on_trees[] = {15u, 4u};
 
   // Verify number of occluded tiles on the pending layer for each tiling.
   for (size_t i = 0; i < pending_layer()->num_tilings(); ++i) {
     PictureLayerTiling* tiling = pending_layer()->tilings()->tiling_at(i);
     auto prioritized_tiles =
         tiling->UpdateAndGetAllPrioritizedTilesForTesting();
 
     size_t occluded_tile_count_on_pending = 0u;
-    for (PictureLayerTiling::CoverageIterator iter(tiling, 1.f,
-                                                   gfx::Rect(layer_bounds));
+    for (PictureLayerTiling::CoverageIterator iter(tiling, dest_scale,
+                                                   dest_layer_bounds);
          iter; ++iter) {
       Tile* tile = *iter;
 
-      if (invalidation_rect.Intersects(iter.geometry_rect()))
+      if (dest_invalidation_rect.Intersects(iter.geometry_rect()))
         EXPECT_TRUE(tile);
       else
         EXPECT_FALSE(tile);
 
       if (!tile)
         continue;
       if (prioritized_tiles[tile].is_occluded())
         occluded_tile_count_on_pending++;
     }
     EXPECT_EQ(expected_occluded_tile_count_on_pending[i],
               occluded_tile_count_on_pending)
         << tiling->contents_scale();
   }
 
   // Verify number of occluded tiles on the active layer for each tiling.
   for (size_t i = 0; i < active_layer()->num_tilings(); ++i) {
     PictureLayerTiling* tiling = active_layer()->tilings()->tiling_at(i);
     auto prioritized_tiles =
         tiling->UpdateAndGetAllPrioritizedTilesForTesting();
 
     size_t occluded_tile_count_on_active = 0u;
-    for (PictureLayerTiling::CoverageIterator iter(tiling, 1.f,
-                                                   gfx::Rect(layer_bounds));
+    for (PictureLayerTiling::CoverageIterator iter(tiling, dest_scale,
+                                                   dest_layer_bounds);
          iter; ++iter) {
       Tile* tile = *iter;
 
       if (!tile)
         continue;
       if (prioritized_tiles[tile].is_occluded())
         occluded_tile_count_on_active++;
     }
     EXPECT_EQ(expected_occluded_tile_count_on_active[i],
               occluded_tile_count_on_active)
@@ skipping 778 matching lines @@
     EXPECT_FLOAT_EQ(expected_contents_scale,
                     pending_layer_ptr->picture_layer_tiling_set()
                         ->FindTilingWithResolution(HIGH_RESOLUTION)
                         ->contents_scale())
         << "ideal_contents_scale: " << ideal_contents_scale;
   }
 }
 
 }  // namespace
 }  // namespace cc