Raster PictureLayerTiling with fractional translation

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 29 matching lines @@
                                                gfx::Rect(device_viewport));
 }
 
 class TestablePictureLayerTiling : public PictureLayerTiling {
  public:
   using PictureLayerTiling::SetLiveTilesRect;
   using PictureLayerTiling::TileAt;
 
   static std::unique_ptr<TestablePictureLayerTiling> Create(
       WhichTree tree,
-      float contents_scale,
+      const ScaleTranslate2d& raster_transform,
       scoped_refptr<RasterSource> raster_source,
       PictureLayerTilingClient* client,
       const LayerTreeSettings& settings) {
     return base::WrapUnique(new TestablePictureLayerTiling(
-        tree, contents_scale, raster_source, client,
+        tree, raster_transform, 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,
+                             const ScaleTranslate2d& raster_transform,
                              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,
                              float max_preraster_distance)
       : PictureLayerTiling(tree,
-                           contents_scale,
+                           raster_transform,
                            raster_source,
                            client,
                            min_preraster_distance,
                            max_preraster_distance) {}
 };
 
 class PictureLayerTilingIteratorTest : public testing::Test {
  public:
   PictureLayerTilingIteratorTest() {}
   ~PictureLayerTilingIteratorTest() override {}
 
   void Initialize(const gfx::Size& tile_size,
                   float contents_scale,
                   const gfx::Size& layer_bounds) {
     client_.SetTileSize(tile_size);
     scoped_refptr<FakeRasterSource> raster_source =
         FakeRasterSource::CreateFilled(layer_bounds);
-    tiling_ = TestablePictureLayerTiling::Create(PENDING_TREE, contents_scale,
+    tiling_ = TestablePictureLayerTiling::Create(
+        PENDING_TREE, ScaleTranslate2d(contents_scale, gfx::Vector2dF()),
+        raster_source, &client_, LayerTreeSettings());
+    tiling_->set_resolution(HIGH_RESOLUTION);
+  }
+
+  void InitializeWithTranslation(const gfx::Size& tile_size,
+                                 const ScaleTranslate2d& raster_transform,
+                                 const gfx::Size& layer_bounds) {
+    client_.SetTileSize(tile_size);
+    scoped_refptr<FakeRasterSource> raster_source =
+        FakeRasterSource::CreateFilled(layer_bounds);
+    tiling_ = TestablePictureLayerTiling::Create(PENDING_TREE, raster_transform,
                                                  raster_source, &client_,
                                                  LayerTreeSettings());
     tiling_->set_resolution(HIGH_RESOLUTION);
   }
 
   void InitializeActive(const gfx::Size& tile_size,
                         float contents_scale,
                         const gfx::Size& layer_bounds) {
     client_.SetTileSize(tile_size);
     scoped_refptr<FakeRasterSource> raster_source =
         FakeRasterSource::CreateFilled(layer_bounds);
-    tiling_ = TestablePictureLayerTiling::Create(ACTIVE_TREE, contents_scale,
-                                                 raster_source, &client_,
-                                                 LayerTreeSettings());
+    tiling_ = TestablePictureLayerTiling::Create(
+        ACTIVE_TREE, ScaleTranslate2d(contents_scale, gfx::Vector2dF()),
+        raster_source, &client_, LayerTreeSettings());
     tiling_->set_resolution(HIGH_RESOLUTION);
   }
 
   void SetLiveRectAndVerifyTiles(const gfx::Rect& live_tiles_rect) {
     tiling_->SetLiveTilesRect(live_tiles_rect);
 
     std::vector<Tile*> tiles = tiling_->AllTilesForTesting();
     for (std::vector<Tile*>::iterator iter = tiles.begin();
          iter != tiles.end();
          ++iter) {
       EXPECT_TRUE(live_tiles_rect.Intersects((*iter)->content_rect()));
     }
   }
 
   void VerifyTilesExactlyCoverRect(
       float rect_scale,
       const gfx::Rect& request_rect,
       const gfx::Rect& expect_rect) {
     EXPECT_TRUE(request_rect.Contains(expect_rect));
 
     // Iterators are not valid if the destination scale is smaller than the
     // tiling scale. This is because coverage computation is done in integer
     // grids in the dest space, and the overlap between tiles may not guarantee
     // to enclose an integer grid line to round to if scaled down.
-    ASSERT_GE(rect_scale, tiling_->contents_scale());
+    ASSERT_GE(rect_scale, tiling_->contents_scale_key());
 
     Region remaining = expect_rect;
     for (PictureLayerTiling::CoverageIterator
              iter(tiling_.get(), rect_scale, request_rect);
          iter;
          ++iter) {
       // Geometry cannot overlap previous geometry at all
       gfx::Rect geometry = iter.geometry_rect();
       EXPECT_TRUE(expect_rect.Contains(geometry));
       EXPECT_TRUE(remaining.Contains(geometry));
@@ skipping 47 matching lines @@
          iter;
          ++iter) {
       remaining.Subtract(iter.geometry_rect());
       callback.Run(*iter, iter.geometry_rect());
     }
     EXPECT_TRUE(remaining.IsEmpty());
   }
 
   void VerifyTilesCoverNonContainedRect(float rect_scale,
                                         const gfx::Rect& dest_rect) {
-    float dest_to_contents_scale = tiling_->contents_scale() / rect_scale;
+    float dest_to_contents_scale = tiling_->contents_scale_key() / rect_scale;
     gfx::Rect clamped_rect = gfx::ScaleToEnclosingRect(
         gfx::Rect(tiling_->tiling_size()), 1.f / dest_to_contents_scale);
     clamped_rect.Intersect(dest_rect);
     VerifyTilesExactlyCoverRect(rect_scale, dest_rect, clamped_rect);
   }
 
  protected:
   FakePictureLayerTilingClient client_;
   std::unique_ptr<TestablePictureLayerTiling> tiling_;
   bool loose_texel_extent_check_ = false;
@@ skipping 272 matching lines @@
 TEST_F(PictureLayerTilingIteratorTest, CreateTileJustCoverBorderUp) {
   float content_scale = 1.2000000476837158f;
   gfx::Size tile_size(512, 512);
   gfx::Size layer_size(1440, 4560);
   FakePictureLayerTilingClient active_client;
 
   active_client.SetTileSize(tile_size);
   scoped_refptr<FakeRasterSource> raster_source =
       FakeRasterSource::CreateFilled(layer_size);
   std::unique_ptr<TestablePictureLayerTiling> active_tiling =
-      TestablePictureLayerTiling::Create(ACTIVE_TREE, content_scale,
-                                         raster_source, &active_client,
-                                         LayerTreeSettings());
+      TestablePictureLayerTiling::Create(
+          ACTIVE_TREE, ScaleTranslate2d(content_scale, gfx::Vector2dF()),
+          raster_source, &active_client, LayerTreeSettings());
   active_tiling->set_resolution(HIGH_RESOLUTION);
 
   gfx::Rect invalid_rect(0, 750, 220, 100);
   Initialize(tile_size, content_scale, layer_size);
   client_.set_twin_tiling(active_tiling.get());
   client_.set_invalidation(invalid_rect);
   SetLiveRectAndVerifyTiles(gfx::Rect(layer_size));
   // When it creates a tile in pending tree, verify that tiles are invalidated
   // even if only their border pixels intersect the invalidation rect
   EXPECT_TRUE(tiling_->TileAt(0, 1));
@@ skipping 194 matching lines @@
 
 TEST_F(PictureLayerTilingIteratorTest,
        TilesExistLargeViewportAndLayerWithSmallVisibleArea) {
   gfx::Size layer_bounds(10000, 10000);
   client_.SetTileSize(gfx::Size(100, 100));
   LayerTreeSettings settings;
   settings.tiling_interest_area_padding = 1;
 
   scoped_refptr<FakeRasterSource> raster_source =
       FakeRasterSource::CreateFilled(layer_bounds);
-  tiling_ = TestablePictureLayerTiling::Create(PENDING_TREE, 1.f, raster_source,
-                                               &client_, settings);
+  tiling_ = TestablePictureLayerTiling::Create(
+      PENDING_TREE, ScaleTranslate2d(), raster_source, &client_, settings);
   tiling_->set_resolution(HIGH_RESOLUTION);
   VerifyTilesExactlyCoverRect(1.f, gfx::Rect(layer_bounds));
   VerifyTiles(1.f, gfx::Rect(layer_bounds), base::Bind(&TileExists, false));
 
   gfx::Rect visible_rect(8000, 8000, 50, 50);
 
   tiling_->ComputeTilePriorityRects(visible_rect,  // visible rect
                                     visible_rect,  // skewport
                                     visible_rect,  // soon border rect
                                     visible_rect,  // eventually rect
@@ skipping 16 matching lines @@
   gfx::Transform current_screen_transform;
 
   gfx::Rect viewport_in_layer_space = ViewportInLayerSpace(
       current_screen_transform, device_viewport);
 
   client.SetTileSize(gfx::Size(100, 100));
 
   scoped_refptr<FakeRasterSource> raster_source =
       FakeRasterSource::CreateFilled(current_layer_bounds);
   std::unique_ptr<TestablePictureLayerTiling> tiling =
-      TestablePictureLayerTiling::Create(ACTIVE_TREE, 1.0f, raster_source,
-                                         &client, LayerTreeSettings());
+      TestablePictureLayerTiling::Create(ACTIVE_TREE, ScaleTranslate2d(),
+                                         raster_source, &client,
+                                         LayerTreeSettings());
   tiling->set_resolution(HIGH_RESOLUTION);
 
   LayerTreeSettings settings;
   gfx::Rect eventually_rect = viewport_in_layer_space;
   eventually_rect.Inset(-settings.tiling_interest_area_padding,
                         -settings.tiling_interest_area_padding);
   tiling->ComputeTilePriorityRects(
       viewport_in_layer_space, viewport_in_layer_space, viewport_in_layer_space,
       eventually_rect, current_layer_contents_scale, Occlusion());
   auto prioritized_tiles = tiling->UpdateAndGetAllPrioritizedTilesForTesting();
@@ skipping 36 matching lines @@
   last_screen_transform = current_screen_transform;
 
   gfx::Rect viewport_in_layer_space = ViewportInLayerSpace(
       current_screen_transform, device_viewport);
 
   client.SetTileSize(gfx::Size(100, 100));
 
   scoped_refptr<FakeRasterSource> raster_source =
       FakeRasterSource::CreateFilled(current_layer_bounds);
   std::unique_ptr<TestablePictureLayerTiling> tiling =
-      TestablePictureLayerTiling::Create(ACTIVE_TREE, 1.0f, raster_source,
-                                         &client, LayerTreeSettings());
+      TestablePictureLayerTiling::Create(ACTIVE_TREE, ScaleTranslate2d(),
+                                         raster_source, &client,
+                                         LayerTreeSettings());
   tiling->set_resolution(HIGH_RESOLUTION);
 
   LayerTreeSettings settings;
   gfx::Rect eventually_rect = viewport_in_layer_space;
   eventually_rect.Inset(-settings.tiling_interest_area_padding,
                         -settings.tiling_interest_area_padding);
   tiling->ComputeTilePriorityRects(
       viewport_in_layer_space, viewport_in_layer_space, viewport_in_layer_space,
       eventually_rect, current_layer_contents_scale, Occlusion());
   auto prioritized_tiles = tiling->UpdateAndGetAllPrioritizedTilesForTesting();
@@ skipping 46 matching lines @@
   last_screen_transform = current_screen_transform;
 
   gfx::Rect viewport_in_layer_space = ViewportInLayerSpace(
       current_screen_transform, device_viewport);
 
   client.SetTileSize(gfx::Size(100, 100));
 
   scoped_refptr<FakeRasterSource> raster_source =
       FakeRasterSource::CreateFilled(current_layer_bounds);
   std::unique_ptr<TestablePictureLayerTiling> tiling =
-      TestablePictureLayerTiling::Create(ACTIVE_TREE, 1.0f, raster_source,
-                                         &client, LayerTreeSettings());
+      TestablePictureLayerTiling::Create(ACTIVE_TREE, ScaleTranslate2d(),
+                                         raster_source, &client,
+                                         LayerTreeSettings());
   tiling->set_resolution(HIGH_RESOLUTION);
 
   LayerTreeSettings settings;
   gfx::Rect eventually_rect = viewport_in_layer_space;
   eventually_rect.Inset(-settings.tiling_interest_area_padding,
                         -settings.tiling_interest_area_padding);
   tiling->ComputeTilePriorityRects(
       viewport_in_layer_space, viewport_in_layer_space, viewport_in_layer_space,
       eventually_rect, current_layer_contents_scale, Occlusion());
   auto prioritized_tiles = tiling->UpdateAndGetAllPrioritizedTilesForTesting();
@@ skipping 20 matching lines @@
   EXPECT_NE(TilePriority::NOW, priority.priority_bin);
 }
 
 TEST(PictureLayerTilingTest, RecycledTilesClearedOnReset) {
   FakePictureLayerTilingClient active_client;
   active_client.SetTileSize(gfx::Size(100, 100));
 
   scoped_refptr<FakeRasterSource> raster_source =
       FakeRasterSource::CreateFilled(gfx::Size(100, 100));
   std::unique_ptr<TestablePictureLayerTiling> active_tiling =
-      TestablePictureLayerTiling::Create(ACTIVE_TREE, 1.0f, raster_source,
-                                         &active_client, LayerTreeSettings());
+      TestablePictureLayerTiling::Create(ACTIVE_TREE, ScaleTranslate2d(),
+                                         raster_source, &active_client,
+                                         LayerTreeSettings());
   active_tiling->set_resolution(HIGH_RESOLUTION);
   // Create all tiles on this tiling.
   gfx::Rect visible_rect = gfx::Rect(0, 0, 100, 100);
   active_tiling->ComputeTilePriorityRects(
       visible_rect, visible_rect, visible_rect, visible_rect, 1.f, Occlusion());
 
   FakePictureLayerTilingClient recycle_client;
   recycle_client.SetTileSize(gfx::Size(100, 100));
   recycle_client.set_twin_tiling(active_tiling.get());
 
   LayerTreeSettings settings;
 
   raster_source = FakeRasterSource::CreateFilled(gfx::Size(100, 100));
   std::unique_ptr<TestablePictureLayerTiling> recycle_tiling =
-      TestablePictureLayerTiling::Create(PENDING_TREE, 1.0f, raster_source,
-                                         &recycle_client, settings);
+      TestablePictureLayerTiling::Create(PENDING_TREE, ScaleTranslate2d(),
+                                         raster_source, &recycle_client,
+                                         settings);
   recycle_tiling->set_resolution(HIGH_RESOLUTION);
 
   // Create all tiles on the recycle tiling.
   recycle_tiling->ComputeTilePriorityRects(visible_rect, visible_rect,
                                            visible_rect, visible_rect, 1.0f,
                                            Occlusion());
 
   // Set the second tiling as recycled.
   active_client.set_twin_tiling(NULL);
   recycle_client.set_twin_tiling(NULL);
 
   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());
+      TestablePictureLayerTiling::Create(PENDING_TREE, ScaleTranslate2d(),
+                                         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());
@@ skipping 50 matching lines @@
 TEST_F(PictureLayerTilingIteratorTest, GiantRect) {
   loose_texel_extent_check_ = true;
 
   gfx::Size tile_size(256, 256);
   gfx::Size layer_size(33554432, 33554432);
   float contents_scale = 1.f;
 
   client_.SetTileSize(tile_size);
   scoped_refptr<FakeRasterSource> raster_source =
       FakeRasterSource::CreateEmpty(layer_size);
-  tiling_ = TestablePictureLayerTiling::Create(PENDING_TREE, contents_scale,
-                                               raster_source, &client_,
-                                               LayerTreeSettings());
+  tiling_ = TestablePictureLayerTiling::Create(
+      PENDING_TREE, ScaleTranslate2d(contents_scale, gfx::Vector2dF()),
+      raster_source, &client_, LayerTreeSettings());
 
   gfx::Rect content_rect(25554432, 25554432, 950, 860);
   VerifyTilesExactlyCoverRect(contents_scale, content_rect);
 }
 
 TEST_F(PictureLayerTilingIteratorTest, QuadShouldNotUseLastHalfTexel) {
   Initialize(gfx::Size(100, 100), 1.f, gfx::Size(198, 198));
   // Creates a situation that tile bounds get rounded up by almost 1px in the
   // dest space. This test verifies that even in such situation the coverage
   // iterator won't generate a texture rect that can potentially get clamped.
@@ skipping 65 matching lines @@
   EXPECT_TRUE(tiles.size());
   for (const auto* tile : tiles) {
     EXPECT_EQ(tile->tiling(), tiling_.get());
   }
 
   // Create an active tiling, transfer tiles to that tiling, and ensure that
   // the tiles have their tiling updated.
   scoped_refptr<FakeRasterSource> raster_source =
       FakeRasterSource::CreateFilled(bounds);
   auto active_tiling = TestablePictureLayerTiling::Create(
-      ACTIVE_TREE, 1.f, raster_source, &client_, LayerTreeSettings());
+      ACTIVE_TREE, ScaleTranslate2d(), raster_source, &client_,
+      LayerTreeSettings());
   active_tiling->set_resolution(HIGH_RESOLUTION);
 
   active_tiling->TakeTilesAndPropertiesFrom(tiling_.get(),
                                             Region(gfx::Rect(bounds)));
   for (const auto* tile : tiles) {
     EXPECT_EQ(tile->tiling(), active_tiling.get());
   }
 }
 
+TEST_F(PictureLayerTilingIteratorTest, FractionalTranslatedTiling) {
+  InitializeWithTranslation(
+      gfx::Size(256, 256),
+      ScaleTranslate2d(1.f, gfx::Vector2dF(0.125f, 0.125f)),
+      gfx::Size(1000, 1));
+  EXPECT_EQ(tiling_->tiling_size(), gfx::Size(1001, 2));
+  SetLiveRectAndVerifyTiles(gfx::Rect(1000, 1));
+
+  // Verifies the texture coordinate is correctly translated.
+  for (PictureLayerTiling::CoverageIterator iter(tiling_.get(), 1.f,
+                                                 gfx::Rect(1000, 1));
+       iter; ++iter) {
+    gfx::Rect geometry_rect = iter.geometry_rect();
+    gfx::RectF texture_rect = iter.texture_rect();
+    if (geometry_rect == gfx::Rect(0, 0, 255, 1)) {
+      EXPECT_EQ(gfx::RectF(0.125f, 0.125f, 255.f, 1.f), texture_rect);
+    } else if (geometry_rect == gfx::Rect(255, 0, 254, 1)) {
+      EXPECT_EQ(gfx::RectF(1.125f, 0.125f, 254.f, 1.f), texture_rect);
+    } else if (geometry_rect == gfx::Rect(509, 0, 254, 1)) {
+      EXPECT_EQ(gfx::RectF(1.125f, 0.125f, 254.f, 1.f), texture_rect);
+    } else {
+      EXPECT_EQ(gfx::Rect(763, 0, 237, 1), geometry_rect);
+      EXPECT_EQ(gfx::RectF(1.125f, 0.125f, 237.f, 1.f), texture_rect);
+    }
+  }
+
+  // Similar to above, with a different coverage scale.
+  for (PictureLayerTiling::CoverageIterator iter(tiling_.get(), 1.375f,
+                                                 gfx::Rect(1375, 2));
+       iter; ++iter) {
+    gfx::Rect geometry_rect = iter.geometry_rect();
+    gfx::RectF texture_rect = iter.texture_rect();
+    if (geometry_rect == gfx::Rect(0, 0, 351, 2)) {
+      gfx::RectF expectation(geometry_rect);
+      expectation.Scale(1.f / 1.375f);
+      expectation.Offset(0.125f, 0.125f);
+      EXPECT_FLOAT_EQ(expectation.x(), texture_rect.x());
+      EXPECT_FLOAT_EQ(expectation.y(), texture_rect.y());
+      EXPECT_FLOAT_EQ(expectation.width(), texture_rect.width());
+      EXPECT_FLOAT_EQ(expectation.height(), texture_rect.height());
+    } else if (geometry_rect == gfx::Rect(351, 0, 349, 2)) {
+      gfx::RectF expectation(geometry_rect);
+      expectation.Scale(1.f / 1.375f);
+      expectation.Offset(0.125f - 254.f, 0.125f);
+      EXPECT_FLOAT_EQ(expectation.x(), texture_rect.x());
+      EXPECT_FLOAT_EQ(expectation.y(), texture_rect.y());
+      EXPECT_FLOAT_EQ(expectation.width(), texture_rect.width());
+      EXPECT_FLOAT_EQ(expectation.height(), texture_rect.height());
+    } else if (geometry_rect == gfx::Rect(700, 0, 349, 2)) {
+      gfx::RectF expectation(geometry_rect);
+      expectation.Scale(1.f / 1.375f);
+      expectation.Offset(0.125f - 254.f * 2.f, 0.125f);
+      EXPECT_FLOAT_EQ(expectation.x(), texture_rect.x());
+      EXPECT_FLOAT_EQ(expectation.y(), texture_rect.y());
+      EXPECT_FLOAT_EQ(expectation.width(), texture_rect.width());
+      EXPECT_FLOAT_EQ(expectation.height(), texture_rect.height());
+    } else {
+      EXPECT_EQ(gfx::Rect(1049, 0, 326, 2), geometry_rect);
+      gfx::RectF expectation(geometry_rect);
+      expectation.Scale(1.f / 1.375f);
+      expectation.Offset(0.125f - 254.f * 3.f, 0.125f);
+      EXPECT_FLOAT_EQ(expectation.x(), texture_rect.x());
+      EXPECT_FLOAT_EQ(expectation.y(), texture_rect.y());
+      EXPECT_FLOAT_EQ(expectation.width(), texture_rect.width());
+      EXPECT_FLOAT_EQ(expectation.height(), texture_rect.height());
+    }
+  }
+}
+
+TEST_F(PictureLayerTilingIteratorTest, FractionalTranslatedTilingOverflow) {
+  // This tests a corner case where the coverage rect is slightly greater
+  // than the layer rect due to rounding up, and the bottom right edge of
+  // the tiling coincide with actual layer bound. That is, the requested
+  // coverage rect slightly exceed the valid extent, but we still return
+  // full coverage as a special case for external edges.
+
+  // The layer bounds is (9, 9), which after scale and translation
+  // becomes (l=0.5, t=0.5, r=14, b=14) in the contents space.
+  InitializeWithTranslation(gfx::Size(256, 256),
+                            ScaleTranslate2d(1.5f, gfx::Vector2dF(0.5f, 0.5f)),
+                            gfx::Size(9, 9));
+  EXPECT_EQ(tiling_->tiling_size(), gfx::Size(14, 14));
+  SetLiveRectAndVerifyTiles(gfx::Rect(9, 9));
+
+  PictureLayerTiling::CoverageIterator iter(tiling_.get(), 1.56f,
+                                            gfx::Rect(15, 15));
+  ASSERT_TRUE(iter);
+  gfx::Rect geometry_rect = iter.geometry_rect();
+  gfx::RectF texture_rect = iter.texture_rect();
+  EXPECT_EQ(gfx::Rect(0, 0, 15, 15), geometry_rect);
+  gfx::RectF expectation(geometry_rect);
+  expectation.Scale(1.5f / 1.56f);
+  expectation.Offset(0.5f, 0.5f);
+  EXPECT_FLOAT_EQ(expectation.x(), texture_rect.x());
+  EXPECT_FLOAT_EQ(expectation.y(), texture_rect.y());
+  EXPECT_FLOAT_EQ(expectation.width(), texture_rect.width());
+  EXPECT_FLOAT_EQ(expectation.height(), texture_rect.height());
+
+  EXPECT_FALSE(++iter);
+}
+
 }  // namespace
 }  // namespace cc