1 // Copyright 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "cc/resources/picture_layer_tiling.h" 6 7 #include <limits> 8 9 #include "cc/base/math_util.h" 10 #include "cc/resources/picture_layer_tiling_set.h" 11 #include "cc/test/fake_picture_layer_tiling_client.h" 12 #include "testing/gtest/include/gtest/gtest.h" 13 #include "ui/gfx/rect_conversions.h" 14 #include "ui/gfx/size_conversions.h" 15 16 namespace cc { 17 namespace { 18 19 static gfx::Rect ViewportInLayerSpace( 20 const gfx::Transform& transform, 21 gfx::Size device_viewport) { 22 23 gfx::Transform inverse; 24 if (!transform.GetInverse(&inverse)) 25 return gfx::Rect(); 26 27 gfx::RectF viewport_in_layer_space = MathUtil::ProjectClippedRect( 28 inverse, gfx::RectF(gfx::Point(0, 0), device_viewport)); 29 30 return ToEnclosingRect(viewport_in_layer_space); 31 } 32 33 class TestablePictureLayerTiling : public PictureLayerTiling { 34 public: 35 using PictureLayerTiling::SetLiveTilesRect; 36 using PictureLayerTiling::TileAt; 37 38 static scoped_ptr<TestablePictureLayerTiling> Create( 39 float contents_scale, 40 gfx::Size layer_bounds, 41 PictureLayerTilingClient* client) { 42 return make_scoped_ptr(new TestablePictureLayerTiling( 43 contents_scale, 44 layer_bounds, 45 client)); 46 } 47 48 protected: 49 TestablePictureLayerTiling(float contents_scale, 50 gfx::Size layer_bounds, 51 PictureLayerTilingClient* client) 52 : PictureLayerTiling(contents_scale, layer_bounds, client) { } 53 }; 54 55 class PictureLayerTilingIteratorTest : public testing::Test { 56 public: 57 PictureLayerTilingIteratorTest() {} 58 virtual ~PictureLayerTilingIteratorTest() {} 59 60 void Initialize(gfx::Size tile_size, 61 float contents_scale, 62 gfx::Size layer_bounds) { 63 client_.SetTileSize(tile_size); 64 tiling_ = TestablePictureLayerTiling::Create(contents_scale, 65 layer_bounds, 66 &client_); 67 } 68 69 void SetLiveRectAndVerifyTiles(gfx::Rect live_tiles_rect) { 70 tiling_->SetLiveTilesRect(live_tiles_rect); 71 72 std::vector<Tile*> tiles = tiling_->AllTilesForTesting(); 73 for (std::vector<Tile*>::iterator iter = tiles.begin(); 74 iter != tiles.end(); 75 ++iter) { 76 EXPECT_TRUE(live_tiles_rect.Intersects((*iter)->content_rect())); 77 } 78 } 79 80 void VerifyTilesExactlyCoverRect( 81 float rect_scale, 82 gfx::Rect request_rect, 83 gfx::Rect expect_rect) { 84 EXPECT_TRUE(request_rect.Contains(expect_rect)); 85 86 // Iterators are not valid if this ratio is too large (i.e. the 87 // tiling is too high-res for a low-res destination rect.) This is an 88 // artifact of snapping geometry to integer coordinates and then mapping 89 // back to floating point texture coordinates. 90 float dest_to_contents_scale = tiling_->contents_scale() / rect_scale; 91 ASSERT_LE(dest_to_contents_scale, 2.0); 92 93 Region remaining = expect_rect; 94 for (PictureLayerTiling::CoverageIterator 95 iter(tiling_.get(), rect_scale, request_rect); 96 iter; 97 ++iter) { 98 // Geometry cannot overlap previous geometry at all 99 gfx::Rect geometry = iter.geometry_rect(); 100 EXPECT_TRUE(expect_rect.Contains(geometry)); 101 EXPECT_TRUE(remaining.Contains(geometry)); 102 remaining.Subtract(geometry); 103 104 // Sanity check that texture coords are within the texture rect. 105 gfx::RectF texture_rect = iter.texture_rect(); 106 EXPECT_GE(texture_rect.x(), 0); 107 EXPECT_GE(texture_rect.y(), 0); 108 EXPECT_LE(texture_rect.right(), client_.TileSize().width()); 109 EXPECT_LE(texture_rect.bottom(), client_.TileSize().height()); 110 111 EXPECT_EQ(iter.texture_size(), client_.TileSize()); 112 } 113 114 // The entire rect must be filled by geometry from the tiling. 115 EXPECT_TRUE(remaining.IsEmpty()); 116 } 117 118 void VerifyTilesExactlyCoverRect(float rect_scale, gfx::Rect rect) { 119 VerifyTilesExactlyCoverRect(rect_scale, rect, rect); 120 } 121 122 void VerifyTiles( 123 float rect_scale, 124 gfx::Rect rect, 125 base::Callback<void(Tile* tile, gfx::Rect geometry_rect)> callback) { 126 VerifyTiles(tiling_.get(), 127 rect_scale, 128 rect, 129 callback); 130 } 131 132 void VerifyTiles( 133 PictureLayerTiling* tiling, 134 float rect_scale, 135 gfx::Rect rect, 136 base::Callback<void(Tile* tile, gfx::Rect geometry_rect)> callback) { 137 Region remaining = rect; 138 for (PictureLayerTiling::CoverageIterator iter(tiling, rect_scale, rect); 139 iter; 140 ++iter) { 141 remaining.Subtract(iter.geometry_rect()); 142 callback.Run(*iter, iter.geometry_rect()); 143 } 144 EXPECT_TRUE(remaining.IsEmpty()); 145 } 146 147 void VerifyTilesCoverNonContainedRect(float rect_scale, gfx::Rect dest_rect) { 148 float dest_to_contents_scale = tiling_->contents_scale() / rect_scale; 149 gfx::Rect clamped_rect = gfx::ScaleToEnclosingRect( 150 tiling_->ContentRect(), 1.f / dest_to_contents_scale); 151 clamped_rect.Intersect(dest_rect); 152 VerifyTilesExactlyCoverRect(rect_scale, dest_rect, clamped_rect); 153 } 154 155 protected: 156 FakePictureLayerTilingClient client_; 157 scoped_ptr<TestablePictureLayerTiling> tiling_; 158 159 private: 160 DISALLOW_COPY_AND_ASSIGN(PictureLayerTilingIteratorTest); 161 }; 162 163 TEST_F(PictureLayerTilingIteratorTest, LiveTilesExactlyCoverLiveTileRect) { 164 Initialize(gfx::Size(100, 100), 1, gfx::Size(1099, 801)); 165 SetLiveRectAndVerifyTiles(gfx::Rect(100, 100)); 166 SetLiveRectAndVerifyTiles(gfx::Rect(101, 99)); 167 SetLiveRectAndVerifyTiles(gfx::Rect(1099, 1)); 168 SetLiveRectAndVerifyTiles(gfx::Rect(1, 801)); 169 SetLiveRectAndVerifyTiles(gfx::Rect(1099, 1)); 170 SetLiveRectAndVerifyTiles(gfx::Rect(201, 800)); 171 } 172 173 TEST_F(PictureLayerTilingIteratorTest, IteratorCoversLayerBoundsNoScale) { 174 Initialize(gfx::Size(100, 100), 1, gfx::Size(1099, 801)); 175 VerifyTilesExactlyCoverRect(1, gfx::Rect()); 176 VerifyTilesExactlyCoverRect(1, gfx::Rect(0, 0, 1099, 801)); 177 VerifyTilesExactlyCoverRect(1, gfx::Rect(52, 83, 789, 412)); 178 179 // With borders, a size of 3x3 = 1 pixel of content. 180 Initialize(gfx::Size(3, 3), 1, gfx::Size(10, 10)); 181 VerifyTilesExactlyCoverRect(1, gfx::Rect(0, 0, 1, 1)); 182 VerifyTilesExactlyCoverRect(1, gfx::Rect(0, 0, 2, 2)); 183 VerifyTilesExactlyCoverRect(1, gfx::Rect(1, 1, 2, 2)); 184 VerifyTilesExactlyCoverRect(1, gfx::Rect(3, 2, 5, 2)); 185 } 186 187 TEST_F(PictureLayerTilingIteratorTest, IteratorCoversLayerBoundsTilingScale) { 188 Initialize(gfx::Size(200, 100), 2.0f, gfx::Size(1005, 2010)); 189 VerifyTilesExactlyCoverRect(1, gfx::Rect()); 190 VerifyTilesExactlyCoverRect(1, gfx::Rect(0, 0, 1005, 2010)); 191 VerifyTilesExactlyCoverRect(1, gfx::Rect(50, 112, 512, 381)); 192 193 Initialize(gfx::Size(3, 3), 2.0f, gfx::Size(10, 10)); 194 VerifyTilesExactlyCoverRect(1, gfx::Rect()); 195 VerifyTilesExactlyCoverRect(1, gfx::Rect(0, 0, 1, 1)); 196 VerifyTilesExactlyCoverRect(1, gfx::Rect(0, 0, 2, 2)); 197 VerifyTilesExactlyCoverRect(1, gfx::Rect(1, 1, 2, 2)); 198 VerifyTilesExactlyCoverRect(1, gfx::Rect(3, 2, 5, 2)); 199 200 Initialize(gfx::Size(100, 200), 0.5f, gfx::Size(1005, 2010)); 201 VerifyTilesExactlyCoverRect(1, gfx::Rect(0, 0, 1005, 2010)); 202 VerifyTilesExactlyCoverRect(1, gfx::Rect(50, 112, 512, 381)); 203 204 Initialize(gfx::Size(150, 250), 0.37f, gfx::Size(1005, 2010)); 205 VerifyTilesExactlyCoverRect(1, gfx::Rect(0, 0, 1005, 2010)); 206 VerifyTilesExactlyCoverRect(1, gfx::Rect(50, 112, 512, 381)); 207 208 Initialize(gfx::Size(312, 123), 0.01f, gfx::Size(1005, 2010)); 209 VerifyTilesExactlyCoverRect(1, gfx::Rect(0, 0, 1005, 2010)); 210 VerifyTilesExactlyCoverRect(1, gfx::Rect(50, 112, 512, 381)); 211 } 212 213 TEST_F(PictureLayerTilingIteratorTest, IteratorCoversLayerBoundsBothScale) { 214 Initialize(gfx::Size(50, 50), 4.0f, gfx::Size(800, 600)); 215 VerifyTilesExactlyCoverRect(2.0f, gfx::Rect()); 216 VerifyTilesExactlyCoverRect(2.0f, gfx::Rect(0, 0, 1600, 1200)); 217 VerifyTilesExactlyCoverRect(2.0f, gfx::Rect(512, 365, 253, 182)); 218 219 float scale = 6.7f; 220 gfx::Size bounds(800, 600); 221 gfx::Rect full_rect(gfx::ToCeiledSize(gfx::ScaleSize(bounds, scale))); 222 Initialize(gfx::Size(256, 512), 5.2f, bounds); 223 VerifyTilesExactlyCoverRect(scale, full_rect); 224 VerifyTilesExactlyCoverRect(scale, gfx::Rect(2014, 1579, 867, 1033)); 225 } 226 227 TEST_F(PictureLayerTilingIteratorTest, IteratorEmptyRect) { 228 Initialize(gfx::Size(100, 100), 1.0f, gfx::Size(800, 600)); 229 230 gfx::Rect empty; 231 PictureLayerTiling::CoverageIterator iter(tiling_.get(), 1.0f, empty); 232 EXPECT_FALSE(iter); 233 } 234 235 TEST_F(PictureLayerTilingIteratorTest, NonIntersectingRect) { 236 Initialize(gfx::Size(100, 100), 1.0f, gfx::Size(800, 600)); 237 gfx::Rect non_intersecting(1000, 1000, 50, 50); 238 PictureLayerTiling::CoverageIterator iter(tiling_.get(), 1, non_intersecting); 239 EXPECT_FALSE(iter); 240 } 241 242 TEST_F(PictureLayerTilingIteratorTest, LayerEdgeTextureCoordinates) { 243 Initialize(gfx::Size(300, 300), 1.0f, gfx::Size(256, 256)); 244 // All of these sizes are 256x256, scaled and ceiled. 245 VerifyTilesExactlyCoverRect(1.0f, gfx::Rect(0, 0, 256, 256)); 246 VerifyTilesExactlyCoverRect(0.8f, gfx::Rect(0, 0, 205, 205)); 247 VerifyTilesExactlyCoverRect(1.2f, gfx::Rect(0, 0, 308, 308)); 248 } 249 250 TEST_F(PictureLayerTilingIteratorTest, NonContainedDestRect) { 251 Initialize(gfx::Size(100, 100), 1.0f, gfx::Size(400, 400)); 252 253 // Too large in all dimensions 254 VerifyTilesCoverNonContainedRect(1.0f, gfx::Rect(-1000, -1000, 2000, 2000)); 255 VerifyTilesCoverNonContainedRect(1.5f, gfx::Rect(-1000, -1000, 2000, 2000)); 256 VerifyTilesCoverNonContainedRect(0.5f, gfx::Rect(-1000, -1000, 2000, 2000)); 257 258 // Partially covering content, but too large 259 VerifyTilesCoverNonContainedRect(1.0f, gfx::Rect(-1000, 100, 2000, 100)); 260 VerifyTilesCoverNonContainedRect(1.5f, gfx::Rect(-1000, 100, 2000, 100)); 261 VerifyTilesCoverNonContainedRect(0.5f, gfx::Rect(-1000, 100, 2000, 100)); 262 } 263 264 TEST(PictureLayerTilingTest, ExpandRectEqual) { 265 gfx::Rect in(40, 50, 100, 200); 266 gfx::Rect bounds(-1000, -1000, 10000, 10000); 267 int64 target_area = 100 * 200; 268 gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy( 269 in, target_area, bounds, NULL); 270 EXPECT_EQ(in.ToString(), out.ToString()); 271 } 272 273 TEST(PictureLayerTilingTest, ExpandRectSmaller) { 274 gfx::Rect in(40, 50, 100, 200); 275 gfx::Rect bounds(-1000, -1000, 10000, 10000); 276 int64 target_area = 100 * 100; 277 gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy( 278 in, target_area, bounds, NULL); 279 EXPECT_EQ(out.bottom() - in.bottom(), in.y() - out.y()); 280 EXPECT_EQ(out.right() - in.right(), in.x() - out.x()); 281 EXPECT_EQ(out.width() - in.width(), out.height() - in.height()); 282 EXPECT_NEAR(100 * 100, out.width() * out.height(), 50); 283 EXPECT_TRUE(bounds.Contains(out)); 284 } 285 286 TEST(PictureLayerTilingTest, ExpandRectUnbounded) { 287 gfx::Rect in(40, 50, 100, 200); 288 gfx::Rect bounds(-1000, -1000, 10000, 10000); 289 int64 target_area = 200 * 200; 290 gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy( 291 in, target_area, bounds, NULL); 292 EXPECT_EQ(out.bottom() - in.bottom(), in.y() - out.y()); 293 EXPECT_EQ(out.right() - in.right(), in.x() - out.x()); 294 EXPECT_EQ(out.width() - in.width(), out.height() - in.height()); 295 EXPECT_NEAR(200 * 200, out.width() * out.height(), 100); 296 EXPECT_TRUE(bounds.Contains(out)); 297 } 298 299 TEST(PictureLayerTilingTest, ExpandRectBoundedSmaller) { 300 gfx::Rect in(40, 50, 100, 200); 301 gfx::Rect bounds(50, 60, 40, 30); 302 int64 target_area = 200 * 200; 303 gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy( 304 in, target_area, bounds, NULL); 305 EXPECT_EQ(bounds.ToString(), out.ToString()); 306 } 307 308 TEST(PictureLayerTilingTest, ExpandRectBoundedEqual) { 309 gfx::Rect in(40, 50, 100, 200); 310 gfx::Rect bounds = in; 311 int64 target_area = 200 * 200; 312 gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy( 313 in, target_area, bounds, NULL); 314 EXPECT_EQ(bounds.ToString(), out.ToString()); 315 } 316 317 TEST(PictureLayerTilingTest, ExpandRectBoundedSmallerStretchVertical) { 318 gfx::Rect in(40, 50, 100, 200); 319 gfx::Rect bounds(45, 0, 90, 300); 320 int64 target_area = 200 * 200; 321 gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy( 322 in, target_area, bounds, NULL); 323 EXPECT_EQ(bounds.ToString(), out.ToString()); 324 } 325 326 TEST(PictureLayerTilingTest, ExpandRectBoundedEqualStretchVertical) { 327 gfx::Rect in(40, 50, 100, 200); 328 gfx::Rect bounds(40, 0, 100, 300); 329 int64 target_area = 200 * 200; 330 gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy( 331 in, target_area, bounds, NULL); 332 EXPECT_EQ(bounds.ToString(), out.ToString()); 333 } 334 335 TEST(PictureLayerTilingTest, ExpandRectBoundedSmallerStretchHorizontal) { 336 gfx::Rect in(40, 50, 100, 200); 337 gfx::Rect bounds(0, 55, 180, 190); 338 int64 target_area = 200 * 200; 339 gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy( 340 in, target_area, bounds, NULL); 341 EXPECT_EQ(bounds.ToString(), out.ToString()); 342 } 343 344 TEST(PictureLayerTilingTest, ExpandRectBoundedEqualStretchHorizontal) { 345 gfx::Rect in(40, 50, 100, 200); 346 gfx::Rect bounds(0, 50, 180, 200); 347 int64 target_area = 200 * 200; 348 gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy( 349 in, target_area, bounds, NULL); 350 EXPECT_EQ(bounds.ToString(), out.ToString()); 351 } 352 353 TEST(PictureLayerTilingTest, ExpandRectBoundedLeft) { 354 gfx::Rect in(40, 50, 100, 200); 355 gfx::Rect bounds(20, -1000, 10000, 10000); 356 int64 target_area = 200 * 200; 357 gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy( 358 in, target_area, bounds, NULL); 359 EXPECT_EQ(out.bottom() - in.bottom(), in.y() - out.y()); 360 EXPECT_EQ(out.bottom() - in.bottom(), out.right() - in.right()); 361 EXPECT_LE(out.width() * out.height(), target_area); 362 EXPECT_GT(out.width() * out.height(), 363 target_area - out.width() - out.height() * 2); 364 EXPECT_TRUE(bounds.Contains(out)); 365 } 366 367 TEST(PictureLayerTilingTest, ExpandRectBoundedRight) { 368 gfx::Rect in(40, 50, 100, 200); 369 gfx::Rect bounds(-1000, -1000, 1000+120, 10000); 370 int64 target_area = 200 * 200; 371 gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy( 372 in, target_area, bounds, NULL); 373 EXPECT_EQ(out.bottom() - in.bottom(), in.y() - out.y()); 374 EXPECT_EQ(out.bottom() - in.bottom(), in.x() - out.x()); 375 EXPECT_LE(out.width() * out.height(), target_area); 376 EXPECT_GT(out.width() * out.height(), 377 target_area - out.width() - out.height() * 2); 378 EXPECT_TRUE(bounds.Contains(out)); 379 } 380 381 TEST(PictureLayerTilingTest, ExpandRectBoundedTop) { 382 gfx::Rect in(40, 50, 100, 200); 383 gfx::Rect bounds(-1000, 30, 10000, 10000); 384 int64 target_area = 200 * 200; 385 gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy( 386 in, target_area, bounds, NULL); 387 EXPECT_EQ(out.right() - in.right(), in.x() - out.x()); 388 EXPECT_EQ(out.right() - in.right(), out.bottom() - in.bottom()); 389 EXPECT_LE(out.width() * out.height(), target_area); 390 EXPECT_GT(out.width() * out.height(), 391 target_area - out.width() * 2 - out.height()); 392 EXPECT_TRUE(bounds.Contains(out)); 393 } 394 395 TEST(PictureLayerTilingTest, ExpandRectBoundedBottom) { 396 gfx::Rect in(40, 50, 100, 200); 397 gfx::Rect bounds(-1000, -1000, 10000, 1000 + 220); 398 int64 target_area = 200 * 200; 399 gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy( 400 in, target_area, bounds, NULL); 401 EXPECT_EQ(out.right() - in.right(), in.x() - out.x()); 402 EXPECT_EQ(out.right() - in.right(), in.y() - out.y()); 403 EXPECT_LE(out.width() * out.height(), target_area); 404 EXPECT_GT(out.width() * out.height(), 405 target_area - out.width() * 2 - out.height()); 406 EXPECT_TRUE(bounds.Contains(out)); 407 } 408 409 TEST(PictureLayerTilingTest, ExpandRectSquishedHorizontally) { 410 gfx::Rect in(40, 50, 100, 200); 411 gfx::Rect bounds(0, -4000, 100+40+20, 100000); 412 int64 target_area = 400 * 400; 413 gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy( 414 in, target_area, bounds, NULL); 415 EXPECT_EQ(20, out.right() - in.right()); 416 EXPECT_EQ(40, in.x() - out.x()); 417 EXPECT_EQ(out.bottom() - in.bottom(), in.y() - out.y()); 418 EXPECT_LE(out.width() * out.height(), target_area); 419 EXPECT_GT(out.width() * out.height(), 420 target_area - out.width() * 2); 421 EXPECT_TRUE(bounds.Contains(out)); 422 } 423 424 TEST(PictureLayerTilingTest, ExpandRectSquishedVertically) { 425 gfx::Rect in(40, 50, 100, 200); 426 gfx::Rect bounds(-4000, 0, 100000, 200+50+30); 427 int64 target_area = 400 * 400; 428 gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy( 429 in, target_area, bounds, NULL); 430 EXPECT_EQ(30, out.bottom() - in.bottom()); 431 EXPECT_EQ(50, in.y() - out.y()); 432 EXPECT_EQ(out.right() - in.right(), in.x() - out.x()); 433 EXPECT_LE(out.width() * out.height(), target_area); 434 EXPECT_GT(out.width() * out.height(), 435 target_area - out.height() * 2); 436 EXPECT_TRUE(bounds.Contains(out)); 437 } 438 439 TEST(PictureLayerTilingTest, ExpandRectOutOfBoundsFarAway) { 440 gfx::Rect in(400, 500, 100, 200); 441 gfx::Rect bounds(0, 0, 10, 10); 442 int64 target_area = 400 * 400; 443 gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy( 444 in, target_area, bounds, NULL); 445 EXPECT_TRUE(out.IsEmpty()); 446 } 447 448 TEST(PictureLayerTilingTest, ExpandRectOutOfBoundsExpandedFullyCover) { 449 gfx::Rect in(40, 50, 100, 100); 450 gfx::Rect bounds(0, 0, 10, 10); 451 int64 target_area = 400 * 400; 452 gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy( 453 in, target_area, bounds, NULL); 454 EXPECT_EQ(bounds.ToString(), out.ToString()); 455 } 456 457 TEST(PictureLayerTilingTest, ExpandRectOutOfBoundsExpandedPartlyCover) { 458 gfx::Rect in(600, 600, 100, 100); 459 gfx::Rect bounds(0, 0, 500, 500); 460 int64 target_area = 400 * 400; 461 gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy( 462 in, target_area, bounds, NULL); 463 EXPECT_EQ(bounds.right(), out.right()); 464 EXPECT_EQ(bounds.bottom(), out.bottom()); 465 EXPECT_LE(out.width() * out.height(), target_area); 466 EXPECT_GT(out.width() * out.height(), 467 target_area - out.width() - out.height()); 468 EXPECT_TRUE(bounds.Contains(out)); 469 } 470 471 TEST(PictureLayerTilingTest, EmptyStartingRect) { 472 // If a layer has a non-invertible transform, then the starting rect 473 // for the layer would be empty. 474 gfx::Rect in(40, 40, 0, 0); 475 gfx::Rect bounds(0, 0, 10, 10); 476 int64 target_area = 400 * 400; 477 gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy( 478 in, target_area, bounds, NULL); 479 EXPECT_TRUE(out.IsEmpty()); 480 } 481 482 static void TileExists(bool exists, Tile* tile, gfx::Rect geometry_rect) { 483 EXPECT_EQ(exists, tile != NULL) << geometry_rect.ToString(); 484 } 485 486 TEST_F(PictureLayerTilingIteratorTest, TilesExist) { 487 gfx::Size layer_bounds(1099, 801); 488 Initialize(gfx::Size(100, 100), 1.f, layer_bounds); 489 VerifyTilesExactlyCoverRect(1.f, gfx::Rect(layer_bounds)); 490 VerifyTiles(1.f, gfx::Rect(layer_bounds), base::Bind(&TileExists, false)); 491 492 tiling_->UpdateTilePriorities( 493 ACTIVE_TREE, 494 layer_bounds, // device viewport 495 gfx::Rect(layer_bounds), // viewport in layer space 496 gfx::Rect(layer_bounds), // visible content rect 497 layer_bounds, // last layer bounds 498 layer_bounds, // current layer bounds 499 1.f, // last contents scale 500 1.f, // current contents scale 501 gfx::Transform(), // last screen transform 502 gfx::Transform(), // current screen transform 503 1.0, // current frame time 504 10000); // max tiles in tile manager 505 VerifyTiles(1.f, gfx::Rect(layer_bounds), base::Bind(&TileExists, true)); 506 507 // Make the viewport rect empty. All tiles are killed and become zombies. 508 tiling_->UpdateTilePriorities( 509 ACTIVE_TREE, 510 layer_bounds, // device viewport 511 gfx::Rect(), // viewport in layer space 512 gfx::Rect(), // visible content rect 513 layer_bounds, // last layer bounds 514 layer_bounds, // current layer bounds 515 1.f, // last contents scale 516 1.f, // current contents scale 517 gfx::Transform(), // last screen transform 518 gfx::Transform(), // current screen transform 519 2.0, // current frame time 520 10000); // max tiles in tile manager 521 VerifyTiles(1.f, gfx::Rect(layer_bounds), base::Bind(&TileExists, false)); 522 } 523 524 TEST_F(PictureLayerTilingIteratorTest, TilesExistGiantViewport) { 525 gfx::Size layer_bounds(1099, 801); 526 Initialize(gfx::Size(100, 100), 1.f, layer_bounds); 527 VerifyTilesExactlyCoverRect(1.f, gfx::Rect(layer_bounds)); 528 VerifyTiles(1.f, gfx::Rect(layer_bounds), base::Bind(&TileExists, false)); 529 530 gfx::Rect giant_rect(-10000000, -10000000, 1000000000, 1000000000); 531 532 tiling_->UpdateTilePriorities( 533 ACTIVE_TREE, 534 layer_bounds, // device viewport 535 giant_rect, // viewport in layer space 536 gfx::Rect(layer_bounds), // visible content rect 537 layer_bounds, // last layer bounds 538 layer_bounds, // current layer bounds 539 1.f, // last contents scale 540 1.f, // current contents scale 541 gfx::Transform(), // last screen transform 542 gfx::Transform(), // current screen transform 543 1.0, // current frame time 544 10000); // max tiles in tile manager 545 VerifyTiles(1.f, gfx::Rect(layer_bounds), base::Bind(&TileExists, true)); 546 547 // If the visible content rect is empty, it should still have live tiles. 548 tiling_->UpdateTilePriorities( 549 ACTIVE_TREE, 550 layer_bounds, // device viewport 551 giant_rect, // viewport in layer space 552 gfx::Rect(), // visible content rect 553 layer_bounds, // last layer bounds 554 layer_bounds, // current layer bounds 555 1.f, // last contents scale 556 1.f, // current contents scale 557 gfx::Transform(), // last screen transform 558 gfx::Transform(), // current screen transform 559 2.0, // current frame time 560 10000); // max tiles in tile manager 561 VerifyTiles(1.f, gfx::Rect(layer_bounds), base::Bind(&TileExists, true)); 562 } 563 564 TEST_F(PictureLayerTilingIteratorTest, TilesExistOutsideViewport) { 565 gfx::Size layer_bounds(1099, 801); 566 Initialize(gfx::Size(100, 100), 1.f, layer_bounds); 567 VerifyTilesExactlyCoverRect(1.f, gfx::Rect(layer_bounds)); 568 VerifyTiles(1.f, gfx::Rect(layer_bounds), base::Bind(&TileExists, false)); 569 570 // This rect does not intersect with the layer, as the layer is outside the 571 // viewport. 572 gfx::Rect viewport_rect(1100, 0, 1000, 1000); 573 EXPECT_FALSE(viewport_rect.Intersects(gfx::Rect(layer_bounds))); 574 575 tiling_->UpdateTilePriorities( 576 ACTIVE_TREE, 577 layer_bounds, // device viewport 578 viewport_rect, // viewport in layer space 579 gfx::Rect(), // visible content rect 580 layer_bounds, // last layer bounds 581 layer_bounds, // current layer bounds 582 1.f, // last contents scale 583 1.f, // current contents scale 584 gfx::Transform(), // last screen transform 585 gfx::Transform(), // current screen transform 586 1.0, // current frame time 587 10000); // max tiles in tile manager 588 VerifyTiles(1.f, gfx::Rect(layer_bounds), base::Bind(&TileExists, true)); 589 } 590 591 static void TilesIntersectingRectExist(gfx::Rect rect, 592 bool intersect_exists, 593 Tile* tile, 594 gfx::Rect geometry_rect) { 595 bool intersects = rect.Intersects(geometry_rect); 596 bool expected_exists = intersect_exists ? intersects : !intersects; 597 EXPECT_EQ(expected_exists, tile != NULL) 598 << "Rects intersecting " << rect.ToString() << " should exist. " 599 << "Current tile rect is " << geometry_rect.ToString(); 600 } 601 602 TEST_F(PictureLayerTilingIteratorTest, 603 TilesExistLargeViewportAndLayerWithSmallVisibleArea) { 604 gfx::Size layer_bounds(10000, 10000); 605 Initialize(gfx::Size(100, 100), 1.f, layer_bounds); 606 VerifyTilesExactlyCoverRect(1.f, gfx::Rect(layer_bounds)); 607 VerifyTiles(1.f, gfx::Rect(layer_bounds), base::Bind(&TileExists, false)); 608 609 gfx::Rect visible_rect(8000, 8000, 50, 50); 610 611 tiling_->UpdateTilePriorities( 612 ACTIVE_TREE, 613 layer_bounds, // device viewport 614 gfx::Rect(layer_bounds), // viewport in layer space 615 visible_rect, // visible content rect 616 layer_bounds, // last layer bounds 617 layer_bounds, // current layer bounds 618 1.f, // last contents scale 619 1.f, // current contents scale 620 gfx::Transform(), // last screen transform 621 gfx::Transform(), // current screen transform 622 1.0, // current frame time 623 1); // max tiles in tile manager 624 VerifyTiles(1.f, 625 gfx::Rect(layer_bounds), 626 base::Bind(&TilesIntersectingRectExist, visible_rect, true)); 627 } 628 629 static void CountExistingTiles(int *count, 630 Tile* tile, 631 gfx::Rect geometry_rect) { 632 if (tile != NULL) 633 ++(*count); 634 } 635 636 TEST_F(PictureLayerTilingIteratorTest, 637 TilesExistLargeViewportAndLayerWithLargeVisibleArea) { 638 gfx::Size layer_bounds(10000, 10000); 639 Initialize(gfx::Size(100, 100), 1.f, layer_bounds); 640 VerifyTilesExactlyCoverRect(1.f, gfx::Rect(layer_bounds)); 641 VerifyTiles(1.f, gfx::Rect(layer_bounds), base::Bind(&TileExists, false)); 642 643 tiling_->UpdateTilePriorities( 644 ACTIVE_TREE, 645 layer_bounds, // device viewport 646 gfx::Rect(layer_bounds), // viewport in layer space 647 gfx::Rect(layer_bounds), // visible content rect 648 layer_bounds, // last layer bounds 649 layer_bounds, // current layer bounds 650 1.f, // last contents scale 651 1.f, // current contents scale 652 gfx::Transform(), // last screen transform 653 gfx::Transform(), // current screen transform 654 1.0, // current frame time 655 1); // max tiles in tile manager 656 657 int num_tiles = 0; 658 VerifyTiles(1.f, 659 gfx::Rect(layer_bounds), 660 base::Bind(&CountExistingTiles, &num_tiles)); 661 // If we're making a rect the size of one tile, it can only overlap up to 4 662 // tiles depending on its position. 663 EXPECT_LE(num_tiles, 4); 664 VerifyTiles(1.f, gfx::Rect(), base::Bind(&TileExists, false)); 665 } 666 667 TEST_F(PictureLayerTilingIteratorTest, AddTilingsToMatchScale) { 668 gfx::Size layer_bounds(1099, 801); 669 gfx::Size tile_size(100, 100); 670 671 client_.SetTileSize(tile_size); 672 673 PictureLayerTilingSet active_set(&client_, layer_bounds); 674 675 active_set.AddTiling(1.f); 676 677 VerifyTiles(active_set.tiling_at(0), 678 1.f, 679 gfx::Rect(layer_bounds), 680 base::Bind(&TileExists, false)); 681 682 active_set.UpdateTilePriorities( 683 PENDING_TREE, 684 layer_bounds, // device viewport 685 gfx::Rect(layer_bounds), // viewport in layer space 686 gfx::Rect(layer_bounds), // visible content rect 687 layer_bounds, // last layer bounds 688 layer_bounds, // current layer bounds 689 1.f, // last contents scale 690 1.f, // current contents scale 691 gfx::Transform(), // last screen transform 692 gfx::Transform(), // current screen transform 693 1.0, // current frame time 694 10000); // max tiles in tile manager 695 696 // The active tiling has tiles now. 697 VerifyTiles(active_set.tiling_at(0), 698 1.f, 699 gfx::Rect(layer_bounds), 700 base::Bind(&TileExists, true)); 701 702 // Add the same tilings to the pending set. 703 PictureLayerTilingSet pending_set(&client_, layer_bounds); 704 Region invalidation; 705 pending_set.SyncTilings(active_set, layer_bounds, invalidation, 0.f); 706 707 // The pending tiling starts with no tiles. 708 VerifyTiles(pending_set.tiling_at(0), 709 1.f, 710 gfx::Rect(layer_bounds), 711 base::Bind(&TileExists, false)); 712 713 // UpdateTilePriorities on the pending tiling at the same frame time. The 714 // pending tiling should get tiles. 715 pending_set.UpdateTilePriorities( 716 PENDING_TREE, 717 layer_bounds, // device viewport 718 gfx::Rect(layer_bounds), // viewport in layer space 719 gfx::Rect(layer_bounds), // visible content rect 720 layer_bounds, // last layer bounds 721 layer_bounds, // current layer bounds 722 1.f, // last contents scale 723 1.f, // current contents scale 724 gfx::Transform(), // last screen transform 725 gfx::Transform(), // current screen transform 726 1.0, // current frame time 727 10000); // max tiles in tile manager 728 729 VerifyTiles(pending_set.tiling_at(0), 730 1.f, 731 gfx::Rect(layer_bounds), 732 base::Bind(&TileExists, true)); 733 } 734 735 TEST(UpdateTilePrioritiesTest, VisibleTiles) { 736 // The TilePriority of visible tiles should have zero distance_to_visible 737 // and time_to_visible. 738 739 FakePictureLayerTilingClient client; 740 scoped_ptr<TestablePictureLayerTiling> tiling; 741 742 gfx::Size device_viewport(800, 600); 743 gfx::Rect visible_layer_rect(0, 0, 200, 200); 744 gfx::Size last_layer_bounds(200, 200); 745 gfx::Size current_layer_bounds(200, 200); 746 float last_layer_contents_scale = 1.f; 747 float current_layer_contents_scale = 1.f; 748 gfx::Transform last_screen_transform; 749 gfx::Transform current_screen_transform; 750 double current_frame_time_in_seconds = 1.0; 751 size_t max_tiles_for_interest_area = 10000; 752 753 gfx::Rect viewport_in_layer_space = ViewportInLayerSpace( 754 current_screen_transform, device_viewport); 755 756 client.SetTileSize(gfx::Size(100, 100)); 757 tiling = TestablePictureLayerTiling::Create(1.0f, // contents_scale 758 current_layer_bounds, 759 &client); 760 761 tiling->UpdateTilePriorities( 762 ACTIVE_TREE, 763 device_viewport, 764 viewport_in_layer_space, 765 visible_layer_rect, 766 last_layer_bounds, 767 current_layer_bounds, 768 last_layer_contents_scale, 769 current_layer_contents_scale, 770 last_screen_transform, 771 current_screen_transform, 772 current_frame_time_in_seconds, 773 max_tiles_for_interest_area); 774 775 ASSERT_TRUE(tiling->TileAt(0, 0)); 776 ASSERT_TRUE(tiling->TileAt(0, 1)); 777 ASSERT_TRUE(tiling->TileAt(1, 0)); 778 ASSERT_TRUE(tiling->TileAt(1, 1)); 779 780 TilePriority priority = tiling->TileAt(0, 0)->priority(ACTIVE_TREE); 781 EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible_in_pixels); 782 EXPECT_FLOAT_EQ(0.f, priority.time_to_visible_in_seconds); 783 784 priority = tiling->TileAt(0, 1)->priority(ACTIVE_TREE); 785 EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible_in_pixels); 786 EXPECT_FLOAT_EQ(0.f, priority.time_to_visible_in_seconds); 787 788 priority = tiling->TileAt(1, 0)->priority(ACTIVE_TREE); 789 EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible_in_pixels); 790 EXPECT_FLOAT_EQ(0.f, priority.time_to_visible_in_seconds); 791 792 priority = tiling->TileAt(1, 1)->priority(ACTIVE_TREE); 793 EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible_in_pixels); 794 EXPECT_FLOAT_EQ(0.f, priority.time_to_visible_in_seconds); 795 } 796 797 TEST(UpdateTilePrioritiesTest, OffscreenTiles) { 798 // The TilePriority of offscreen tiles (without movement) should have nonzero 799 // distance_to_visible and infinite time_to_visible. 800 801 FakePictureLayerTilingClient client; 802 scoped_ptr<TestablePictureLayerTiling> tiling; 803 804 gfx::Size device_viewport(800, 600); 805 gfx::Rect visible_layer_rect(0, 0, 0, 0); // offscreen; nothing is visible. 806 gfx::Size last_layer_bounds(200, 200); 807 gfx::Size current_layer_bounds(200, 200); 808 float last_layer_contents_scale = 1.f; 809 float current_layer_contents_scale = 1.f; 810 gfx::Transform last_screen_transform; 811 gfx::Transform current_screen_transform; 812 double current_frame_time_in_seconds = 1.0; 813 size_t max_tiles_for_interest_area = 10000; 814 815 current_screen_transform.Translate(850, 0); 816 last_screen_transform = current_screen_transform; 817 818 gfx::Rect viewport_in_layer_space = ViewportInLayerSpace( 819 current_screen_transform, device_viewport); 820 821 client.SetTileSize(gfx::Size(100, 100)); 822 tiling = TestablePictureLayerTiling::Create(1.0f, // contents_scale 823 current_layer_bounds, 824 &client); 825 826 tiling->UpdateTilePriorities( 827 ACTIVE_TREE, 828 device_viewport, 829 viewport_in_layer_space, 830 visible_layer_rect, 831 last_layer_bounds, 832 current_layer_bounds, 833 last_layer_contents_scale, 834 current_layer_contents_scale, 835 last_screen_transform, 836 current_screen_transform, 837 current_frame_time_in_seconds, 838 max_tiles_for_interest_area); 839 840 ASSERT_TRUE(tiling->TileAt(0, 0)); 841 ASSERT_TRUE(tiling->TileAt(0, 1)); 842 ASSERT_TRUE(tiling->TileAt(1, 0)); 843 ASSERT_TRUE(tiling->TileAt(1, 1)); 844 845 TilePriority priority = tiling->TileAt(0, 0)->priority(ACTIVE_TREE); 846 EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f); 847 EXPECT_FLOAT_EQ(std::numeric_limits<float>::infinity(), 848 priority.time_to_visible_in_seconds); 849 850 priority = tiling->TileAt(0, 1)->priority(ACTIVE_TREE); 851 EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f); 852 EXPECT_FLOAT_EQ(std::numeric_limits<float>::infinity(), 853 priority.time_to_visible_in_seconds); 854 855 priority = tiling->TileAt(1, 0)->priority(ACTIVE_TREE); 856 EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f); 857 EXPECT_FLOAT_EQ(std::numeric_limits<float>::infinity(), 858 priority.time_to_visible_in_seconds); 859 860 priority = tiling->TileAt(1, 1)->priority(ACTIVE_TREE); 861 EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f); 862 EXPECT_FLOAT_EQ(std::numeric_limits<float>::infinity(), 863 priority.time_to_visible_in_seconds); 864 865 // Furthermore, in this scenario tiles on the right hand side should have a 866 // larger distance to visible. 867 TilePriority left = tiling->TileAt(0, 0)->priority(ACTIVE_TREE); 868 TilePriority right = tiling->TileAt(1, 0)->priority(ACTIVE_TREE); 869 EXPECT_GT(right.distance_to_visible_in_pixels, 870 left.distance_to_visible_in_pixels); 871 872 left = tiling->TileAt(0, 1)->priority(ACTIVE_TREE); 873 right = tiling->TileAt(1, 1)->priority(ACTIVE_TREE); 874 EXPECT_GT(right.distance_to_visible_in_pixels, 875 left.distance_to_visible_in_pixels); 876 } 877 878 TEST(UpdateTilePrioritiesTest, PartiallyOffscreenLayer) { 879 // Sanity check that a layer with some tiles visible and others offscreen has 880 // correct TilePriorities for each tile. 881 882 FakePictureLayerTilingClient client; 883 scoped_ptr<TestablePictureLayerTiling> tiling; 884 885 gfx::Size device_viewport(800, 600); 886 gfx::Rect visible_layer_rect(0, 0, 100, 100); // only top quarter. 887 gfx::Size last_layer_bounds(200, 200); 888 gfx::Size current_layer_bounds(200, 200); 889 float last_layer_contents_scale = 1.f; 890 float current_layer_contents_scale = 1.f; 891 gfx::Transform last_screen_transform; 892 gfx::Transform current_screen_transform; 893 double current_frame_time_in_seconds = 1.0; 894 size_t max_tiles_for_interest_area = 10000; 895 896 current_screen_transform.Translate(705, 505); 897 last_screen_transform = current_screen_transform; 898 899 gfx::Rect viewport_in_layer_space = ViewportInLayerSpace( 900 current_screen_transform, device_viewport); 901 902 client.SetTileSize(gfx::Size(100, 100)); 903 tiling = TestablePictureLayerTiling::Create(1.0f, // contents_scale 904 current_layer_bounds, 905 &client); 906 907 tiling->UpdateTilePriorities( 908 ACTIVE_TREE, 909 device_viewport, 910 viewport_in_layer_space, 911 visible_layer_rect, 912 last_layer_bounds, 913 current_layer_bounds, 914 last_layer_contents_scale, 915 current_layer_contents_scale, 916 last_screen_transform, 917 current_screen_transform, 918 current_frame_time_in_seconds, 919 max_tiles_for_interest_area); 920 921 ASSERT_TRUE(tiling->TileAt(0, 0)); 922 ASSERT_TRUE(tiling->TileAt(0, 1)); 923 ASSERT_TRUE(tiling->TileAt(1, 0)); 924 ASSERT_TRUE(tiling->TileAt(1, 1)); 925 926 TilePriority priority = tiling->TileAt(0, 0)->priority(ACTIVE_TREE); 927 EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible_in_pixels); 928 EXPECT_FLOAT_EQ(0.f, priority.time_to_visible_in_seconds); 929 930 priority = tiling->TileAt(0, 1)->priority(ACTIVE_TREE); 931 EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f); 932 EXPECT_FLOAT_EQ(std::numeric_limits<float>::infinity(), 933 priority.time_to_visible_in_seconds); 934 935 priority = tiling->TileAt(1, 0)->priority(ACTIVE_TREE); 936 EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f); 937 EXPECT_FLOAT_EQ(std::numeric_limits<float>::infinity(), 938 priority.time_to_visible_in_seconds); 939 940 priority = tiling->TileAt(1, 1)->priority(ACTIVE_TREE); 941 EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f); 942 EXPECT_FLOAT_EQ(std::numeric_limits<float>::infinity(), 943 priority.time_to_visible_in_seconds); 944 } 945 946 TEST(UpdateTilePrioritiesTest, PartiallyOffscreenRotatedLayer) { 947 // Each tile of a layer may be affected differently by a transform; Check 948 // that UpdateTilePriorities correctly accounts for the transform between 949 // layer space and screen space. 950 951 FakePictureLayerTilingClient client; 952 scoped_ptr<TestablePictureLayerTiling> tiling; 953 954 gfx::Size device_viewport(800, 600); 955 gfx::Rect visible_layer_rect(0, 0, 100, 100); // only top-left quarter. 956 gfx::Size last_layer_bounds(200, 200); 957 gfx::Size current_layer_bounds(200, 200); 958 float last_layer_contents_scale = 1.f; 959 float current_layer_contents_scale = 1.f; 960 gfx::Transform last_screen_transform; 961 gfx::Transform current_screen_transform; 962 double current_frame_time_in_seconds = 1.0; 963 size_t max_tiles_for_interest_area = 10000; 964 965 // A diagonally rotated layer that is partially off the bottom of the screen. 966 // In this configuration, only the top-left tile would be visible. 967 current_screen_transform.Translate(400, 550); 968 current_screen_transform.RotateAboutZAxis(45); 969 last_screen_transform = current_screen_transform; 970 971 gfx::Rect viewport_in_layer_space = ViewportInLayerSpace( 972 current_screen_transform, device_viewport); 973 974 client.SetTileSize(gfx::Size(100, 100)); 975 tiling = TestablePictureLayerTiling::Create(1.0f, // contents_scale 976 current_layer_bounds, 977 &client); 978 979 tiling->UpdateTilePriorities( 980 ACTIVE_TREE, 981 device_viewport, 982 viewport_in_layer_space, 983 visible_layer_rect, 984 last_layer_bounds, 985 current_layer_bounds, 986 last_layer_contents_scale, 987 current_layer_contents_scale, 988 last_screen_transform, 989 current_screen_transform, 990 current_frame_time_in_seconds, 991 max_tiles_for_interest_area); 992 993 ASSERT_TRUE(tiling->TileAt(0, 0)); 994 ASSERT_TRUE(tiling->TileAt(0, 1)); 995 ASSERT_TRUE(tiling->TileAt(1, 0)); 996 ASSERT_TRUE(tiling->TileAt(1, 1)); 997 998 TilePriority priority = tiling->TileAt(0, 0)->priority(ACTIVE_TREE); 999 EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible_in_pixels); 1000 EXPECT_FLOAT_EQ(0.f, priority.time_to_visible_in_seconds); 1001 1002 priority = tiling->TileAt(0, 1)->priority(ACTIVE_TREE); 1003 EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f); 1004 EXPECT_FLOAT_EQ(std::numeric_limits<float>::infinity(), 1005 priority.time_to_visible_in_seconds); 1006 1007 priority = tiling->TileAt(1, 0)->priority(ACTIVE_TREE); 1008 EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f); 1009 EXPECT_FLOAT_EQ(std::numeric_limits<float>::infinity(), 1010 priority.time_to_visible_in_seconds); 1011 1012 priority = tiling->TileAt(1, 1)->priority(ACTIVE_TREE); 1013 EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f); 1014 EXPECT_FLOAT_EQ(std::numeric_limits<float>::infinity(), 1015 priority.time_to_visible_in_seconds); 1016 1017 // Furthermore, in this scenario the bottom-right tile should have the larger 1018 // distance to visible. 1019 TilePriority top_left = tiling->TileAt(0, 0)->priority(ACTIVE_TREE); 1020 TilePriority top_right = tiling->TileAt(1, 0)->priority(ACTIVE_TREE); 1021 TilePriority bottom_left = tiling->TileAt(0, 1)->priority(ACTIVE_TREE); 1022 TilePriority bottom_right = tiling->TileAt(1, 1)->priority(ACTIVE_TREE); 1023 EXPECT_GT(top_right.distance_to_visible_in_pixels, 1024 top_left.distance_to_visible_in_pixels); 1025 EXPECT_GT(bottom_left.distance_to_visible_in_pixels, 1026 top_left.distance_to_visible_in_pixels); 1027 1028 EXPECT_GT(bottom_right.distance_to_visible_in_pixels, 1029 bottom_left.distance_to_visible_in_pixels); 1030 EXPECT_GT(bottom_right.distance_to_visible_in_pixels, 1031 top_right.distance_to_visible_in_pixels); 1032 } 1033 1034 TEST(UpdateTilePrioritiesTest, PerspectiveLayer) { 1035 // Perspective transforms need to take a different code path. 1036 // This test checks tile priorities of a perspective layer. 1037 1038 FakePictureLayerTilingClient client; 1039 scoped_ptr<TestablePictureLayerTiling> tiling; 1040 1041 gfx::Size device_viewport(800, 600); 1042 gfx::Rect visible_layer_rect(0, 0, 0, 0); // offscreen. 1043 gfx::Size last_layer_bounds(200, 200); 1044 gfx::Size current_layer_bounds(200, 200); 1045 float last_layer_contents_scale = 1.f; 1046 float current_layer_contents_scale = 1.f; 1047 gfx::Transform last_screen_transform; 1048 gfx::Transform current_screen_transform; 1049 double current_frame_time_in_seconds = 1.0; 1050 size_t max_tiles_for_interest_area = 10000; 1051 1052 // A 3d perspective layer rotated about its Y axis, translated to almost 1053 // fully offscreen. The left side will appear closer (i.e. larger in 2d) than 1054 // the right side, so the top-left tile will technically be closer than the 1055 // top-right. 1056 1057 // Translate layer to offscreen 1058 current_screen_transform.Translate(400.0, 630.0); 1059 // Apply perspective about the center of the layer 1060 current_screen_transform.Translate(100.0, 100.0); 1061 current_screen_transform.ApplyPerspectiveDepth(100.0); 1062 current_screen_transform.RotateAboutYAxis(10.0); 1063 current_screen_transform.Translate(-100.0, -100.0); 1064 last_screen_transform = current_screen_transform; 1065 1066 // Sanity check that this transform wouldn't cause w<0 clipping. 1067 bool clipped; 1068 MathUtil::MapQuad(current_screen_transform, 1069 gfx::QuadF(gfx::RectF(0, 0, 200, 200)), 1070 &clipped); 1071 ASSERT_FALSE(clipped); 1072 1073 gfx::Rect viewport_in_layer_space = ViewportInLayerSpace( 1074 current_screen_transform, device_viewport); 1075 1076 client.SetTileSize(gfx::Size(100, 100)); 1077 tiling = TestablePictureLayerTiling::Create(1.0f, // contents_scale 1078 current_layer_bounds, 1079 &client); 1080 1081 tiling->UpdateTilePriorities( 1082 ACTIVE_TREE, 1083 device_viewport, 1084 viewport_in_layer_space, 1085 visible_layer_rect, 1086 last_layer_bounds, 1087 current_layer_bounds, 1088 last_layer_contents_scale, 1089 current_layer_contents_scale, 1090 last_screen_transform, 1091 current_screen_transform, 1092 current_frame_time_in_seconds, 1093 max_tiles_for_interest_area); 1094 1095 ASSERT_TRUE(tiling->TileAt(0, 0)); 1096 ASSERT_TRUE(tiling->TileAt(0, 1)); 1097 ASSERT_TRUE(tiling->TileAt(1, 0)); 1098 ASSERT_TRUE(tiling->TileAt(1, 1)); 1099 1100 // All tiles will have a positive distance_to_visible 1101 // and an infinite time_to_visible. 1102 TilePriority priority = tiling->TileAt(0, 0)->priority(ACTIVE_TREE); 1103 EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f); 1104 EXPECT_FLOAT_EQ(std::numeric_limits<float>::infinity(), 1105 priority.time_to_visible_in_seconds); 1106 1107 priority = tiling->TileAt(0, 1)->priority(ACTIVE_TREE); 1108 EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f); 1109 EXPECT_FLOAT_EQ(std::numeric_limits<float>::infinity(), 1110 priority.time_to_visible_in_seconds); 1111 1112 priority = tiling->TileAt(1, 0)->priority(ACTIVE_TREE); 1113 EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f); 1114 EXPECT_FLOAT_EQ(std::numeric_limits<float>::infinity(), 1115 priority.time_to_visible_in_seconds); 1116 1117 priority = tiling->TileAt(1, 1)->priority(ACTIVE_TREE); 1118 EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f); 1119 EXPECT_FLOAT_EQ(std::numeric_limits<float>::infinity(), 1120 priority.time_to_visible_in_seconds); 1121 1122 // Furthermore, in this scenario the top-left distance_to_visible 1123 // will be smallest, followed by top-right. The bottom layers 1124 // will of course be further than the top layers. 1125 TilePriority top_left = tiling->TileAt(0, 0)->priority(ACTIVE_TREE); 1126 TilePriority top_right = tiling->TileAt(1, 0)->priority(ACTIVE_TREE); 1127 TilePriority bottom_left = tiling->TileAt(0, 1)->priority(ACTIVE_TREE); 1128 TilePriority bottom_right = tiling->TileAt(1, 1)->priority(ACTIVE_TREE); 1129 EXPECT_GT(top_right.distance_to_visible_in_pixels, 1130 top_left.distance_to_visible_in_pixels); 1131 1132 EXPECT_GT(bottom_right.distance_to_visible_in_pixels, 1133 top_right.distance_to_visible_in_pixels); 1134 1135 EXPECT_GT(bottom_left.distance_to_visible_in_pixels, 1136 top_left.distance_to_visible_in_pixels); 1137 } 1138 1139 TEST(UpdateTilePrioritiesTest, PerspectiveLayerClippedByW) { 1140 // Perspective transforms need to take a different code path. 1141 // This test checks tile priorities of a perspective layer. 1142 1143 FakePictureLayerTilingClient client; 1144 scoped_ptr<TestablePictureLayerTiling> tiling; 1145 1146 gfx::Size device_viewport(800, 600); 1147 gfx::Rect visible_layer_rect(0, 0, 0, 0); // offscreen. 1148 gfx::Size last_layer_bounds(200, 200); 1149 gfx::Size current_layer_bounds(200, 200); 1150 float last_layer_contents_scale = 1.f; 1151 float current_layer_contents_scale = 1.f; 1152 gfx::Transform last_screen_transform; 1153 gfx::Transform current_screen_transform; 1154 double current_frame_time_in_seconds = 1.0; 1155 size_t max_tiles_for_interest_area = 10000; 1156 1157 // A 3d perspective layer rotated about its Y axis, translated to almost 1158 // fully offscreen. The left side will appear closer (i.e. larger in 2d) than 1159 // the right side, so the top-left tile will technically be closer than the 1160 // top-right. 1161 1162 // Translate layer to offscreen 1163 current_screen_transform.Translate(400.0, 970.0); 1164 // Apply perspective and rotation about the center of the layer 1165 current_screen_transform.Translate(100.0, 100.0); 1166 current_screen_transform.ApplyPerspectiveDepth(10.0); 1167 current_screen_transform.RotateAboutYAxis(10.0); 1168 current_screen_transform.Translate(-100.0, -100.0); 1169 last_screen_transform = current_screen_transform; 1170 1171 // Sanity check that this transform does cause w<0 clipping for the left side 1172 // of the layer, but not the right side. 1173 bool clipped; 1174 MathUtil::MapQuad(current_screen_transform, 1175 gfx::QuadF(gfx::RectF(0, 0, 100, 200)), 1176 &clipped); 1177 ASSERT_TRUE(clipped); 1178 1179 MathUtil::MapQuad(current_screen_transform, 1180 gfx::QuadF(gfx::RectF(100, 0, 100, 200)), 1181 &clipped); 1182 ASSERT_FALSE(clipped); 1183 1184 gfx::Rect viewport_in_layer_space = ViewportInLayerSpace( 1185 current_screen_transform, device_viewport); 1186 1187 client.SetTileSize(gfx::Size(100, 100)); 1188 tiling = TestablePictureLayerTiling::Create(1.0f, // contents_scale 1189 current_layer_bounds, 1190 &client); 1191 1192 tiling->UpdateTilePriorities( 1193 ACTIVE_TREE, 1194 device_viewport, 1195 viewport_in_layer_space, 1196 visible_layer_rect, 1197 last_layer_bounds, 1198 current_layer_bounds, 1199 last_layer_contents_scale, 1200 current_layer_contents_scale, 1201 last_screen_transform, 1202 current_screen_transform, 1203 current_frame_time_in_seconds, 1204 max_tiles_for_interest_area); 1205 1206 ASSERT_TRUE(tiling->TileAt(0, 0)); 1207 ASSERT_TRUE(tiling->TileAt(0, 1)); 1208 ASSERT_TRUE(tiling->TileAt(1, 0)); 1209 ASSERT_TRUE(tiling->TileAt(1, 1)); 1210 1211 // Left-side tiles will be clipped by the transform, so we have to assume 1212 // they are visible just in case. 1213 TilePriority priority = tiling->TileAt(0, 0)->priority(ACTIVE_TREE); 1214 EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible_in_pixels); 1215 EXPECT_FLOAT_EQ(0.f, priority.time_to_visible_in_seconds); 1216 1217 priority = tiling->TileAt(0, 1)->priority(ACTIVE_TREE); 1218 EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible_in_pixels); 1219 EXPECT_FLOAT_EQ(0.f, priority.time_to_visible_in_seconds); 1220 1221 // Right-side tiles will have a positive distance_to_visible 1222 // and an infinite time_to_visible. 1223 priority = tiling->TileAt(1, 0)->priority(ACTIVE_TREE); 1224 EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f); 1225 EXPECT_FLOAT_EQ(std::numeric_limits<float>::infinity(), 1226 priority.time_to_visible_in_seconds); 1227 1228 priority = tiling->TileAt(1, 1)->priority(ACTIVE_TREE); 1229 EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f); 1230 EXPECT_FLOAT_EQ(std::numeric_limits<float>::infinity(), 1231 priority.time_to_visible_in_seconds); 1232 } 1233 1234 TEST(UpdateTilePrioritiesTest, BasicMotion) { 1235 // Test that time_to_visible is computed correctly when 1236 // there is some motion. 1237 1238 FakePictureLayerTilingClient client; 1239 scoped_ptr<TestablePictureLayerTiling> tiling; 1240 1241 gfx::Size device_viewport(800, 600); 1242 gfx::Rect visible_layer_rect(0, 0, 0, 0); 1243 gfx::Size last_layer_bounds(200, 200); 1244 gfx::Size current_layer_bounds(200, 200); 1245 float last_layer_contents_scale = 1.f; 1246 float current_layer_contents_scale = 1.f; 1247 gfx::Transform last_screen_transform; 1248 gfx::Transform current_screen_transform; 1249 double last_frame_time_in_seconds = 1.0; 1250 double current_frame_time_in_seconds = 2.0; 1251 size_t max_tiles_for_interest_area = 10000; 1252 1253 // Offscreen layer is coming closer to viewport at 1000 pixels per second. 1254 current_screen_transform.Translate(1800, 0); 1255 last_screen_transform.Translate(2800, 0); 1256 1257 gfx::Rect viewport_in_layer_space = ViewportInLayerSpace( 1258 current_screen_transform, device_viewport); 1259 1260 client.SetTileSize(gfx::Size(100, 100)); 1261 tiling = TestablePictureLayerTiling::Create(1.0f, // contents_scale 1262 current_layer_bounds, 1263 &client); 1264 1265 // previous ("last") frame 1266 tiling->UpdateTilePriorities( 1267 ACTIVE_TREE, 1268 device_viewport, 1269 viewport_in_layer_space, 1270 visible_layer_rect, 1271 last_layer_bounds, 1272 last_layer_bounds, 1273 last_layer_contents_scale, 1274 last_layer_contents_scale, 1275 last_screen_transform, 1276 last_screen_transform, 1277 last_frame_time_in_seconds, 1278 max_tiles_for_interest_area); 1279 1280 // current frame 1281 tiling->UpdateTilePriorities( 1282 ACTIVE_TREE, 1283 device_viewport, 1284 viewport_in_layer_space, 1285 visible_layer_rect, 1286 last_layer_bounds, 1287 current_layer_bounds, 1288 last_layer_contents_scale, 1289 current_layer_contents_scale, 1290 last_screen_transform, 1291 current_screen_transform, 1292 current_frame_time_in_seconds, 1293 max_tiles_for_interest_area); 1294 1295 ASSERT_TRUE(tiling->TileAt(0, 0)); 1296 ASSERT_TRUE(tiling->TileAt(0, 1)); 1297 ASSERT_TRUE(tiling->TileAt(1, 0)); 1298 ASSERT_TRUE(tiling->TileAt(1, 1)); 1299 1300 TilePriority priority = tiling->TileAt(0, 0)->priority(ACTIVE_TREE); 1301 EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f); 1302 EXPECT_FLOAT_EQ(1.f, 1303 priority.time_to_visible_in_seconds); 1304 1305 priority = tiling->TileAt(0, 1)->priority(ACTIVE_TREE); 1306 EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f); 1307 EXPECT_FLOAT_EQ(1.f, 1308 priority.time_to_visible_in_seconds); 1309 1310 // time_to_visible for the right hand side layers needs an extra 0.099 1311 // seconds because this tile is 99 pixels further away. 1312 priority = tiling->TileAt(1, 0)->priority(ACTIVE_TREE); 1313 EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f); 1314 EXPECT_FLOAT_EQ(1.099f, 1315 priority.time_to_visible_in_seconds); 1316 1317 priority = tiling->TileAt(1, 1)->priority(ACTIVE_TREE); 1318 EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f); 1319 EXPECT_FLOAT_EQ(1.099f, 1320 priority.time_to_visible_in_seconds); 1321 } 1322 1323 TEST(UpdateTilePrioritiesTest, RotationMotion) { 1324 // Each tile of a layer may be affected differently by a transform; Check 1325 // that UpdateTilePriorities correctly accounts for the transform between 1326 // layer space and screen space. 1327 1328 FakePictureLayerTilingClient client; 1329 scoped_ptr<TestablePictureLayerTiling> tiling; 1330 1331 gfx::Size device_viewport(800, 600); 1332 gfx::Rect visible_layer_rect(0, 0, 0, 0); // offscren. 1333 gfx::Size last_layer_bounds(200, 200); 1334 gfx::Size current_layer_bounds(200, 200); 1335 float last_layer_contents_scale = 1.f; 1336 float current_layer_contents_scale = 1.f; 1337 gfx::Transform last_screen_transform; 1338 gfx::Transform current_screen_transform; 1339 double last_frame_time_in_seconds = 1.0; 1340 double current_frame_time_in_seconds = 2.0; 1341 size_t max_tiles_for_interest_area = 10000; 1342 1343 // Rotation motion is set up specifically so that: 1344 // - rotation occurs about the center of the layer 1345 // - the top-left tile becomes visible on rotation 1346 // - the top-right tile will have an infinite time_to_visible 1347 // because it is rotating away from viewport. 1348 // - bottom-left layer will have a positive non-zero time_to_visible 1349 // because it is rotating toward the viewport. 1350 current_screen_transform.Translate(400, 550); 1351 current_screen_transform.RotateAboutZAxis(45); 1352 1353 last_screen_transform.Translate(400, 550); 1354 1355 gfx::Rect viewport_in_layer_space = ViewportInLayerSpace( 1356 current_screen_transform, device_viewport); 1357 1358 client.SetTileSize(gfx::Size(100, 100)); 1359 tiling = TestablePictureLayerTiling::Create(1.0f, // contents_scale 1360 current_layer_bounds, 1361 &client); 1362 1363 // previous ("last") frame 1364 tiling->UpdateTilePriorities( 1365 ACTIVE_TREE, 1366 device_viewport, 1367 viewport_in_layer_space, 1368 visible_layer_rect, 1369 last_layer_bounds, 1370 last_layer_bounds, 1371 last_layer_contents_scale, 1372 last_layer_contents_scale, 1373 last_screen_transform, 1374 last_screen_transform, 1375 last_frame_time_in_seconds, 1376 max_tiles_for_interest_area); 1377 1378 // current frame 1379 tiling->UpdateTilePriorities( 1380 ACTIVE_TREE, 1381 device_viewport, 1382 viewport_in_layer_space, 1383 visible_layer_rect, 1384 last_layer_bounds, 1385 current_layer_bounds, 1386 last_layer_contents_scale, 1387 current_layer_contents_scale, 1388 last_screen_transform, 1389 current_screen_transform, 1390 current_frame_time_in_seconds, 1391 max_tiles_for_interest_area); 1392 1393 ASSERT_TRUE(tiling->TileAt(0, 0)); 1394 ASSERT_TRUE(tiling->TileAt(0, 1)); 1395 ASSERT_TRUE(tiling->TileAt(1, 0)); 1396 ASSERT_TRUE(tiling->TileAt(1, 1)); 1397 1398 TilePriority priority = tiling->TileAt(0, 0)->priority(ACTIVE_TREE); 1399 EXPECT_FLOAT_EQ(0.f, priority.distance_to_visible_in_pixels); 1400 EXPECT_FLOAT_EQ(0.f, priority.time_to_visible_in_seconds); 1401 1402 priority = tiling->TileAt(0, 1)->priority(ACTIVE_TREE); 1403 EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f); 1404 EXPECT_GT(priority.time_to_visible_in_seconds, 0.f); 1405 1406 priority = tiling->TileAt(1, 0)->priority(ACTIVE_TREE); 1407 EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f); 1408 EXPECT_FLOAT_EQ(std::numeric_limits<float>::infinity(), 1409 priority.time_to_visible_in_seconds); 1410 } 1411 1412 } // namespace 1413 } // namespace cc 1414
