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