Add an instance parameter to var objects, audio, and the 2D API. This replace...

ppapi/tests/test_graphics_2d.cc

 // Copyright (c) 2010 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ppapi/tests/test_graphics_2d.h"
 
 #include <string.h>
 
 #include "ppapi/c/dev/ppb_testing_dev.h"
 #include "ppapi/c/pp_errors.h"
@@ skipping 59 matching lines @@
                                    pp::ImageData* image,
                                    const pp::Point& top_left) const {
   return pp::PPBoolToBool(testing_interface_->ReadImageData(
       dc.pp_resource(),
       image->pp_resource(),
       &top_left.pp_point()));
 }
 
 bool TestGraphics2D::IsDCUniformColor(const pp::Graphics2D& dc,
                                       uint32_t color) const {
-  pp::ImageData readback(PP_IMAGEDATAFORMAT_BGRA_PREMUL,
+  pp::ImageData readback(instance_, PP_IMAGEDATAFORMAT_BGRA_PREMUL,
                          dc.size(), false);
   if (readback.is_null())
     return false;
   if (!ReadImageData(dc, &readback, pp::Point(0, 0)))
     return false;
   return IsSquareInImage(readback, 0, pp::Rect(dc.size()), color);
 }
 
 bool TestGraphics2D::FlushAndWaitForDone(pp::Graphics2D* context) {
   pp::CompletionCallback cc(&FlushCallbackQuitMessageLoop, this);
@@ skipping 68 matching lines @@
         return false;
     }
   }
   return true;
 }
 
 bool TestGraphics2D::IsSquareInDC(const pp::Graphics2D& dc,
                                   uint32_t background_color,
                                   const pp::Rect& square,
                                   uint32_t square_color) const {
-  pp::ImageData readback(PP_IMAGEDATAFORMAT_BGRA_PREMUL,
+  pp::ImageData readback(instance_, PP_IMAGEDATAFORMAT_BGRA_PREMUL,
                          dc.size(), false);
   if (readback.is_null())
     return false;
   if (!ReadImageData(dc, &readback, pp::Point(0, 0)))
     return false;
   return IsSquareInImage(readback, background_color, square, square_color);
 }
 
 // Test all the functions with an invalid handle. Most of these just check for
 // a crash since the browser don't return a value.
 std::string TestGraphics2D::TestInvalidResource() {
   pp::Graphics2D null_context;
-  pp::ImageData image(PP_IMAGEDATAFORMAT_BGRA_PREMUL, pp::Size(16, 16), true);
+  pp::ImageData image(instance_, PP_IMAGEDATAFORMAT_BGRA_PREMUL,
+                      pp::Size(16, 16), true);
 
   // Describe.
   PP_Size size;
   PP_Bool opaque;
   graphics_2d_interface_->Describe(image.pp_resource(), &size, &opaque);
   graphics_2d_interface_->Describe(null_context.pp_resource(),
                                    &size, &opaque);
 
   // PaintImageData.
   PP_Point zero_zero;
@@ skipping 37 matching lines @@
     return "ReadImageData succeeded with a different resource";
   if (testing_interface_->ReadImageData(null_context.pp_resource(),
                                         image.pp_resource(),
                                         &zero_zero))
     return "ReadImageData succeeded with a NULL resource";
 
   return "";
 }
 
 std::string TestGraphics2D::TestInvalidSize() {
-  pp::Graphics2D a(pp::Size(16, 0), false);
+  pp::Graphics2D a(instance_, pp::Size(16, 0), false);
   if (!a.is_null())
     return "0 height accepted";
 
-  pp::Graphics2D b(pp::Size(0, 16), false);
+  pp::Graphics2D b(instance_, pp::Size(0, 16), false);
   if (!b.is_null())
     return "0 width accepted";
 
   // Need to use the C API since pp::Size prevents negative sizes.
   PP_Size size;
   size.width = 16;
   size.height = -16;
   ASSERT_FALSE(!!graphics_2d_interface_->Create(
       pp::Module::Get()->pp_module(), &size, PP_FALSE));
 
   size.width = -16;
   size.height = 16;
   ASSERT_FALSE(!!graphics_2d_interface_->Create(
       pp::Module::Get()->pp_module(), &size, PP_FALSE));
 
   return "";
 }
 
 std::string TestGraphics2D::TestHumongous() {
-  pp::Graphics2D a(pp::Size(100000, 100000), false);
+  pp::Graphics2D a(instance_, pp::Size(100000, 100000), false);
   if (!a.is_null())
     return "Humongous device created";
   return "";
 }
 
 std::string TestGraphics2D::TestInitToZero() {
   const int w = 15, h = 17;
-  pp::Graphics2D dc(pp::Size(w, h), false);
+  pp::Graphics2D dc(instance_, pp::Size(w, h), false);
   if (dc.is_null())
     return "Failure creating a boring device";
 
   // Make an image with nonzero data in it (so we can test that zeros were
   // actually read versus ReadImageData being a NOP).
-  pp::ImageData image(PP_IMAGEDATAFORMAT_BGRA_PREMUL, pp::Size(w, h), true);
+  pp::ImageData image(instance_, PP_IMAGEDATAFORMAT_BGRA_PREMUL,
+                      pp::Size(w, h), true);
   if (image.is_null())
     return "Failure to allocate an image";
   memset(image.data(), 0xFF, image.stride() * image.size().height() * 4);
 
   // Read out the initial data from the device & check.
   if (!ReadImageData(dc, &image, pp::Point(0, 0)))
     return "Couldn't read image data";
   if (!IsSquareInImage(image, 0, pp::Rect(0, 0, w, h), 0))
     return "Got a nonzero pixel";
 
   return "";
 }
 
 std::string TestGraphics2D::TestDescribe() {
   const int w = 15, h = 17;
-  pp::Graphics2D dc(pp::Size(w, h), false);
+  pp::Graphics2D dc(instance_, pp::Size(w, h), false);
   if (dc.is_null())
     return "Failure creating a boring device";
 
   PP_Size size;
   size.width = -1;
   size.height = -1;
   PP_Bool is_always_opaque = PP_TRUE;
   if (!graphics_2d_interface_->Describe(dc.pp_resource(), &size,
                                         &is_always_opaque))
     return "Describe failed";
   if (size.width != w || size.height != h || is_always_opaque != PP_FALSE)
     return "Mismatch of data.";
 
   return "";
 }
 
 std::string TestGraphics2D::TestPaint() {
   const int w = 15, h = 17;
-  pp::Graphics2D dc(pp::Size(w, h), false);
+  pp::Graphics2D dc(instance_, pp::Size(w, h), false);
   if (dc.is_null())
     return "Failure creating a boring device";
 
   // Make sure the device background is 0.
   if (!IsDCUniformColor(dc, 0))
     return "Bad initial color";
 
   // Fill the backing store with white.
   const uint32_t background_color = 0xFFFFFFFF;
-  pp::ImageData background(PP_IMAGEDATAFORMAT_BGRA_PREMUL, pp::Size(w, h),
-                           false);
+  pp::ImageData background(instance_, PP_IMAGEDATAFORMAT_BGRA_PREMUL,
+                           pp::Size(w, h), false);
   FillRectInImage(&background, pp::Rect(0, 0, w, h), background_color);
   dc.PaintImageData(background, pp::Point(0, 0));
   if (!FlushAndWaitForDone(&dc))
     return "Couldn't flush to fill backing store";
 
   // Make an image to paint with that's opaque white and enqueue a paint.
   const int fill_w = 2, fill_h = 3;
-  pp::ImageData fill(PP_IMAGEDATAFORMAT_BGRA_PREMUL, pp::Size(fill_w, fill_h),
-                     true);
+  pp::ImageData fill(instance_, PP_IMAGEDATAFORMAT_BGRA_PREMUL,
+                     pp::Size(fill_w, fill_h), true);
   if (fill.is_null())
     return "Failure to allocate fill image";
   FillRectInImage(&fill, pp::Rect(fill.size()), background_color);
   const int paint_x = 4, paint_y = 5;
   dc.PaintImageData(fill, pp::Point(paint_x, paint_y));
 
   // Validate that nothing has been actually painted.
   if (!IsDCUniformColor(dc, background_color))
     return "Image updated before flush (or failure in readback).";
 
@@ skipping 20 matching lines @@
                     pp::Rect(-second_paint_x, -second_paint_y, 1, 1));
   if (!FlushAndWaitForDone(&dc))
     return "Couldn't flush second paint";
 
   // Now we should have a little bit of the image peeking out the top left.
   if (!IsSquareInDC(dc, background_color, pp::Rect(0, 0, 1, 1),
                     fill_color))
     return "Partially offscreen paint failed.";
 
   // Now repaint that top left pixel by doing a subset of the source image.
-  pp::ImageData subset(PP_IMAGEDATAFORMAT_BGRA_PREMUL, pp::Size(w, h), false);
+  pp::ImageData subset(instance_, PP_IMAGEDATAFORMAT_BGRA_PREMUL,
+                       pp::Size(w, h), false);
   uint32_t subset_color = 0x80808080;
   const int subset_x = 2, subset_y = 1;
   *subset.GetAddr32(pp::Point(subset_x, subset_y)) = subset_color;
   dc.PaintImageData(subset, pp::Point(-subset_x, -subset_y),
                     pp::Rect(subset_x, subset_y, 1, 1));
   if (!FlushAndWaitForDone(&dc))
     return "Couldn't flush repaint";
   if (!IsSquareInDC(dc, background_color, pp::Rect(0, 0, 1, 1),
                     subset_color))
     return "Subset paint failed.";
 
   return "";
 }
 
 std::string TestGraphics2D::TestScroll() {
   const int w = 115, h = 117;
-  pp::Graphics2D dc(pp::Size(w, h), false);
+  pp::Graphics2D dc(instance_, pp::Size(w, h), false);
   if (dc.is_null())
     return "Failure creating a boring device.";
 
   // Make sure the device background is 0.
   if (!IsDCUniformColor(dc, 0))
     return "Bad initial color.";
 
   const int image_w = 15, image_h = 23;
-  pp::ImageData test_image(PP_IMAGEDATAFORMAT_BGRA_PREMUL,
+  pp::ImageData test_image(instance_, PP_IMAGEDATAFORMAT_BGRA_PREMUL,
                            pp::Size(image_w, image_h), false);
   FillImageWithGradient(&test_image);
 
   int image_x = 51, image_y = 72;
   dc.PaintImageData(test_image, pp::Point(image_x, image_y));
   if (!FlushAndWaitForDone(&dc))
     return "Couldn't flush to fill backing store.";
 
   // TC1, Scroll image to a free space.
   int dx = -40, dy = -48;
   pp::Rect clip = pp::Rect(image_x, image_y, test_image.size().width(),
                            test_image.size().height());
   dc.Scroll(clip, pp::Point(dx, dy));
 
   if (!FlushAndWaitForDone(&dc))
     return "TC1, Couldn't flush to scroll.";
 
   image_x += dx;
   image_y += dy;
 
-  pp::ImageData readback(PP_IMAGEDATAFORMAT_BGRA_PREMUL,
+  pp::ImageData readback(instance_, PP_IMAGEDATAFORMAT_BGRA_PREMUL,
                          pp::Size(image_w, image_h), false);
   if (!ReadImageData(dc, &readback, pp::Point(image_x, image_y)))
     return "TC1, Couldn't read back image data.";
 
   if (!CompareImages(test_image, readback))
     return "TC1, Read back image is not the same as test image.";
 
   // TC2, Scroll image to an overlapping space.
   dx = 6;
   dy = 9;
@@ skipping 11 matching lines @@
     return "TC2, Couldn't read back image data.";
 
   if (!CompareImages(test_image, readback))
     return "TC2, Read back image is not the same as test image.";
 
   return "";
 }
 
 std::string TestGraphics2D::TestReplace() {
   const int w = 15, h = 17;
-  pp::Graphics2D dc(pp::Size(w, h), false);
+  pp::Graphics2D dc(instance_, pp::Size(w, h), false);
   if (dc.is_null())
     return "Failure creating a boring device";
 
   // Replacing with a different size image should fail.
-  pp::ImageData weird_size(PP_IMAGEDATAFORMAT_BGRA_PREMUL,
+  pp::ImageData weird_size(instance_, PP_IMAGEDATAFORMAT_BGRA_PREMUL,
                            pp::Size(w - 1, h), true);
   if (weird_size.is_null())
     return "Failure allocating the weird sized image";
   dc.ReplaceContents(&weird_size);
 
   // Fill the background with blue but don't flush yet.
   const int32_t background_color = 0xFF0000FF;
-  pp::ImageData background(PP_IMAGEDATAFORMAT_BGRA_PREMUL, pp::Size(w, h),
-                           true);
+  pp::ImageData background(instance_, PP_IMAGEDATAFORMAT_BGRA_PREMUL,
+                           pp::Size(w, h), true);
   if (background.is_null())
     return "Failure to allocate background image";
   FillRectInImage(&background, pp::Rect(0, 0, w, h), background_color);
   dc.PaintImageData(background, pp::Point(0, 0));
 
   // Replace with a green background but don't flush yet.
   const int32_t swapped_color = 0xFF0000FF;
-  pp::ImageData swapped(PP_IMAGEDATAFORMAT_BGRA_PREMUL, pp::Size(w, h), true);
+  pp::ImageData swapped(instance_, PP_IMAGEDATAFORMAT_BGRA_PREMUL,
+                        pp::Size(w, h), true);
   if (swapped.is_null())
     return "Failure to allocate swapped image";
   FillRectInImage(&swapped, pp::Rect(0, 0, w, h), swapped_color);
   dc.ReplaceContents(&swapped);
 
   // The background should be unchanged since we didn't flush yet.
   if (!IsDCUniformColor(dc, 0))
     return "Image updated before flush (or failure in readback).";
 
   // Test the C++ wrapper. The size of the swapped image should be reset.
@@ skipping 12 matching lines @@
   if (!IsDCUniformColor(dc, swapped_color))
     return "Flushed color incorrect (or failure in readback).";
 
   return "";
 }
 
 std::string TestGraphics2D::TestFlush() {
   // Tests that synchronous flushes (NULL callback) fail on the main thread
   // (which is the current one).
   const int w = 15, h = 17;
-  pp::Graphics2D dc(pp::Size(w, h), false);
+  pp::Graphics2D dc(instance_, pp::Size(w, h), false);
   if (dc.is_null())
     return "Failure creating a boring device";
 
   // Fill the background with blue but don't flush yet.
-  pp::ImageData background(PP_IMAGEDATAFORMAT_BGRA_PREMUL, pp::Size(w, h),
-                           true);
+  pp::ImageData background(instance_, PP_IMAGEDATAFORMAT_BGRA_PREMUL,
+                           pp::Size(w, h), true);
   if (background.is_null())
     return "Failure to allocate background image";
   dc.PaintImageData(background, pp::Point(0, 0));
 
   int32_t rv = dc.Flush(pp::CompletionCallback::Block());
   if (rv == PP_OK || rv == PP_ERROR_WOULDBLOCK)
     return "Flush succeeded from the main thread with no callback.";
 
   // Test flushing with no operations still issues a callback.
   // (This may also hang if the browser never issues the callback).
-  pp::Graphics2D dc_nopaints(pp::Size(w, h), false);
+  pp::Graphics2D dc_nopaints(instance_, pp::Size(w, h), false);
   if (dc.is_null())
     return "Failure creating the nopaint device";
   if (!FlushAndWaitForDone(&dc_nopaints))
     return "Couldn't flush the nopaint device";
 
   // Test that multiple flushes fail if we don't get a callback in between.
   rv = dc_nopaints.Flush(pp::CompletionCallback(&FlushCallbackNOP, NULL));
   if (rv != PP_OK && rv != PP_ERROR_WOULDBLOCK)
     return "Couldn't flush first time for multiple flush test.";
 
   if (rv != PP_OK) {
     // If the first flush would block, then a second should fail.
     rv = dc_nopaints.Flush(pp::CompletionCallback(&FlushCallbackNOP, NULL));
     if (rv == PP_OK || rv == PP_ERROR_WOULDBLOCK)
       return "Second flush succeeded before callback ran.";
   }
 
   return "";
 }