1 // Copyright (c) 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 "ppapi/tests/test_graphics_2d.h" 6 7 #include <stdlib.h> 8 #include <string.h> 9 10 #include <set> 11 12 #include "ppapi/c/pp_errors.h" 13 #include "ppapi/c/ppb_graphics_2d.h" 14 #include "ppapi/cpp/completion_callback.h" 15 #include "ppapi/cpp/graphics_2d.h" 16 #include "ppapi/cpp/graphics_3d.h" 17 #include "ppapi/cpp/image_data.h" 18 #include "ppapi/cpp/instance.h" 19 #include "ppapi/cpp/module.h" 20 #include "ppapi/cpp/rect.h" 21 #include "ppapi/tests/test_utils.h" 22 #include "ppapi/tests/testing_instance.h" 23 24 REGISTER_TEST_CASE(Graphics2D); 25 26 namespace { 27 28 bool CanFlushContext(pp::Instance* instance, pp::Graphics2D* context) { 29 TestCompletionCallback callback(instance->pp_instance()); 30 callback.WaitForResult(context->Flush(callback.GetCallback())); 31 return (callback.result() == PP_OK); 32 } 33 34 bool CanFlushContextC(pp::Instance* instance, PP_Resource graphics_2d, 35 const PPB_Graphics2D_1_1* graphics_2d_if) { 36 TestCompletionCallback callback(instance->pp_instance()); 37 callback.WaitForResult(graphics_2d_if->Flush( 38 graphics_2d, callback.GetCallback().pp_completion_callback())); 39 return (callback.result() == PP_OK); 40 } 41 42 } // namespace 43 44 TestGraphics2D::TestGraphics2D(TestingInstance* instance) 45 : TestCase(instance), 46 is_view_changed_(false), 47 post_quit_on_view_changed_(false) { 48 } 49 50 bool TestGraphics2D::Init() { 51 graphics_2d_interface_ = static_cast<const PPB_Graphics2D*>( 52 pp::Module::Get()->GetBrowserInterface(PPB_GRAPHICS_2D_INTERFACE_1_1)); 53 image_data_interface_ = static_cast<const PPB_ImageData*>( 54 pp::Module::Get()->GetBrowserInterface(PPB_IMAGEDATA_INTERFACE_1_0)); 55 return graphics_2d_interface_ && image_data_interface_ && 56 CheckTestingInterface(); 57 } 58 59 void TestGraphics2D::RunTests(const std::string& filter) { 60 RUN_TEST(InvalidResource, filter); 61 RUN_TEST(InvalidSize, filter); 62 RUN_TEST(Humongous, filter); 63 RUN_TEST(InitToZero, filter); 64 RUN_TEST(Describe, filter); 65 RUN_TEST(Scale, filter); 66 RUN_TEST_FORCEASYNC_AND_NOT(Paint, filter); 67 RUN_TEST_FORCEASYNC_AND_NOT(Scroll, filter); 68 RUN_TEST_FORCEASYNC_AND_NOT(Replace, filter); 69 RUN_TEST_FORCEASYNC_AND_NOT(Flush, filter); 70 RUN_TEST_FORCEASYNC_AND_NOT(FlushOffscreenUpdate, filter); 71 RUN_TEST(Dev, filter); 72 RUN_TEST(ReplaceContentsCaching, filter); 73 RUN_TEST(BindNull, filter); 74 } 75 76 void TestGraphics2D::QuitMessageLoop() { 77 testing_interface_->QuitMessageLoop(instance_->pp_instance()); 78 } 79 80 bool TestGraphics2D::ReadImageData(const pp::Graphics2D& dc, 81 pp::ImageData* image, 82 const pp::Point& top_left) const { 83 return PP_ToBool(testing_interface_->ReadImageData( 84 dc.pp_resource(), 85 image->pp_resource(), 86 &top_left.pp_point())); 87 } 88 89 bool TestGraphics2D::IsDCUniformColor(const pp::Graphics2D& dc, 90 uint32_t color) const { 91 pp::ImageData readback(instance_, PP_IMAGEDATAFORMAT_BGRA_PREMUL, 92 dc.size(), false); 93 if (readback.is_null()) 94 return false; 95 if (!ReadImageData(dc, &readback, pp::Point(0, 0))) 96 return false; 97 return IsSquareInImage(readback, 0, pp::Rect(dc.size()), color); 98 } 99 100 std::string TestGraphics2D::FlushAndWaitForDone(pp::Graphics2D* context) { 101 TestCompletionCallback callback(instance_->pp_instance(), callback_type()); 102 callback.WaitForResult(context->Flush(callback.GetCallback())); 103 CHECK_CALLBACK_BEHAVIOR(callback); 104 ASSERT_EQ(PP_OK, callback.result()); 105 PASS(); 106 } 107 108 void TestGraphics2D::FillRectInImage(pp::ImageData* image, 109 const pp::Rect& rect, 110 uint32_t color) const { 111 for (int y = rect.y(); y < rect.bottom(); y++) { 112 uint32_t* row = image->GetAddr32(pp::Point(rect.x(), y)); 113 for (int pixel = 0; pixel < rect.width(); pixel++) 114 row[pixel] = color; 115 } 116 } 117 118 void TestGraphics2D::FillImageWithGradient(pp::ImageData* image) const { 119 for (int y = 0; y < image->size().height(); y++) { 120 uint32_t red = ((y * 256) / image->size().height()) & 0xFF; 121 for (int x = 0; x < image->size().width(); x++) { 122 uint32_t green = ((x * 256) / image->size().width()) & 0xFF; 123 uint32_t blue = ((red + green) / 2) & 0xFF; 124 uint32_t* pixel = image->GetAddr32(pp::Point(x, y)); 125 *pixel = (blue << 24) | (green << 16) | (red << 8); 126 } 127 } 128 } 129 130 bool TestGraphics2D::CompareImages(const pp::ImageData& image1, 131 const pp::ImageData& image2) { 132 return CompareImageRect( 133 image1, pp::Rect(0, 0, image1.size().width(), image1.size().height()), 134 image2, pp::Rect(0, 0, image2.size().width(), image2.size().height())); 135 } 136 137 bool TestGraphics2D::CompareImageRect(const pp::ImageData& image1, 138 const pp::Rect& rc1, 139 const pp::ImageData& image2, 140 const pp::Rect& rc2) const { 141 if (rc1.width() != rc2.width() || rc1.height() != rc2.height()) 142 return false; 143 144 for (int y = 0; y < rc1.height(); y++) { 145 for (int x = 0; x < rc1.width(); x++) { 146 if (*(image1.GetAddr32(pp::Point(rc1.x() + x, rc1.y() + y))) != 147 *(image2.GetAddr32(pp::Point(rc2.x() + x, rc2.y() + y)))) 148 return false; 149 } 150 } 151 return true; 152 } 153 154 bool TestGraphics2D::IsSquareInImage(const pp::ImageData& image_data, 155 uint32_t background_color, 156 const pp::Rect& square, 157 uint32_t square_color) const { 158 for (int y = 0; y < image_data.size().height(); y++) { 159 for (int x = 0; x < image_data.size().width(); x++) { 160 uint32_t pixel = *image_data.GetAddr32(pp::Point(x, y)); 161 uint32_t desired_color; 162 if (square.Contains(x, y)) 163 desired_color = square_color; 164 else 165 desired_color = background_color; 166 if (pixel != desired_color) 167 return false; 168 } 169 } 170 return true; 171 } 172 173 bool TestGraphics2D::IsSquareInDC(const pp::Graphics2D& dc, 174 uint32_t background_color, 175 const pp::Rect& square, 176 uint32_t square_color) const { 177 pp::ImageData readback(instance_, PP_IMAGEDATAFORMAT_BGRA_PREMUL, 178 dc.size(), false); 179 if (readback.is_null()) 180 return false; 181 if (!ReadImageData(dc, &readback, pp::Point(0, 0))) 182 return false; 183 return IsSquareInImage(readback, background_color, square, square_color); 184 } 185 186 187 PP_Resource TestGraphics2D::ReplaceContentsAndReturnID( 188 pp::Graphics2D* dc, 189 const pp::Size& size) { 190 pp::ImageData image(instance_, PP_IMAGEDATAFORMAT_BGRA_PREMUL, size, true); 191 192 PP_Resource id = image.pp_resource(); 193 194 dc->ReplaceContents(&image); 195 std::string result = FlushAndWaitForDone(dc); 196 if (!result.empty()) 197 return 0; 198 199 return id; 200 } 201 202 // Test all the functions with an invalid handle. Most of these just check for 203 // a crash since the browser don't return a value. 204 std::string TestGraphics2D::TestInvalidResource() { 205 pp::Graphics2D null_context; 206 pp::ImageData image(instance_, PP_IMAGEDATAFORMAT_BGRA_PREMUL, 207 pp::Size(16, 16), true); 208 209 // Describe. 210 PP_Size size; 211 PP_Bool opaque; 212 graphics_2d_interface_->Describe(image.pp_resource(), &size, &opaque); 213 graphics_2d_interface_->Describe(null_context.pp_resource(), 214 &size, &opaque); 215 216 // PaintImageData. 217 PP_Point zero_zero; 218 zero_zero.x = 0; 219 zero_zero.y = 0; 220 graphics_2d_interface_->PaintImageData(image.pp_resource(), 221 image.pp_resource(), 222 &zero_zero, NULL); 223 graphics_2d_interface_->PaintImageData(null_context.pp_resource(), 224 image.pp_resource(), 225 &zero_zero, NULL); 226 227 // Scroll. 228 PP_Point zero_ten; 229 zero_ten.x = 0; 230 zero_ten.y = 10; 231 graphics_2d_interface_->Scroll(image.pp_resource(), NULL, &zero_ten); 232 graphics_2d_interface_->Scroll(null_context.pp_resource(), 233 NULL, &zero_ten); 234 235 // ReplaceContents. 236 graphics_2d_interface_->ReplaceContents(image.pp_resource(), 237 image.pp_resource()); 238 graphics_2d_interface_->ReplaceContents(null_context.pp_resource(), 239 image.pp_resource()); 240 241 // Flush. 242 TestCompletionCallback cb(instance_->pp_instance(), PP_OPTIONAL); 243 cb.WaitForResult( 244 graphics_2d_interface_->Flush(image.pp_resource(), 245 cb.GetCallback().pp_completion_callback())); 246 ASSERT_EQ(PP_ERROR_BADRESOURCE, cb.result()); 247 cb.WaitForResult( 248 graphics_2d_interface_->Flush(null_context.pp_resource(), 249 cb.GetCallback().pp_completion_callback())); 250 ASSERT_EQ(PP_ERROR_BADRESOURCE, cb.result()); 251 252 // ReadImageData. 253 ASSERT_FALSE(testing_interface_->ReadImageData(image.pp_resource(), 254 image.pp_resource(), 255 &zero_zero)); 256 ASSERT_FALSE(testing_interface_->ReadImageData(null_context.pp_resource(), 257 image.pp_resource(), 258 &zero_zero)); 259 260 PASS(); 261 } 262 263 std::string TestGraphics2D::TestInvalidSize() { 264 pp::Graphics2D a(instance_, pp::Size(16, 0), false); 265 ASSERT_FALSE(CanFlushContext(instance_, &a)); 266 267 pp::Graphics2D b(instance_, pp::Size(0, 16), false); 268 ASSERT_FALSE(CanFlushContext(instance_, &b)); 269 270 // Need to use the C API since pp::Size prevents negative sizes. 271 PP_Size size; 272 size.width = 16; 273 size.height = -16; 274 PP_Resource graphics = graphics_2d_interface_->Create( 275 instance_->pp_instance(), &size, PP_FALSE); 276 ASSERT_FALSE(CanFlushContextC(instance_, graphics, graphics_2d_interface_)); 277 pp::Module::Get()->core()->ReleaseResource(graphics); 278 279 size.width = -16; 280 size.height = 16; 281 graphics = graphics_2d_interface_->Create( 282 instance_->pp_instance(), &size, PP_FALSE); 283 ASSERT_FALSE(CanFlushContextC(instance_, graphics, graphics_2d_interface_)); 284 pp::Module::Get()->core()->ReleaseResource(graphics); 285 286 // Overflow to negative size 287 size.width = std::numeric_limits<int32_t>::max(); 288 size.height = std::numeric_limits<int32_t>::max(); 289 graphics = graphics_2d_interface_->Create( 290 instance_->pp_instance(), &size, PP_FALSE); 291 ASSERT_FALSE(CanFlushContextC(instance_, graphics, graphics_2d_interface_)); 292 pp::Module::Get()->core()->ReleaseResource(graphics); 293 294 PASS(); 295 } 296 297 std::string TestGraphics2D::TestHumongous() { 298 pp::Graphics2D a(instance_, pp::Size(100000, 100000), false); 299 ASSERT_FALSE(CanFlushContext(instance_, &a)); 300 PASS(); 301 } 302 303 std::string TestGraphics2D::TestInitToZero() { 304 const int w = 15, h = 17; 305 pp::Graphics2D dc(instance_, pp::Size(w, h), false); 306 ASSERT_FALSE(dc.is_null()); 307 308 // Make an image with nonzero data in it (so we can test that zeros were 309 // actually read versus ReadImageData being a NOP). 310 pp::ImageData image(instance_, PP_IMAGEDATAFORMAT_BGRA_PREMUL, 311 pp::Size(w, h), true); 312 ASSERT_FALSE(image.is_null()); 313 ASSERT_FALSE(image.size().IsEmpty()); 314 memset(image.data(), 0xFF, image.stride() * image.size().height() * 4); 315 316 // Read out the initial data from the device & check. 317 ASSERT_TRUE(ReadImageData(dc, &image, pp::Point(0, 0))); 318 ASSERT_TRUE(IsSquareInImage(image, 0, pp::Rect(0, 0, w, h), 0)); 319 320 PASS(); 321 } 322 323 std::string TestGraphics2D::TestDescribe() { 324 const int w = 15, h = 17; 325 const bool always_opaque = (::rand() % 2 == 1); 326 pp::Graphics2D dc(instance_, pp::Size(w, h), always_opaque); 327 ASSERT_FALSE(dc.is_null()); 328 329 PP_Size size; 330 size.width = -1; 331 size.height = -1; 332 PP_Bool is_always_opaque = PP_FALSE; 333 ASSERT_TRUE(graphics_2d_interface_->Describe(dc.pp_resource(), &size, 334 &is_always_opaque)); 335 ASSERT_EQ(w, size.width); 336 ASSERT_EQ(h, size.height); 337 ASSERT_EQ(PP_FromBool(always_opaque), is_always_opaque); 338 339 PASS(); 340 } 341 342 std::string TestGraphics2D::TestScale() { 343 // Tests GetScale/SetScale 344 const int w = 20, h = 16; 345 const float scale = 1.0f/2.0f; 346 pp::Graphics2D dc(instance_, pp::Size(w, h), false); 347 ASSERT_FALSE(dc.is_null()); 348 ASSERT_EQ(1.0, dc.GetScale()); 349 ASSERT_TRUE(dc.SetScale(scale)); 350 ASSERT_EQ(scale, dc.GetScale()); 351 // Try setting a few invalid scale factors. Ensure that we catch these errors 352 // and don't change the actual scale 353 ASSERT_FALSE(dc.SetScale(-1.0f)); 354 ASSERT_FALSE(dc.SetScale(0.0f)); 355 ASSERT_EQ(scale, dc.GetScale()); 356 357 // Verify that the context has the specified number of pixels, despite the 358 // non-identity scale 359 PP_Size size; 360 size.width = -1; 361 size.height = -1; 362 PP_Bool is_always_opaque = PP_FALSE; 363 ASSERT_TRUE(graphics_2d_interface_->Describe(dc.pp_resource(), &size, 364 &is_always_opaque)); 365 ASSERT_EQ(w, size.width); 366 ASSERT_EQ(h, size.height); 367 ASSERT_EQ(PP_FALSE, is_always_opaque); 368 369 PASS(); 370 } 371 372 std::string TestGraphics2D::TestPaint() { 373 const int w = 15, h = 17; 374 pp::Graphics2D dc(instance_, pp::Size(w, h), false); 375 ASSERT_FALSE(dc.is_null()); 376 377 // Make sure the device background is 0. 378 ASSERT_TRUE(IsDCUniformColor(dc, 0)); 379 380 // Fill the backing store with white. 381 const uint32_t background_color = 0xFFFFFFFF; 382 pp::ImageData background(instance_, PP_IMAGEDATAFORMAT_BGRA_PREMUL, 383 pp::Size(w, h), false); 384 FillRectInImage(&background, pp::Rect(0, 0, w, h), background_color); 385 dc.PaintImageData(background, pp::Point(0, 0)); 386 ASSERT_SUBTEST_SUCCESS(FlushAndWaitForDone(&dc)); 387 388 // Make an image to paint with that's opaque white and enqueue a paint. 389 const int fill_w = 2, fill_h = 3; 390 pp::ImageData fill(instance_, PP_IMAGEDATAFORMAT_BGRA_PREMUL, 391 pp::Size(fill_w, fill_h), true); 392 ASSERT_FALSE(fill.is_null()); 393 FillRectInImage(&fill, pp::Rect(fill.size()), background_color); 394 const int paint_x = 4, paint_y = 5; 395 dc.PaintImageData(fill, pp::Point(paint_x, paint_y)); 396 397 // Validate that nothing has been actually painted. 398 ASSERT_TRUE(IsDCUniformColor(dc, background_color)); 399 400 // The paint hasn't been flushed so we can still change the bitmap. Fill with 401 // 50% blue. This will also verify that the backing store is replaced 402 // with the contents rather than blended. 403 const uint32_t fill_color = 0x80000080; 404 FillRectInImage(&fill, pp::Rect(fill.size()), fill_color); 405 ASSERT_SUBTEST_SUCCESS(FlushAndWaitForDone(&dc)); 406 407 ASSERT_TRUE(IsSquareInDC(dc, background_color, 408 pp::Rect(paint_x, paint_y, fill_w, fill_h), 409 fill_color)); 410 411 // Reset the DC to blank white & paint our image slightly off the buffer. 412 // This should succeed. We also try painting the same thing where the 413 // dirty rect falls outeside of the device, which should fail. 414 dc.PaintImageData(background, pp::Point(0, 0)); 415 const int second_paint_x = -1, second_paint_y = -2; 416 dc.PaintImageData(fill, pp::Point(second_paint_x, second_paint_y)); 417 dc.PaintImageData(fill, pp::Point(second_paint_x, second_paint_y), 418 pp::Rect(-second_paint_x, -second_paint_y, 1, 1)); 419 ASSERT_SUBTEST_SUCCESS(FlushAndWaitForDone(&dc)); 420 421 // Now we should have a little bit of the image peeking out the top left. 422 ASSERT_TRUE(IsSquareInDC(dc, background_color, pp::Rect(0, 0, 1, 1), 423 fill_color)); 424 425 // Now repaint that top left pixel by doing a subset of the source image. 426 pp::ImageData subset(instance_, PP_IMAGEDATAFORMAT_BGRA_PREMUL, 427 pp::Size(w, h), false); 428 uint32_t subset_color = 0x80808080; 429 const int subset_x = 2, subset_y = 1; 430 *subset.GetAddr32(pp::Point(subset_x, subset_y)) = subset_color; 431 dc.PaintImageData(subset, pp::Point(-subset_x, -subset_y), 432 pp::Rect(subset_x, subset_y, 1, 1)); 433 ASSERT_SUBTEST_SUCCESS(FlushAndWaitForDone(&dc)); 434 ASSERT_TRUE(IsSquareInDC(dc, background_color, pp::Rect(0, 0, 1, 1), 435 subset_color)); 436 437 PASS(); 438 } 439 440 std::string TestGraphics2D::TestScroll() { 441 const int w = 115, h = 117; 442 pp::Graphics2D dc(instance_, pp::Size(w, h), false); 443 ASSERT_FALSE(dc.is_null()); 444 ASSERT_TRUE(instance_->BindGraphics(dc)); 445 446 // Make sure the device background is 0. 447 ASSERT_TRUE(IsDCUniformColor(dc, 0)); 448 449 const int image_width = 15, image_height = 23; 450 pp::ImageData test_image(instance_, PP_IMAGEDATAFORMAT_BGRA_PREMUL, 451 pp::Size(image_width, image_height), false); 452 FillImageWithGradient(&test_image); 453 pp::ImageData no_image(instance_, PP_IMAGEDATAFORMAT_BGRA_PREMUL, 454 pp::Size(image_width, image_height), false); 455 FillRectInImage(&no_image, pp::Rect(0, 0, image_width, image_height), 0); 456 pp::ImageData readback_image(instance_, PP_IMAGEDATAFORMAT_BGRA_PREMUL, 457 pp::Size(image_width, image_height), false); 458 pp::ImageData readback_scroll(instance_, PP_IMAGEDATAFORMAT_BGRA_PREMUL, 459 pp::Size(image_width, image_height), false); 460 461 ASSERT_EQ(pp::Size(image_width, image_height), test_image.size()); 462 463 int image_x = 51, image_y = 72; 464 dc.PaintImageData(test_image, pp::Point(image_x, image_y)); 465 ASSERT_SUBTEST_SUCCESS(FlushAndWaitForDone(&dc)); 466 467 // Test Case 1. Incorrect usage when scrolling image to a free space. 468 // The clip area is *not* the area to shift around within the graphics device 469 // by specified amount. It's the area to which the scroll is limited. So if 470 // the clip area is the size of the image and the amount points to free space, 471 // the scroll won't result in additional images. 472 int dx = -40, dy = -48; 473 int scroll_x = image_x + dx, scroll_y = image_y + dy; 474 pp::Rect clip(image_x, image_y, image_width, image_height); 475 dc.Scroll(clip, pp::Point(dx, dy)); 476 ASSERT_SUBTEST_SUCCESS(FlushAndWaitForDone(&dc)); 477 ASSERT_TRUE( 478 ReadImageData(dc, &readback_scroll, pp::Point(scroll_x, scroll_y))); 479 ASSERT_TRUE(CompareImages(no_image, readback_scroll)); 480 481 // Test Case 2. 482 // The amount is intended to place the image in the free space outside 483 // of the original, but the clip area extends beyond the graphics device area. 484 // This scroll is invalid and will be a noop. 485 scroll_x = 11, scroll_y = 24; 486 clip = pp::Rect(0, 0, w, h + 1); 487 dc.Scroll(clip, pp::Point(scroll_x - image_x, scroll_y - image_y)); 488 ASSERT_SUBTEST_SUCCESS(FlushAndWaitForDone(&dc)); 489 ASSERT_TRUE( 490 ReadImageData(dc, &readback_scroll, pp::Point(scroll_x, scroll_y))); 491 ASSERT_TRUE(CompareImages(no_image, readback_scroll)); 492 493 // Test Case 3. 494 // The amount is intended to place the image in the free space outside 495 // of the original, but the clip area does not cover the image, 496 // so there is nothing to scroll. 497 scroll_x = 11, scroll_y = 24; 498 clip = pp::Rect(0, 0, image_x, image_y); 499 dc.Scroll(clip, pp::Point(scroll_x - image_x, scroll_y - image_y)); 500 ASSERT_SUBTEST_SUCCESS(FlushAndWaitForDone(&dc)); 501 ASSERT_TRUE( 502 ReadImageData(dc, &readback_scroll, pp::Point(scroll_x, scroll_y))); 503 ASSERT_TRUE(CompareImages(no_image, readback_scroll)); 504 505 // Test Case 4. 506 // Same as TC3, but the clip covers part of the image. 507 // This part will be scrolled to the intended origin. 508 int part_w = image_width / 2, part_h = image_height / 2; 509 clip = pp::Rect(0, 0, image_x + part_w, image_y + part_h); 510 dc.Scroll(clip, pp::Point(scroll_x - image_x, scroll_y - image_y)); 511 ASSERT_SUBTEST_SUCCESS(FlushAndWaitForDone(&dc)); 512 ASSERT_TRUE( 513 ReadImageData(dc, &readback_scroll, pp::Point(scroll_x, scroll_y))); 514 ASSERT_FALSE(CompareImages(test_image, readback_scroll)); 515 pp::Rect part_rect(part_w, part_h); 516 ASSERT_TRUE( 517 CompareImageRect(test_image, part_rect, readback_scroll, part_rect)); 518 519 // Test Case 5 520 // Same as TC3, but the clip area covers the entire image. 521 // It will be scrolled to the intended origin. 522 clip = pp::Rect(0, 0, image_x + image_width, image_y + image_height); 523 dc.Scroll(clip, pp::Point(scroll_x - image_x, scroll_y - image_y)); 524 ASSERT_SUBTEST_SUCCESS(FlushAndWaitForDone(&dc)); 525 ASSERT_TRUE( 526 ReadImageData(dc, &readback_scroll, pp::Point(scroll_x, scroll_y))); 527 ASSERT_TRUE(CompareImages(test_image, readback_scroll)); 528 529 // Note that the undefined area left by the scroll does not actually get 530 // cleared, so the original image is still there. This is not guaranteed and 531 // is not something for users to rely on, but we can test for this here, so 532 // we know when the underlying behavior changes. 533 ASSERT_TRUE(ReadImageData(dc, &readback_image, pp::Point(image_x, image_y))); 534 ASSERT_TRUE(CompareImages(test_image, readback_image)); 535 536 // Test Case 6. 537 // Scroll image to an overlapping space. The clip area is limited 538 // to the image, so this will just modify its area. 539 dx = 6; 540 dy = 9; 541 scroll_x = image_x + dx; 542 scroll_y = image_y + dy; 543 clip = pp::Rect(image_x, image_y, image_width, image_height); 544 dc.Scroll(clip, pp::Point(dx, dy)); 545 ASSERT_SUBTEST_SUCCESS(FlushAndWaitForDone(&dc)); 546 ASSERT_TRUE(ReadImageData(dc, &readback_image, pp::Point(image_x, image_y))); 547 ASSERT_FALSE(CompareImages(test_image, readback_image)); 548 pp::Rect scroll_rect(image_width - dx, image_height - dy); 549 ASSERT_TRUE( 550 ReadImageData(dc, &readback_scroll, pp::Point(scroll_x, scroll_y))); 551 ASSERT_TRUE( 552 CompareImageRect(test_image, scroll_rect, readback_scroll, scroll_rect)); 553 554 PASS(); 555 } 556 557 std::string TestGraphics2D::TestReplace() { 558 const int w = 15, h = 17; 559 pp::Graphics2D dc(instance_, pp::Size(w, h), false); 560 ASSERT_FALSE(dc.is_null()); 561 562 // Replacing with a different size image should fail. 563 pp::ImageData weird_size(instance_, PP_IMAGEDATAFORMAT_BGRA_PREMUL, 564 pp::Size(w - 1, h), true); 565 ASSERT_FALSE(weird_size.is_null()); 566 dc.ReplaceContents(&weird_size); 567 568 // Fill the background with blue but don't flush yet. 569 const uint32_t background_color = 0xFF0000FF; 570 pp::ImageData background(instance_, PP_IMAGEDATAFORMAT_BGRA_PREMUL, 571 pp::Size(w, h), true); 572 ASSERT_FALSE(background.is_null()); 573 FillRectInImage(&background, pp::Rect(0, 0, w, h), background_color); 574 dc.PaintImageData(background, pp::Point(0, 0)); 575 576 // Replace with a green background but don't flush yet. 577 const int32_t swapped_color = 0x00FF00FF; 578 pp::ImageData swapped(instance_, PP_IMAGEDATAFORMAT_BGRA_PREMUL, 579 pp::Size(w, h), true); 580 ASSERT_FALSE(swapped.is_null()); 581 FillRectInImage(&swapped, pp::Rect(0, 0, w, h), swapped_color); 582 dc.ReplaceContents(&swapped); 583 584 // The background should be unchanged since we didn't flush yet. 585 ASSERT_TRUE(IsDCUniformColor(dc, 0)); 586 587 // Test the C++ wrapper. The size of the swapped image should be reset. 588 ASSERT_TRUE(!swapped.pp_resource() && !swapped.size().width() && 589 !swapped.size().height() && !swapped.data()); 590 591 // Painting with the swapped image should fail. 592 dc.PaintImageData(swapped, pp::Point(0, 0)); 593 594 // Flush and make sure the result is correct. 595 ASSERT_SUBTEST_SUCCESS(FlushAndWaitForDone(&dc)); 596 597 // The background should be green from the swapped image. 598 ASSERT_TRUE(IsDCUniformColor(dc, swapped_color)); 599 600 PASS(); 601 } 602 603 std::string TestGraphics2D::TestFlush() { 604 // Tests that synchronous flushes (NULL callback) fail on the main thread 605 // (which is the current one). 606 const int w = 15, h = 17; 607 pp::Graphics2D dc(instance_, pp::Size(w, h), false); 608 ASSERT_FALSE(dc.is_null()); 609 610 // Fill the background with blue but don't flush yet. 611 pp::ImageData background(instance_, PP_IMAGEDATAFORMAT_BGRA_PREMUL, 612 pp::Size(w, h), true); 613 ASSERT_FALSE(background.is_null()); 614 dc.PaintImageData(background, pp::Point(0, 0)); 615 616 int32_t rv = dc.Flush(pp::BlockUntilComplete()); 617 ASSERT_EQ(PP_ERROR_BLOCKS_MAIN_THREAD, rv); 618 619 // Test flushing with no operations still issues a callback. 620 // (This may also hang if the browser never issues the callback). 621 pp::Graphics2D dc_nopaints(instance_, pp::Size(w, h), false); 622 ASSERT_FALSE(dc.is_null()); 623 ASSERT_SUBTEST_SUCCESS(FlushAndWaitForDone(&dc_nopaints)); 624 625 TestCompletionCallback callback_1(instance_->pp_instance(), callback_type()); 626 627 // Test that multiple flushes fail if we don't get a callback in between. 628 rv = dc_nopaints.Flush(callback_1.GetCallback()); 629 if (rv == PP_OK_COMPLETIONPENDING) { 630 // If the first flush completes asynchronously, then a second should fail. 631 TestCompletionCallback callback_2(instance_->pp_instance(), 632 callback_type()); 633 callback_2.WaitForResult(dc_nopaints.Flush(callback_2.GetCallback())); 634 CHECK_CALLBACK_BEHAVIOR(callback_2); 635 ASSERT_EQ(PP_ERROR_INPROGRESS, callback_2.result()); 636 } 637 callback_1.WaitForResult(rv); 638 ASSERT_EQ(PP_OK, callback_1.result()); 639 640 PASS(); 641 } 642 643 void TestGraphics2D::DidChangeView(const pp::View& view) { 644 if (post_quit_on_view_changed_) { 645 post_quit_on_view_changed_ = false; 646 is_view_changed_ = true; 647 testing_interface_->QuitMessageLoop(instance_->pp_instance()); 648 } 649 } 650 651 void TestGraphics2D::ResetViewChangedState() { 652 is_view_changed_ = false; 653 } 654 655 bool TestGraphics2D::WaitUntilViewChanged() { 656 // Run a nested message loop. It will exit either on ViewChanged or if the 657 // timeout happens. 658 659 // If view changed before we have chance to run message loop, return directly. 660 if (is_view_changed_) 661 return true; 662 663 post_quit_on_view_changed_ = true; 664 testing_interface_->RunMessageLoop(instance_->pp_instance()); 665 post_quit_on_view_changed_ = false; 666 667 return is_view_changed_; 668 } 669 670 std::string TestGraphics2D::TestFlushOffscreenUpdate() { 671 // Tests that callback of offscreen updates should be delayed. 672 const PP_Time kFlushDelaySec = 1. / 30; // 30 fps 673 const int w = 80, h = 80; 674 pp::Graphics2D dc(instance_, pp::Size(w, h), true); 675 ASSERT_FALSE(dc.is_null()); 676 ASSERT_TRUE(instance_->BindGraphics(dc)); 677 678 // Squeeze from top until bottom half of plugin is out of screen. 679 ResetViewChangedState(); 680 instance_->EvalScript( 681 "var big = document.createElement('div');" 682 "var offset = " 683 " window.innerHeight - plugin.offsetTop - plugin.offsetHeight / 2;" 684 "big.setAttribute('id', 'big-div');" 685 "big.setAttribute('style', 'height: ' + offset + '; width: 100%;');" 686 "document.body.insertBefore(big, document.body.firstChild);"); 687 ASSERT_TRUE(WaitUntilViewChanged()); 688 689 // Allocate a red image chunk 690 pp::ImageData chunk(instance_, PP_IMAGEDATAFORMAT_RGBA_PREMUL, 691 pp::Size(w/8, h/8), true); 692 ASSERT_FALSE(chunk.is_null()); 693 const uint32_t kRed = 0xff0000ff; 694 FillRectInImage(&chunk, pp::Rect(chunk.size()), kRed); 695 696 // Paint a invisable chunk, expecting Flush to invoke callback slowly. 697 dc.PaintImageData(chunk, pp::Point(0, h*0.75)); 698 699 PP_Time begin = pp::Module::Get()->core()->GetTime(); 700 ASSERT_SUBTEST_SUCCESS(FlushAndWaitForDone(&dc)); 701 PP_Time actual_time_elapsed = pp::Module::Get()->core()->GetTime() - begin; 702 // Expect actual_time_elapsed >= kFlushDelaySec, but loose a bit to avoid 703 // precision issue. 704 ASSERT_GE(actual_time_elapsed, kFlushDelaySec * 0.9); 705 706 // Remove the padding on the top since test cases here isn't independent. 707 instance_->EvalScript( 708 "var big = document.getElementById('big-div');" 709 "big.parentNode.removeChild(big);"); 710 ResetViewChangedState(); 711 ASSERT_TRUE(WaitUntilViewChanged()); 712 713 PASS(); 714 } 715 716 std::string TestGraphics2D::TestDev() { 717 // Tests GetScale/SetScale via the Graphics2D_Dev C++ wrapper 718 const int w = 20, h = 16; 719 const float scale = 1.0f/2.0f; 720 pp::Graphics2D dc(instance_, pp::Size(w, h), false); 721 ASSERT_FALSE(dc.is_null()); 722 ASSERT_EQ(1.0f, dc.GetScale()); 723 ASSERT_TRUE(dc.SetScale(scale)); 724 ASSERT_EQ(scale, dc.GetScale()); 725 // Try setting a few invalid scale factors. Ensure that we catch these errors 726 // and don't change the actual scale 727 ASSERT_FALSE(dc.SetScale(-1.0f)); 728 ASSERT_FALSE(dc.SetScale(0.0f)); 729 ASSERT_EQ(scale, dc.GetScale()); 730 731 // Verify that the context has the specified number of pixels, despite the 732 // non-identity scale 733 PP_Size size; 734 size.width = -1; 735 size.height = -1; 736 PP_Bool is_always_opaque = PP_FALSE; 737 ASSERT_TRUE(graphics_2d_interface_->Describe(dc.pp_resource(), &size, 738 &is_always_opaque)); 739 ASSERT_EQ(w, size.width); 740 ASSERT_EQ(h, size.height); 741 ASSERT_EQ(PP_FALSE, is_always_opaque); 742 743 PASS(); 744 } 745 746 // This test makes sure that the out-of-process image data caching works as 747 // expected. Doing ReplaceContents quickly should re-use the image data from 748 // older ones. 749 std::string TestGraphics2D::TestReplaceContentsCaching() { 750 // The cache is only active when running in the proxy, so skip it otherwise. 751 if (!testing_interface_->IsOutOfProcess()) 752 PASS(); 753 754 // Here we test resource IDs as a way to determine if the resource is being 755 // cached and re-used. This is non-optimal since it's entirely possible 756 // (and maybe better) for the proxy to return new resource IDs for the 757 // re-used objects. Howevever, our current implementation does this so it is 758 // an easy thing to check for. 759 // 760 // You could check for the shared memory pointers getting re-used, but the 761 // OS is very likely to use the same memory location for a newly-mapped image 762 // if one was deleted, meaning that it could pass even if the cache is broken. 763 // This would then require that we add some address-re-use-preventing code 764 // which would be tricky. 765 std::set<PP_Resource> resources; 766 767 pp::Size size(16, 16); 768 pp::Graphics2D dc(instance_, size, false); 769 770 // Do two replace contentses, adding the old resource IDs to our map. 771 PP_Resource imageres = ReplaceContentsAndReturnID(&dc, size); 772 ASSERT_TRUE(imageres); 773 resources.insert(imageres); 774 imageres = ReplaceContentsAndReturnID(&dc, size); 775 ASSERT_TRUE(imageres); 776 resources.insert(imageres); 777 778 // Now doing more replace contents should re-use older IDs if the cache is 779 // working. 780 imageres = ReplaceContentsAndReturnID(&dc, size); 781 ASSERT_TRUE(resources.find(imageres) != resources.end()); 782 imageres = ReplaceContentsAndReturnID(&dc, size); 783 ASSERT_TRUE(resources.find(imageres) != resources.end()); 784 785 PASS(); 786 } 787 788 std::string TestGraphics2D::TestBindNull() { 789 // Binding a null resource is not an error, it should clear all bound 790 // resources. We can't easily test what resource is bound, but we can test 791 // that this doesn't throw an error. 792 ASSERT_TRUE(instance_->BindGraphics(pp::Graphics2D())); 793 ASSERT_TRUE(instance_->BindGraphics(pp::Graphics3D())); 794 795 const int w = 115, h = 117; 796 pp::Graphics2D dc(instance_, pp::Size(w, h), false); 797 ASSERT_FALSE(dc.is_null()); 798 ASSERT_TRUE(instance_->BindGraphics(dc)); 799 800 ASSERT_TRUE(instance_->BindGraphics(pp::Graphics2D())); 801 ASSERT_TRUE(instance_->BindGraphics(pp::Graphics3D())); 802 803 PASS(); 804 } 805 806
