ppapi/tests/test_graphics_2d.cc

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