| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2013 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 "base/memory/scoped_ptr.h" | |
| 6 #include "cc/test/fake_picture_pile_impl.h" | |
| 7 #include "cc/test/skia_common.h" | |
| 8 #include "skia/ext/refptr.h" | |
| 9 #include "testing/gtest/include/gtest/gtest.h" | |
| 10 #include "third_party/skia/include/core/SkPixelRef.h" | |
| 11 #include "third_party/skia/include/core/SkShader.h" | |
| 12 #include "ui/gfx/geometry/rect.h" | |
| 13 #include "ui/gfx/geometry/size_conversions.h" | |
| 14 | |
| 15 namespace cc { | |
| 16 namespace { | |
| 17 | |
| 18 TEST(PicturePileImplTest, AnalyzeIsSolidUnscaled) { | |
| 19 gfx::Size tile_size(100, 100); | |
| 20 gfx::Size layer_bounds(400, 400); | |
| 21 | |
| 22 scoped_ptr<FakePicturePile> recording_source = | |
| 23 FakePicturePile::CreateFilledPile(tile_size, layer_bounds); | |
| 24 | |
| 25 SkPaint solid_paint; | |
| 26 SkColor solid_color = SkColorSetARGB(255, 12, 23, 34); | |
| 27 solid_paint.setColor(solid_color); | |
| 28 | |
| 29 SkColor non_solid_color = SkColorSetARGB(128, 45, 56, 67); | |
| 30 SkPaint non_solid_paint; | |
| 31 non_solid_paint.setColor(non_solid_color); | |
| 32 | |
| 33 recording_source->add_draw_rect_with_paint(gfx::Rect(400, 400), solid_paint); | |
| 34 recording_source->Rerecord(); | |
| 35 | |
| 36 scoped_refptr<FakePicturePileImpl> pile = | |
| 37 FakePicturePileImpl::CreateFromPile(recording_source.get(), nullptr); | |
| 38 | |
| 39 // Ensure everything is solid. | |
| 40 for (int y = 0; y <= 300; y += 100) { | |
| 41 for (int x = 0; x <= 300; x += 100) { | |
| 42 RasterSource::SolidColorAnalysis analysis; | |
| 43 gfx::Rect rect(x, y, 100, 100); | |
| 44 pile->PerformSolidColorAnalysis(rect, 1.0, &analysis); | |
| 45 EXPECT_TRUE(analysis.is_solid_color) << rect.ToString(); | |
| 46 EXPECT_EQ(analysis.solid_color, solid_color) << rect.ToString(); | |
| 47 } | |
| 48 } | |
| 49 | |
| 50 // Add one non-solid pixel and recreate the raster source. | |
| 51 recording_source->add_draw_rect_with_paint(gfx::Rect(50, 50, 1, 1), | |
| 52 non_solid_paint); | |
| 53 recording_source->Rerecord(); | |
| 54 pile = FakePicturePileImpl::CreateFromPile(recording_source.get(), nullptr); | |
| 55 | |
| 56 RasterSource::SolidColorAnalysis analysis; | |
| 57 pile->PerformSolidColorAnalysis(gfx::Rect(0, 0, 100, 100), 1.0, &analysis); | |
| 58 EXPECT_FALSE(analysis.is_solid_color); | |
| 59 | |
| 60 pile->PerformSolidColorAnalysis(gfx::Rect(100, 0, 100, 100), 1.0, &analysis); | |
| 61 EXPECT_TRUE(analysis.is_solid_color); | |
| 62 EXPECT_EQ(analysis.solid_color, solid_color); | |
| 63 | |
| 64 // Boundaries should be clipped. | |
| 65 analysis.is_solid_color = false; | |
| 66 pile->PerformSolidColorAnalysis(gfx::Rect(350, 0, 100, 100), 1.0, &analysis); | |
| 67 EXPECT_TRUE(analysis.is_solid_color); | |
| 68 EXPECT_EQ(analysis.solid_color, solid_color); | |
| 69 | |
| 70 analysis.is_solid_color = false; | |
| 71 pile->PerformSolidColorAnalysis(gfx::Rect(0, 350, 100, 100), 1.0, &analysis); | |
| 72 EXPECT_TRUE(analysis.is_solid_color); | |
| 73 EXPECT_EQ(analysis.solid_color, solid_color); | |
| 74 | |
| 75 analysis.is_solid_color = false; | |
| 76 pile->PerformSolidColorAnalysis(gfx::Rect(350, 350, 100, 100), 1.0, | |
| 77 &analysis); | |
| 78 EXPECT_TRUE(analysis.is_solid_color); | |
| 79 EXPECT_EQ(analysis.solid_color, solid_color); | |
| 80 } | |
| 81 | |
| 82 TEST(PicturePileImplTest, AnalyzeIsSolidScaled) { | |
| 83 gfx::Size tile_size(100, 100); | |
| 84 gfx::Size layer_bounds(400, 400); | |
| 85 | |
| 86 scoped_ptr<FakePicturePile> recording_source = | |
| 87 FakePicturePile::CreateFilledPile(tile_size, layer_bounds); | |
| 88 | |
| 89 SkColor solid_color = SkColorSetARGB(255, 12, 23, 34); | |
| 90 SkPaint solid_paint; | |
| 91 solid_paint.setColor(solid_color); | |
| 92 | |
| 93 SkColor non_solid_color = SkColorSetARGB(128, 45, 56, 67); | |
| 94 SkPaint non_solid_paint; | |
| 95 non_solid_paint.setColor(non_solid_color); | |
| 96 | |
| 97 recording_source->add_draw_rect_with_paint(gfx::Rect(400, 400), solid_paint); | |
| 98 recording_source->Rerecord(); | |
| 99 | |
| 100 scoped_refptr<FakePicturePileImpl> pile = | |
| 101 FakePicturePileImpl::CreateFromPile(recording_source.get(), nullptr); | |
| 102 | |
| 103 // Ensure everything is solid. | |
| 104 for (int y = 0; y <= 30; y += 10) { | |
| 105 for (int x = 0; x <= 30; x += 10) { | |
| 106 RasterSource::SolidColorAnalysis analysis; | |
| 107 gfx::Rect rect(x, y, 10, 10); | |
| 108 pile->PerformSolidColorAnalysis(rect, 0.1f, &analysis); | |
| 109 EXPECT_TRUE(analysis.is_solid_color) << rect.ToString(); | |
| 110 EXPECT_EQ(analysis.solid_color, solid_color) << rect.ToString(); | |
| 111 } | |
| 112 } | |
| 113 | |
| 114 // Add one non-solid pixel and recreate the raster source. | |
| 115 recording_source->add_draw_rect_with_paint(gfx::Rect(50, 50, 1, 1), | |
| 116 non_solid_paint); | |
| 117 recording_source->Rerecord(); | |
| 118 pile = FakePicturePileImpl::CreateFromPile(recording_source.get(), nullptr); | |
| 119 | |
| 120 RasterSource::SolidColorAnalysis analysis; | |
| 121 pile->PerformSolidColorAnalysis(gfx::Rect(0, 0, 10, 10), 0.1f, &analysis); | |
| 122 EXPECT_FALSE(analysis.is_solid_color); | |
| 123 | |
| 124 pile->PerformSolidColorAnalysis(gfx::Rect(10, 0, 10, 10), 0.1f, &analysis); | |
| 125 EXPECT_TRUE(analysis.is_solid_color); | |
| 126 EXPECT_EQ(analysis.solid_color, solid_color); | |
| 127 | |
| 128 // Boundaries should be clipped. | |
| 129 analysis.is_solid_color = false; | |
| 130 pile->PerformSolidColorAnalysis(gfx::Rect(35, 0, 10, 10), 0.1f, &analysis); | |
| 131 EXPECT_TRUE(analysis.is_solid_color); | |
| 132 EXPECT_EQ(analysis.solid_color, solid_color); | |
| 133 | |
| 134 analysis.is_solid_color = false; | |
| 135 pile->PerformSolidColorAnalysis(gfx::Rect(0, 35, 10, 10), 0.1f, &analysis); | |
| 136 EXPECT_TRUE(analysis.is_solid_color); | |
| 137 EXPECT_EQ(analysis.solid_color, solid_color); | |
| 138 | |
| 139 analysis.is_solid_color = false; | |
| 140 pile->PerformSolidColorAnalysis(gfx::Rect(35, 35, 10, 10), 0.1f, &analysis); | |
| 141 EXPECT_TRUE(analysis.is_solid_color); | |
| 142 EXPECT_EQ(analysis.solid_color, solid_color); | |
| 143 } | |
| 144 | |
| 145 TEST(PicturePileImplTest, AnalyzeIsSolidEmpty) { | |
| 146 gfx::Size tile_size(100, 100); | |
| 147 gfx::Size layer_bounds(400, 400); | |
| 148 | |
| 149 scoped_refptr<FakePicturePileImpl> pile = | |
| 150 FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds); | |
| 151 RasterSource::SolidColorAnalysis analysis; | |
| 152 EXPECT_FALSE(analysis.is_solid_color); | |
| 153 | |
| 154 pile->PerformSolidColorAnalysis(gfx::Rect(0, 0, 400, 400), 1.f, &analysis); | |
| 155 | |
| 156 EXPECT_TRUE(analysis.is_solid_color); | |
| 157 EXPECT_EQ(analysis.solid_color, SkColorSetARGB(0, 0, 0, 0)); | |
| 158 } | |
| 159 | |
| 160 TEST(PicturePileImplTest, ImageIteratorDiscardableImagesOneTile) { | |
| 161 gfx::Size tile_size(256, 256); | |
| 162 gfx::Size layer_bounds(512, 512); | |
| 163 | |
| 164 scoped_ptr<FakePicturePile> recording_source = | |
| 165 FakePicturePile::CreateFilledPile(tile_size, layer_bounds); | |
| 166 | |
| 167 skia::RefPtr<SkImage> discardable_image[2][2]; | |
| 168 discardable_image[0][0] = CreateDiscardableImage(gfx::Size(32, 32)); | |
| 169 discardable_image[0][1] = CreateDiscardableImage(gfx::Size(32, 32)); | |
| 170 discardable_image[1][1] = CreateDiscardableImage(gfx::Size(32, 32)); | |
| 171 | |
| 172 // Discardable pixel refs are found in the following cells: | |
| 173 // |---|---| | |
| 174 // | x | x | | |
| 175 // |---|---| | |
| 176 // | | x | | |
| 177 // |---|---| | |
| 178 recording_source->add_draw_image(discardable_image[0][0].get(), | |
| 179 gfx::Point(0, 0)); | |
| 180 recording_source->add_draw_image(discardable_image[0][1].get(), | |
| 181 gfx::Point(260, 0)); | |
| 182 recording_source->add_draw_image(discardable_image[1][1].get(), | |
| 183 gfx::Point(260, 260)); | |
| 184 recording_source->SetGatherDiscardableImages(true); | |
| 185 recording_source->Rerecord(); | |
| 186 | |
| 187 scoped_refptr<FakePicturePileImpl> pile = | |
| 188 FakePicturePileImpl::CreateFromPile(recording_source.get(), nullptr); | |
| 189 | |
| 190 // Tile sized iterators. These should find only one pixel ref. | |
| 191 { | |
| 192 PicturePileImpl::ImageIterator iterator(gfx::Rect(0, 0, 256, 256), | |
| 193 pile.get()); | |
| 194 EXPECT_TRUE(iterator); | |
| 195 EXPECT_TRUE(iterator->image == discardable_image[0][0].get()); | |
| 196 EXPECT_EQ(gfx::SkRectToRectF(iterator->image_rect).ToString(), | |
| 197 gfx::RectF(32, 32).ToString()); | |
| 198 EXPECT_FALSE(++iterator); | |
| 199 } | |
| 200 // Shifted tile sized iterators. These should find only one pixel ref. | |
| 201 { | |
| 202 PicturePileImpl::ImageIterator iterator(gfx::Rect(260, 260, 256, 256), | |
| 203 pile.get()); | |
| 204 EXPECT_TRUE(iterator); | |
| 205 EXPECT_TRUE(iterator->image == discardable_image[1][1].get()); | |
| 206 EXPECT_EQ(gfx::SkRectToRectF(iterator->image_rect).ToString(), | |
| 207 gfx::RectF(260, 260, 32, 32).ToString()); | |
| 208 EXPECT_FALSE(++iterator); | |
| 209 } | |
| 210 // Ensure there's no discardable pixel refs in the empty cell | |
| 211 { | |
| 212 PicturePileImpl::ImageIterator iterator(gfx::Rect(0, 256, 256, 256), | |
| 213 pile.get()); | |
| 214 EXPECT_FALSE(iterator); | |
| 215 } | |
| 216 // Layer sized iterators. These should find three pixel ref. | |
| 217 { | |
| 218 PicturePileImpl::ImageIterator iterator(gfx::Rect(0, 0, 512, 512), | |
| 219 pile.get()); | |
| 220 EXPECT_TRUE(iterator); | |
| 221 EXPECT_TRUE(iterator->image == discardable_image[0][0].get()); | |
| 222 EXPECT_EQ(gfx::SkRectToRectF(iterator->image_rect).ToString(), | |
| 223 gfx::RectF(32, 32).ToString()); | |
| 224 EXPECT_TRUE(++iterator); | |
| 225 EXPECT_TRUE(iterator->image == discardable_image[0][1].get()); | |
| 226 EXPECT_EQ(gfx::SkRectToRectF(iterator->image_rect).ToString(), | |
| 227 gfx::RectF(260, 0, 32, 32).ToString()); | |
| 228 EXPECT_TRUE(++iterator); | |
| 229 EXPECT_TRUE(iterator->image == discardable_image[1][1].get()); | |
| 230 EXPECT_EQ(gfx::SkRectToRectF(iterator->image_rect).ToString(), | |
| 231 gfx::RectF(260, 260, 32, 32).ToString()); | |
| 232 EXPECT_FALSE(++iterator); | |
| 233 } | |
| 234 | |
| 235 { | |
| 236 // Copy test. | |
| 237 PicturePileImpl::ImageIterator iterator(gfx::Rect(0, 0, 512, 512), | |
| 238 pile.get()); | |
| 239 EXPECT_TRUE(iterator); | |
| 240 EXPECT_TRUE(iterator->image == discardable_image[0][0].get()); | |
| 241 EXPECT_EQ(gfx::RectF(32, 32).ToString(), | |
| 242 gfx::SkRectToRectF(iterator->image_rect).ToString()); | |
| 243 EXPECT_TRUE(++iterator); | |
| 244 EXPECT_TRUE(iterator->image == discardable_image[0][1].get()); | |
| 245 EXPECT_EQ(gfx::RectF(260, 0, 32, 32).ToString(), | |
| 246 gfx::SkRectToRectF(iterator->image_rect).ToString()); | |
| 247 | |
| 248 // copy now points to the same spot as iterator, | |
| 249 // but both can be incremented independently. | |
| 250 PicturePileImpl::ImageIterator copy = iterator; | |
| 251 EXPECT_TRUE(++iterator); | |
| 252 EXPECT_TRUE(iterator->image == discardable_image[1][1].get()); | |
| 253 EXPECT_EQ(gfx::RectF(260, 260, 32, 32).ToString(), | |
| 254 gfx::SkRectToRectF(iterator->image_rect).ToString()); | |
| 255 EXPECT_FALSE(++iterator); | |
| 256 | |
| 257 EXPECT_TRUE(copy); | |
| 258 EXPECT_TRUE(copy->image == discardable_image[0][1].get()); | |
| 259 EXPECT_EQ(gfx::RectF(260, 0, 32, 32).ToString(), | |
| 260 gfx::SkRectToRectF(copy->image_rect).ToString()); | |
| 261 EXPECT_TRUE(++copy); | |
| 262 EXPECT_TRUE(copy->image == discardable_image[1][1].get()); | |
| 263 EXPECT_EQ(gfx::RectF(260, 260, 32, 32).ToString(), | |
| 264 gfx::SkRectToRectF(copy->image_rect).ToString()); | |
| 265 EXPECT_FALSE(++copy); | |
| 266 } | |
| 267 } | |
| 268 | |
| 269 TEST(PicturePileImplTest, RasterFullContents) { | |
| 270 gfx::Size tile_size(1000, 1000); | |
| 271 gfx::Size layer_bounds(3, 5); | |
| 272 float contents_scale = 1.5f; | |
| 273 float raster_divisions = 2.f; | |
| 274 | |
| 275 scoped_ptr<FakePicturePile> recording_source = | |
| 276 FakePicturePile::CreateFilledPile(tile_size, layer_bounds); | |
| 277 recording_source->SetBackgroundColor(SK_ColorBLACK); | |
| 278 recording_source->SetIsSolidColor(false); | |
| 279 recording_source->SetRequiresClear(false); | |
| 280 recording_source->SetClearCanvasWithDebugColor(false); | |
| 281 | |
| 282 // Because the caller sets content opaque, it also promises that it | |
| 283 // has at least filled in layer_bounds opaquely. | |
| 284 SkPaint white_paint; | |
| 285 white_paint.setColor(SK_ColorWHITE); | |
| 286 recording_source->add_draw_rect_with_paint(gfx::Rect(layer_bounds), | |
| 287 white_paint); | |
| 288 | |
| 289 recording_source->SetMinContentsScale(contents_scale); | |
| 290 recording_source->Rerecord(); | |
| 291 | |
| 292 scoped_refptr<FakePicturePileImpl> pile = | |
| 293 FakePicturePileImpl::CreateFromPile(recording_source.get(), nullptr); | |
| 294 | |
| 295 gfx::Size content_bounds( | |
| 296 gfx::ToCeiledSize(gfx::ScaleSize(layer_bounds, contents_scale))); | |
| 297 | |
| 298 // Simulate drawing into different tiles at different offsets. | |
| 299 int step_x = std::ceil(content_bounds.width() / raster_divisions); | |
| 300 int step_y = std::ceil(content_bounds.height() / raster_divisions); | |
| 301 for (int offset_x = 0; offset_x < content_bounds.width(); | |
| 302 offset_x += step_x) { | |
| 303 for (int offset_y = 0; offset_y < content_bounds.height(); | |
| 304 offset_y += step_y) { | |
| 305 gfx::Rect content_rect(offset_x, offset_y, step_x, step_y); | |
| 306 content_rect.Intersect(gfx::Rect(content_bounds)); | |
| 307 | |
| 308 // Simulate a canvas rect larger than the content rect. Every pixel | |
| 309 // up to one pixel outside the content rect is guaranteed to be opaque. | |
| 310 // Outside of that is undefined. | |
| 311 gfx::Rect canvas_rect(content_rect); | |
| 312 canvas_rect.Inset(0, 0, -1, -1); | |
| 313 | |
| 314 SkBitmap bitmap; | |
| 315 bitmap.allocN32Pixels(canvas_rect.width(), canvas_rect.height()); | |
| 316 SkCanvas canvas(bitmap); | |
| 317 canvas.clear(SK_ColorTRANSPARENT); | |
| 318 | |
| 319 pile->PlaybackToCanvas(&canvas, canvas_rect, canvas_rect, contents_scale); | |
| 320 | |
| 321 SkColor* pixels = reinterpret_cast<SkColor*>(bitmap.getPixels()); | |
| 322 int num_pixels = bitmap.width() * bitmap.height(); | |
| 323 bool all_white = true; | |
| 324 for (int i = 0; i < num_pixels; ++i) { | |
| 325 EXPECT_EQ(SkColorGetA(pixels[i]), 255u); | |
| 326 all_white &= (SkColorGetR(pixels[i]) == 255); | |
| 327 all_white &= (SkColorGetG(pixels[i]) == 255); | |
| 328 all_white &= (SkColorGetB(pixels[i]) == 255); | |
| 329 } | |
| 330 | |
| 331 // If the canvas doesn't extend past the edge of the content, | |
| 332 // it should be entirely white. Otherwise, the edge of the content | |
| 333 // will be non-white. | |
| 334 EXPECT_EQ(all_white, gfx::Rect(content_bounds).Contains(canvas_rect)); | |
| 335 } | |
| 336 } | |
| 337 } | |
| 338 | |
| 339 TEST(PicturePileImpl, RasterContentsTransparent) { | |
| 340 gfx::Size tile_size(1000, 1000); | |
| 341 gfx::Size layer_bounds(5, 3); | |
| 342 float contents_scale = 0.5f; | |
| 343 | |
| 344 scoped_ptr<FakePicturePile> recording_source = | |
| 345 FakePicturePile::CreateFilledPile(tile_size, layer_bounds); | |
| 346 recording_source->SetBackgroundColor(SK_ColorTRANSPARENT); | |
| 347 recording_source->SetRequiresClear(true); | |
| 348 recording_source->SetMinContentsScale(contents_scale); | |
| 349 recording_source->SetClearCanvasWithDebugColor(false); | |
| 350 recording_source->Rerecord(); | |
| 351 | |
| 352 scoped_refptr<FakePicturePileImpl> pile = | |
| 353 FakePicturePileImpl::CreateFromPile(recording_source.get(), nullptr); | |
| 354 gfx::Size content_bounds( | |
| 355 gfx::ToCeiledSize(gfx::ScaleSize(layer_bounds, contents_scale))); | |
| 356 | |
| 357 gfx::Rect canvas_rect(content_bounds); | |
| 358 canvas_rect.Inset(0, 0, -1, -1); | |
| 359 | |
| 360 SkBitmap bitmap; | |
| 361 bitmap.allocN32Pixels(canvas_rect.width(), canvas_rect.height()); | |
| 362 SkCanvas canvas(bitmap); | |
| 363 | |
| 364 pile->PlaybackToCanvas(&canvas, canvas_rect, canvas_rect, contents_scale); | |
| 365 | |
| 366 SkColor* pixels = reinterpret_cast<SkColor*>(bitmap.getPixels()); | |
| 367 int num_pixels = bitmap.width() * bitmap.height(); | |
| 368 for (int i = 0; i < num_pixels; ++i) { | |
| 369 EXPECT_EQ(SkColorGetA(pixels[i]), 0u); | |
| 370 } | |
| 371 } | |
| 372 | |
| 373 class OverlapTest : public ::testing::TestWithParam<float> { | |
| 374 public: | |
| 375 static float MinContentsScale() { return 1.f / 4.f; } | |
| 376 }; | |
| 377 | |
| 378 TEST_P(OverlapTest, NoOverlap) { | |
| 379 gfx::Size tile_size(10, 10); | |
| 380 gfx::Size layer_bounds(30, 30); | |
| 381 gfx::Size bigger_than_layer_bounds(300, 300); | |
| 382 float contents_scale = GetParam(); | |
| 383 // Pick an opaque color to not have to deal with premultiplication off-by-one. | |
| 384 SkColor test_color = SkColorSetARGB(255, 45, 56, 67); | |
| 385 | |
| 386 scoped_ptr<FakePicturePile> recording_source = | |
| 387 FakePicturePile::CreateFilledPile(tile_size, layer_bounds); | |
| 388 recording_source->SetBackgroundColor(SK_ColorTRANSPARENT); | |
| 389 recording_source->SetRequiresClear(true); | |
| 390 recording_source->SetMinContentsScale(MinContentsScale()); | |
| 391 recording_source->SetClearCanvasWithDebugColor(true); | |
| 392 | |
| 393 SkPaint color_paint; | |
| 394 color_paint.setColor(test_color); | |
| 395 // Additive paint, so that if two paints overlap, the color will change. | |
| 396 color_paint.setXfermodeMode(SkXfermode::kPlus_Mode); | |
| 397 // Paint outside the layer to make sure that blending works. | |
| 398 recording_source->add_draw_rect_with_paint( | |
| 399 gfx::Rect(bigger_than_layer_bounds), color_paint); | |
| 400 recording_source->Rerecord(); | |
| 401 | |
| 402 scoped_refptr<FakePicturePileImpl> pile = | |
| 403 FakePicturePileImpl::CreateFromPile(recording_source.get(), nullptr); | |
| 404 gfx::Size content_bounds( | |
| 405 gfx::ToCeiledSize(gfx::ScaleSize(layer_bounds, contents_scale))); | |
| 406 | |
| 407 SkBitmap bitmap; | |
| 408 bitmap.allocN32Pixels(content_bounds.width(), content_bounds.height()); | |
| 409 SkCanvas canvas(bitmap); | |
| 410 | |
| 411 pile->PlaybackToCanvas(&canvas, gfx::Rect(content_bounds), | |
| 412 gfx::Rect(content_bounds), contents_scale); | |
| 413 | |
| 414 for (int y = 0; y < bitmap.height(); y++) { | |
| 415 for (int x = 0; x < bitmap.width(); x++) { | |
| 416 SkColor color = bitmap.getColor(x, y); | |
| 417 EXPECT_EQ(SkColorGetR(test_color), SkColorGetR(color)) << "x: " << x | |
| 418 << ", y: " << y; | |
| 419 EXPECT_EQ(SkColorGetG(test_color), SkColorGetG(color)) << "x: " << x | |
| 420 << ", y: " << y; | |
| 421 EXPECT_EQ(SkColorGetB(test_color), SkColorGetB(color)) << "x: " << x | |
| 422 << ", y: " << y; | |
| 423 EXPECT_EQ(SkColorGetA(test_color), SkColorGetA(color)) << "x: " << x | |
| 424 << ", y: " << y; | |
| 425 if (test_color != color) | |
| 426 break; | |
| 427 } | |
| 428 } | |
| 429 } | |
| 430 | |
| 431 INSTANTIATE_TEST_CASE_P(PicturePileImpl, | |
| 432 OverlapTest, | |
| 433 ::testing::Values(1.f, 0.873f, 1.f / 4.f, 4.f)); | |
| 434 | |
| 435 TEST(PicturePileImplTest, ImageIteratorBorders) { | |
| 436 // 3 tile width / 1 tile height pile | |
| 437 gfx::Size tile_size(128, 128); | |
| 438 gfx::Size layer_bounds(320, 128); | |
| 439 | |
| 440 // Fake picture pile uses a tile grid the size of the tile. So, | |
| 441 // any iteration that intersects with a tile will return all pixel refs | |
| 442 // inside of it. | |
| 443 scoped_ptr<FakePicturePile> recording_source = | |
| 444 FakePicturePile::CreateFilledPile(tile_size, layer_bounds); | |
| 445 recording_source->SetMinContentsScale(0.5f); | |
| 446 | |
| 447 // Bitmaps 0-2 are exactly on tiles 0-2, so that they overlap the borders | |
| 448 // of adjacent tiles. | |
| 449 gfx::Rect bitmap_rects[] = { | |
| 450 recording_source->tiling().TileBounds(0, 0), | |
| 451 recording_source->tiling().TileBounds(1, 0), | |
| 452 recording_source->tiling().TileBounds(2, 0), | |
| 453 }; | |
| 454 gfx::RectF expected_rects[] = { | |
| 455 gfx::RectF(recording_source->tiling().TileBounds(0, 0)), | |
| 456 gfx::RectF(recording_source->tiling().TileBounds(1, 0)), | |
| 457 gfx::RectF(recording_source->tiling().TileBounds(2, 0)), | |
| 458 }; | |
| 459 skia::RefPtr<SkImage> discardable_image[arraysize(bitmap_rects)]; | |
| 460 | |
| 461 for (size_t i = 0; i < arraysize(bitmap_rects); ++i) { | |
| 462 discardable_image[i] = CreateDiscardableImage(bitmap_rects[i].size()); | |
| 463 recording_source->add_draw_image(discardable_image[i].get(), | |
| 464 bitmap_rects[i].origin()); | |
| 465 } | |
| 466 | |
| 467 recording_source->SetGatherDiscardableImages(true); | |
| 468 recording_source->Rerecord(); | |
| 469 | |
| 470 scoped_refptr<FakePicturePileImpl> pile = | |
| 471 FakePicturePileImpl::CreateFromPile(recording_source.get(), nullptr); | |
| 472 | |
| 473 // Sanity check that bitmaps 0-2 intersect the borders of their adjacent | |
| 474 // tiles, but not the actual tiles. | |
| 475 EXPECT_TRUE( | |
| 476 bitmap_rects[0].Intersects(pile->tiling().TileBoundsWithBorder(1, 0))); | |
| 477 EXPECT_FALSE(bitmap_rects[0].Intersects(pile->tiling().TileBounds(1, 0))); | |
| 478 EXPECT_TRUE( | |
| 479 bitmap_rects[1].Intersects(pile->tiling().TileBoundsWithBorder(0, 0))); | |
| 480 EXPECT_FALSE(bitmap_rects[1].Intersects(pile->tiling().TileBounds(0, 0))); | |
| 481 EXPECT_TRUE( | |
| 482 bitmap_rects[1].Intersects(pile->tiling().TileBoundsWithBorder(2, 0))); | |
| 483 EXPECT_FALSE(bitmap_rects[1].Intersects(pile->tiling().TileBounds(2, 0))); | |
| 484 EXPECT_TRUE( | |
| 485 bitmap_rects[2].Intersects(pile->tiling().TileBoundsWithBorder(1, 0))); | |
| 486 EXPECT_FALSE(bitmap_rects[2].Intersects(pile->tiling().TileBounds(1, 0))); | |
| 487 | |
| 488 // Tile-sized iterators. | |
| 489 { | |
| 490 // Because tile 0's borders extend onto tile 1, it will include both | |
| 491 // image 0 and 1. However, it should *not* include image 2. | |
| 492 PicturePileImpl::ImageIterator iterator(pile->tiling().TileBounds(0, 0), | |
| 493 pile.get()); | |
| 494 EXPECT_TRUE(iterator); | |
| 495 EXPECT_TRUE(iterator->image == discardable_image[0].get()); | |
| 496 EXPECT_EQ(expected_rects[0].ToString(), | |
| 497 gfx::SkRectToRectF(iterator->image_rect).ToString()); | |
| 498 EXPECT_TRUE(++iterator); | |
| 499 EXPECT_TRUE(iterator->image == discardable_image[1].get()); | |
| 500 EXPECT_EQ(expected_rects[1].ToString(), | |
| 501 gfx::SkRectToRectF(iterator->image_rect).ToString()); | |
| 502 EXPECT_FALSE(++iterator); | |
| 503 } | |
| 504 { | |
| 505 // Tile 1 + borders hits all images. | |
| 506 PicturePileImpl::ImageIterator iterator(pile->tiling().TileBounds(1, 0), | |
| 507 pile.get()); | |
| 508 EXPECT_TRUE(iterator); | |
| 509 EXPECT_TRUE(iterator->image == discardable_image[0].get()); | |
| 510 EXPECT_EQ(expected_rects[0].ToString(), | |
| 511 gfx::SkRectToRectF(iterator->image_rect).ToString()); | |
| 512 EXPECT_TRUE(++iterator); | |
| 513 EXPECT_TRUE(iterator->image == discardable_image[1].get()); | |
| 514 EXPECT_EQ(expected_rects[1].ToString(), | |
| 515 gfx::SkRectToRectF(iterator->image_rect).ToString()); | |
| 516 EXPECT_TRUE(++iterator); | |
| 517 EXPECT_TRUE(iterator->image == discardable_image[2].get()); | |
| 518 EXPECT_EQ(expected_rects[2].ToString(), | |
| 519 gfx::SkRectToRectF(iterator->image_rect).ToString()); | |
| 520 EXPECT_FALSE(++iterator); | |
| 521 } | |
| 522 { | |
| 523 // Tile 2 should not include image 0, which is only on tile 0 and the | |
| 524 // borders of tile 1. | |
| 525 PicturePileImpl::ImageIterator iterator(pile->tiling().TileBounds(2, 0), | |
| 526 pile.get()); | |
| 527 EXPECT_TRUE(iterator); | |
| 528 EXPECT_TRUE(iterator->image == discardable_image[1].get()); | |
| 529 EXPECT_EQ(expected_rects[1].ToString(), | |
| 530 gfx::SkRectToRectF(iterator->image_rect).ToString()); | |
| 531 EXPECT_TRUE(++iterator); | |
| 532 EXPECT_TRUE(iterator->image == discardable_image[2].get()); | |
| 533 EXPECT_EQ(expected_rects[2].ToString(), | |
| 534 gfx::SkRectToRectF(iterator->image_rect).ToString()); | |
| 535 EXPECT_FALSE(++iterator); | |
| 536 } | |
| 537 } | |
| 538 | |
| 539 } // namespace | |
| 540 } // namespace cc | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1362663002:
cc: Remove PicturePile and PicturePileImpl. (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master