PPAPI: More test cleanup

This removes the last usage of WaitForResult and force_async_, so removes them
as well.

BUG=

Review URL: https://codereview.chromium.org/14139012

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@194364 0039d316-1c4b-4281-b951-d872f2087c98

17 files changed, 391 insertions, 606 deletions

diff --git a/ppapi/tests/test_case.h b/ppapi/tests/test_case.h
index 7457c3a..2c81774 100644
--- a/ppapi/tests/test_case.h
+++ b/ppapi/tests/test_case.h
@@ -159,14 +159,8 @@ class TestCase {
   // NULL unless InitTestingInterface is called.
   const PPB_Testing_Dev* testing_interface_;
 
-  // TODO(dmichael): Remove this, it's for temporary backwards compatibility so
-  // I don't have to change all the tests at once.
-  bool force_async_;
-
   void set_callback_type(CallbackType callback_type) {
     callback_type_ = callback_type;
-    // TODO(dmichael): Remove this; see comment on force_async_.
-    force_async_ = (callback_type_ == PP_REQUIRED);
   }
   CallbackType callback_type() const {
     return callback_type_;
@@ -376,6 +370,10 @@ class TestCaseFactory {
 #define ASSERT_FALSE(cmd) ASSERT_TRUE(!(cmd))
 #define ASSERT_EQ(a, b) ASSERT_TRUE((a) == (b))
 #define ASSERT_NE(a, b) ASSERT_TRUE((a) != (b))
+#define ASSERT_LT(a, b) ASSERT_TRUE((a) < (b))
+#define ASSERT_LE(a, b) ASSERT_TRUE((a) <= (b))
+#define ASSERT_GT(a, b) ASSERT_TRUE((a) > (b))
+#define ASSERT_GE(a, b) ASSERT_TRUE((a) >= (b))
 
 #define ASSERT_DOUBLE_EQ(a, b) ASSERT_TRUE( \
     std::fabs((a)-(b)) <= std::numeric_limits<double>::epsilon())
diff --git a/ppapi/tests/test_file_system.cc b/ppapi/tests/test_file_system.cc
index 9601f54..9a2d712 100644
--- a/ppapi/tests/test_file_system.cc
+++ b/ppapi/tests/test_file_system.cc
@@ -18,12 +18,12 @@ bool TestFileSystem::Init() {
 }
 
 void TestFileSystem::RunTests(const std::string& filter) {
-  RUN_TEST_FORCEASYNC_AND_NOT(Open, filter);
-  RUN_TEST_FORCEASYNC_AND_NOT(MultipleOpens, filter);
+  RUN_CALLBACK_TEST(TestFileSystem, Open, filter);
+  RUN_CALLBACK_TEST(TestFileSystem, MultipleOpens, filter);
 }
 
 std::string TestFileSystem::TestOpen() {
-  TestCompletionCallback callback(instance_->pp_instance(), force_async_);
+  TestCompletionCallback callback(instance_->pp_instance(), callback_type());
 
   // Open.
   pp::FileSystem file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
@@ -46,11 +46,11 @@ std::string TestFileSystem::TestOpen() {
 std::string TestFileSystem::TestMultipleOpens() {
   // Should not allow multiple opens, regardless of whether or not the first
   // open has completed.
-  TestCompletionCallback callback_1(instance_->pp_instance(), force_async_);
+  TestCompletionCallback callback_1(instance_->pp_instance(), callback_type());
   pp::FileSystem file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
   int32_t rv_1 = file_system.Open(1024, callback_1.GetCallback());
 
-  TestCompletionCallback callback_2(instance_->pp_instance(), force_async_);
+  TestCompletionCallback callback_2(instance_->pp_instance(), callback_type());
   callback_2.WaitForResult(file_system.Open(1024, callback_2.GetCallback()));
   CHECK_CALLBACK_BEHAVIOR(callback_2);
   // FileSystem should not allow multiple opens.
@@ -60,7 +60,7 @@ std::string TestFileSystem::TestMultipleOpens() {
   CHECK_CALLBACK_BEHAVIOR(callback_1);
   ASSERT_EQ(PP_OK, callback_1.result());
 
-  TestCompletionCallback callback_3(instance_->pp_instance(), force_async_);
+  TestCompletionCallback callback_3(instance_->pp_instance(), callback_type());
   callback_3.WaitForResult(file_system.Open(1024, callback_3.GetCallback()));
   CHECK_CALLBACK_BEHAVIOR(callback_3);
   ASSERT_NE(PP_OK, callback_3.result());
diff --git a/ppapi/tests/test_graphics_2d.cc b/ppapi/tests/test_graphics_2d.cc
index 14ed49a..7377736 100644
--- a/ppapi/tests/test_graphics_2d.cc
+++ b/ppapi/tests/test_graphics_2d.cc
@@ -36,6 +36,20 @@ void FlushCallbackQuitMessageLoop(void* data, int32_t result) {
   static_cast<TestGraphics2D*>(data)->QuitMessageLoop();
 }
 
+bool CanFlushContext(pp::Instance* instance, pp::Graphics2D* context) {
+  TestCompletionCallback callback(instance->pp_instance());
+  callback.WaitForResult(context->Flush(callback.GetCallback()));
+  return (callback.result() == PP_OK);
+}
+
+bool CanFlushContextC(pp::Instance* instance, PP_Resource graphics_2d,
+                      const PPB_Graphics2D_1_1* graphics_2d_if) {
+  TestCompletionCallback callback(instance->pp_instance());
+  callback.WaitForResult(graphics_2d_if->Flush(
+      graphics_2d, callback.GetCallback().pp_completion_callback()));
+  return (callback.result() == PP_OK);
+}
+
 }  // namespace
 
 TestGraphics2D::TestGraphics2D(TestingInstance* instance)
@@ -46,9 +60,9 @@ TestGraphics2D::TestGraphics2D(TestingInstance* instance)
 
 bool TestGraphics2D::Init() {
   graphics_2d_interface_ = static_cast<const PPB_Graphics2D*>(
-      pp::Module::Get()->GetBrowserInterface(PPB_GRAPHICS_2D_INTERFACE));
+      pp::Module::Get()->GetBrowserInterface(PPB_GRAPHICS_2D_INTERFACE_1_1));
   image_data_interface_ = static_cast<const PPB_ImageData*>(
-      pp::Module::Get()->GetBrowserInterface(PPB_IMAGEDATA_INTERFACE));
+      pp::Module::Get()->GetBrowserInterface(PPB_IMAGEDATA_INTERFACE_1_0));
   return graphics_2d_interface_ && image_data_interface_ &&
          CheckTestingInterface();
 }
@@ -94,41 +108,12 @@ bool TestGraphics2D::IsDCUniformColor(const pp::Graphics2D& dc,
   return IsSquareInImage(readback, 0, pp::Rect(dc.size()), color);
 }
 
-bool TestGraphics2D::ResourceHealthCheck(pp::Instance* instance,
-                                         pp::Graphics2D* context) {
-  TestCompletionCallback callback(instance->pp_instance(), callback_type());
+std::string TestGraphics2D::FlushAndWaitForDone(pp::Graphics2D* context) {
+  TestCompletionCallback callback(instance_->pp_instance(), callback_type());
   callback.WaitForResult(context->Flush(callback.GetCallback()));
-  if (callback.result() < 0)
-    return callback.result() != PP_ERROR_FAILED;
-  else if (callback.result() == 0)
-    return false;
-  return true;
-}
-
-bool TestGraphics2D::ResourceHealthCheckForC(pp::Instance* instance,
-                                             PP_Resource graphics_2d) {
-  TestCompletionCallback callback(instance->pp_instance(), callback_type());
-  callback.WaitForResult(graphics_2d_interface_->Flush(
-      graphics_2d, callback.GetCallback().pp_completion_callback()));
-  if (callback.result() < 0)
-    return callback.result() != PP_ERROR_FAILED;
-  else if (callback.result() == 0)
-    return false;
-  return true;
-}
-
-bool TestGraphics2D::FlushAndWaitForDone(pp::Graphics2D* context) {
-  int32_t flags = (force_async_ ? 0 : PP_COMPLETIONCALLBACK_FLAG_OPTIONAL);
-  pp::CompletionCallback cc(&FlushCallbackQuitMessageLoop, this, flags);
-  int32_t rv = context->Flush(cc);
-  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
-    return false;
-  if (rv == PP_OK)
-    return true;
-  if (rv != PP_OK_COMPLETIONPENDING)
-    return false;
-  testing_interface_->RunMessageLoop(instance_->pp_instance());
-  return true;
+  CHECK_CALLBACK_BEHAVIOR(callback);
+  ASSERT_EQ(PP_OK, callback.result());
+  PASS();
 }
 
 void TestGraphics2D::FillRectInImage(pp::ImageData* image,
@@ -218,7 +203,8 @@ PP_Resource TestGraphics2D::ReplaceContentsAndReturnID(
   PP_Resource id = image.pp_resource();
 
   dc->ReplaceContents(&image);
-  if (!FlushAndWaitForDone(dc))
+  std::string result = FlushAndWaitForDone(dc);
+  if (!result.empty())
     return 0;
 
   return id;
@@ -264,36 +250,33 @@ std::string TestGraphics2D::TestInvalidResource() {
                                           image.pp_resource());
 
   // Flush.
-  if (graphics_2d_interface_->Flush(
-          image.pp_resource(),
-          PP_MakeOptionalCompletionCallback(&FlushCallbackNOP, NULL)) == PP_OK)
-    return "Flush succeeded with a different resource";
-  if (graphics_2d_interface_->Flush(
-          null_context.pp_resource(),
-          PP_MakeOptionalCompletionCallback(&FlushCallbackNOP, NULL)) == PP_OK)
-    return "Flush succeeded with a NULL resource";
+  TestCompletionCallback cb(instance_->pp_instance(), PP_OPTIONAL);
+  cb.WaitForResult(
+      graphics_2d_interface_->Flush(image.pp_resource(),
+                                    cb.GetCallback().pp_completion_callback()));
+  ASSERT_EQ(PP_ERROR_BADRESOURCE, cb.result());
+  cb.WaitForResult(
+      graphics_2d_interface_->Flush(null_context.pp_resource(),
+                                    cb.GetCallback().pp_completion_callback()));
+  ASSERT_EQ(PP_ERROR_BADRESOURCE, cb.result());
 
   // ReadImageData.
-  if (testing_interface_->ReadImageData(image.pp_resource(),
-                                        image.pp_resource(),
-                                        &zero_zero))
-    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";
+  ASSERT_FALSE(testing_interface_->ReadImageData(image.pp_resource(),
+                                                 image.pp_resource(),
+                                                 &zero_zero));
+  ASSERT_FALSE(testing_interface_->ReadImageData(null_context.pp_resource(),
+                                                 image.pp_resource(),
+                                                 &zero_zero));
 
   PASS();
 }
 
 std::string TestGraphics2D::TestInvalidSize() {
   pp::Graphics2D a(instance_, pp::Size(16, 0), false);
-  if (ResourceHealthCheck(instance_, &a))
-    return "0 height accepted";
+  ASSERT_FALSE(CanFlushContext(instance_, &a));
 
   pp::Graphics2D b(instance_, pp::Size(0, 16), false);
-  if (ResourceHealthCheck(instance_, &b))
-    return "0 height accepted";
+  ASSERT_FALSE(CanFlushContext(instance_, &b));
 
   // Need to use the C API since pp::Size prevents negative sizes.
   PP_Size size;
@@ -301,50 +284,48 @@ std::string TestGraphics2D::TestInvalidSize() {
   size.height = -16;
   PP_Resource graphics = graphics_2d_interface_->Create(
       instance_->pp_instance(), &size, PP_FALSE);
-  ASSERT_FALSE(ResourceHealthCheckForC(instance_, graphics));
+  ASSERT_FALSE(CanFlushContextC(instance_, graphics, graphics_2d_interface_));
+  pp::Module::Get()->core()->ReleaseResource(graphics);
 
   size.width = -16;
   size.height = 16;
   graphics = graphics_2d_interface_->Create(
       instance_->pp_instance(), &size, PP_FALSE);
-  ASSERT_FALSE(ResourceHealthCheckForC(instance_, graphics));
+  ASSERT_FALSE(CanFlushContextC(instance_, graphics, graphics_2d_interface_));
+  pp::Module::Get()->core()->ReleaseResource(graphics);
 
   // Overflow to negative size
   size.width = std::numeric_limits<int32_t>::max();
   size.height = std::numeric_limits<int32_t>::max();
   graphics = graphics_2d_interface_->Create(
       instance_->pp_instance(), &size, PP_FALSE);
-  ASSERT_FALSE(ResourceHealthCheckForC(instance_, graphics));
+  ASSERT_FALSE(CanFlushContextC(instance_, graphics, graphics_2d_interface_));
+  pp::Module::Get()->core()->ReleaseResource(graphics);
 
   PASS();
 }
 
 std::string TestGraphics2D::TestHumongous() {
   pp::Graphics2D a(instance_, pp::Size(100000, 100000), false);
-  if (ResourceHealthCheck(instance_, &a))
-    return "Humongous device created";
+  ASSERT_FALSE(CanFlushContext(instance_, &a));
   PASS();
 }
 
 std::string TestGraphics2D::TestInitToZero() {
   const int w = 15, h = 17;
   pp::Graphics2D dc(instance_, pp::Size(w, h), false);
-  if (dc.is_null())
-    return "Failure creating a boring device";
+  ASSERT_FALSE(dc.is_null());
 
   // 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(instance_, PP_IMAGEDATAFORMAT_BGRA_PREMUL,
                       pp::Size(w, h), true);
-  if (image.is_null())
-    return "Failure to allocate an image";
+  ASSERT_FALSE(image.is_null());
   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";
+  ASSERT_TRUE(ReadImageData(dc, &image, pp::Point(0, 0)));
+  ASSERT_TRUE(IsSquareInImage(image, 0, pp::Rect(0, 0, w, h), 0));
 
   PASS();
 }
@@ -353,19 +334,17 @@ std::string TestGraphics2D::TestDescribe() {
   const int w = 15, h = 17;
   const bool always_opaque = (::rand() % 2 == 1);
   pp::Graphics2D dc(instance_, pp::Size(w, h), always_opaque);
-  if (dc.is_null())
-    return "Failure creating a boring device";
+  ASSERT_FALSE(dc.is_null());
 
   PP_Size size;
   size.width = -1;
   size.height = -1;
   PP_Bool is_always_opaque = PP_FALSE;
-  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_FromBool(always_opaque))
-    return "Mismatch of data.";
+  ASSERT_TRUE(graphics_2d_interface_->Describe(dc.pp_resource(), &size,
+                                               &is_always_opaque));
+  ASSERT_EQ(w, size.width);
+  ASSERT_EQ(h, size.height);
+  ASSERT_EQ(PP_FromBool(always_opaque), is_always_opaque);
 
   PASS();
 }
@@ -375,22 +354,15 @@ std::string TestGraphics2D::TestScale() {
   const int w = 20, h = 16;
   const float scale = 1.0f/2.0f;
   pp::Graphics2D dc(instance_, pp::Size(w, h), false);
-  if (dc.is_null())
-    return "Failure creating a boring device";
-  if (dc.GetScale() != 1.0f)
-    return "GetScale returned unexpected value before SetScale";
-  if (!dc.SetScale(scale))
-    return "SetScale failed";
-  if (dc.GetScale() != scale)
-    return "GetScale mismatch with prior SetScale";
+  ASSERT_FALSE(dc.is_null());
+  ASSERT_EQ(1.0,  dc.GetScale());
+  ASSERT_TRUE(dc.SetScale(scale));
+  ASSERT_EQ(scale, dc.GetScale());
   // Try setting a few invalid scale factors. Ensure that we catch these errors
   // and don't change the actual scale
-  if (dc.SetScale(-1.0f))
-    return "SetScale(-1f) did not fail";
-  if (dc.SetScale(0.0f))
-    return "SetScale(0.0f) did not fail";
-  if (dc.GetScale() != scale)
-    return "SetScale with invalid parameter overwrote the scale";
+  ASSERT_FALSE(dc.SetScale(-1.0f));
+  ASSERT_FALSE(dc.SetScale(0.0f));
+  ASSERT_EQ(scale, dc.GetScale());
 
   // Verify that the context has the specified number of pixels, despite the
   // non-identity scale
@@ -398,12 +370,11 @@ std::string TestGraphics2D::TestScale() {
   size.width = -1;
   size.height = -1;
   PP_Bool is_always_opaque = PP_FALSE;
-  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_FromBool(false))
-    return "Mismatch of data.";
+  ASSERT_TRUE(graphics_2d_interface_->Describe(dc.pp_resource(), &size,
+                                               &is_always_opaque));
+  ASSERT_EQ(w, size.width);
+  ASSERT_EQ(h, size.height);
+  ASSERT_EQ(PP_FALSE, is_always_opaque);
 
   PASS();
 }
@@ -411,12 +382,10 @@ std::string TestGraphics2D::TestScale() {
 std::string TestGraphics2D::TestPaint() {
   const int w = 15, h = 17;
   pp::Graphics2D dc(instance_, pp::Size(w, h), false);
-  if (dc.is_null())
-    return "Failure creating a boring device";
+  ASSERT_FALSE(dc.is_null());
 
   // Make sure the device background is 0.
-  if (!IsDCUniformColor(dc, 0))
-    return "Bad initial color";
+  ASSERT_TRUE(IsDCUniformColor(dc, 0));
 
   // Fill the backing store with white.
   const uint32_t background_color = 0xFFFFFFFF;
@@ -424,35 +393,30 @@ std::string TestGraphics2D::TestPaint() {
                            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";
+  ASSERT_SUBTEST_SUCCESS(FlushAndWaitForDone(&dc));
 
   // 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(instance_, PP_IMAGEDATAFORMAT_BGRA_PREMUL,
                      pp::Size(fill_w, fill_h), true);
-  if (fill.is_null())
-    return "Failure to allocate fill image";
+  ASSERT_FALSE(fill.is_null());
   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).";
+  ASSERT_TRUE(IsDCUniformColor(dc, background_color));
 
   // The paint hasn't been flushed so we can still change the bitmap. Fill with
   // 50% blue. This will also verify that the backing store is replaced
   // with the contents rather than blended.
   const uint32_t fill_color = 0x80000080;
   FillRectInImage(&fill, pp::Rect(fill.size()), fill_color);
-  if (!FlushAndWaitForDone(&dc))
-    return "Couldn't flush 50% blue paint";
+  ASSERT_SUBTEST_SUCCESS(FlushAndWaitForDone(&dc));
 
-  if (!IsSquareInDC(dc, background_color,
-                    pp::Rect(paint_x, paint_y, fill_w, fill_h),
-                    fill_color))
-    return "Image not painted properly.";
+  ASSERT_TRUE(IsSquareInDC(dc, background_color,
+                           pp::Rect(paint_x, paint_y, fill_w, fill_h),
+                           fill_color));
 
   // Reset the DC to blank white & paint our image slightly off the buffer.
   // This should succeed. We also try painting the same thing where the
@@ -462,13 +426,11 @@ std::string TestGraphics2D::TestPaint() {
   dc.PaintImageData(fill, pp::Point(second_paint_x, second_paint_y));
   dc.PaintImageData(fill, pp::Point(second_paint_x, second_paint_y),
                     pp::Rect(-second_paint_x, -second_paint_y, 1, 1));
-  if (!FlushAndWaitForDone(&dc))
-    return "Couldn't flush second paint";
+  ASSERT_SUBTEST_SUCCESS(FlushAndWaitForDone(&dc));
 
   // 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.";
+  ASSERT_TRUE(IsSquareInDC(dc, background_color, pp::Rect(0, 0, 1, 1),
+                           fill_color));
 
   // Now repaint that top left pixel by doing a subset of the source image.
   pp::ImageData subset(instance_, PP_IMAGEDATAFORMAT_BGRA_PREMUL,
@@ -478,11 +440,9 @@ std::string TestGraphics2D::TestPaint() {
   *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.";
+  ASSERT_SUBTEST_SUCCESS(FlushAndWaitForDone(&dc));
+  ASSERT_TRUE(IsSquareInDC(dc, background_color, pp::Rect(0, 0, 1, 1),
+                           subset_color));
 
   PASS();
 }
@@ -490,14 +450,11 @@ std::string TestGraphics2D::TestPaint() {
 std::string TestGraphics2D::TestScroll() {
   const int w = 115, h = 117;
   pp::Graphics2D dc(instance_, pp::Size(w, h), false);
-  if (dc.is_null())
-    return "Failure creating a boring device.";
-  if (!instance_->BindGraphics(dc))
-    return "Failure to bind the boring device.";
+  ASSERT_FALSE(dc.is_null());
+  ASSERT_TRUE(instance_->BindGraphics(dc));
 
   // Make sure the device background is 0.
-  if (!IsDCUniformColor(dc, 0))
-    return "Bad initial color.";
+  ASSERT_TRUE(IsDCUniformColor(dc, 0));
 
   const int image_width = 15, image_height = 23;
   pp::ImageData test_image(instance_, PP_IMAGEDATAFORMAT_BGRA_PREMUL,
@@ -511,13 +468,11 @@ std::string TestGraphics2D::TestScroll() {
   pp::ImageData readback_scroll(instance_, PP_IMAGEDATAFORMAT_BGRA_PREMUL,
                                 pp::Size(image_width, image_height), false);
 
-  if (test_image.size() != pp::Size(image_width, image_height))
-    return "Wrong test image size\n";
+  ASSERT_EQ(pp::Size(image_width, image_height), test_image.size());
 
   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.";
+  ASSERT_SUBTEST_SUCCESS(FlushAndWaitForDone(&dc));
 
   // Test Case 1. Incorrect usage when scrolling image to a free space.
   // The clip area is *not* the area to shift around within the graphics device
@@ -528,12 +483,10 @@ std::string TestGraphics2D::TestScroll() {
   int scroll_x = image_x + dx, scroll_y = image_y + dy;
   pp::Rect clip(image_x, image_y, image_width, image_height);
   dc.Scroll(clip, pp::Point(dx, dy));
-  if (!FlushAndWaitForDone(&dc))
-    return "TC1, Couldn't flush to scroll.";
-  if (!ReadImageData(dc, &readback_scroll, pp::Point(scroll_x, scroll_y)))
-    return "TC1, Couldn't read back scrolled image data.";
-  if (!CompareImages(no_image, readback_scroll))
-    return "TC1, Read back scrolled image is not the same as no image.";
+  ASSERT_SUBTEST_SUCCESS(FlushAndWaitForDone(&dc));
+  ASSERT_TRUE(
+      ReadImageData(dc, &readback_scroll, pp::Point(scroll_x, scroll_y)));
+  ASSERT_TRUE(CompareImages(no_image, readback_scroll));
 
   // Test Case 2.
   // The amount is intended to place the image in the free space outside
@@ -542,12 +495,10 @@ std::string TestGraphics2D::TestScroll() {
   scroll_x = 11, scroll_y = 24;
   clip = pp::Rect(0, 0, w, h + 1);
   dc.Scroll(clip, pp::Point(scroll_x - image_x, scroll_y - image_y));
-  if (!FlushAndWaitForDone(&dc))
-    return "TC2, Couldn't flush to scroll.";
-  if (!ReadImageData(dc, &readback_scroll, pp::Point(scroll_x, scroll_y)))
-    return "TC2, Couldn't read back scrolled image data.";
-  if (!CompareImages(no_image, readback_scroll))
-    return "TC2, Read back scrolled image is not the same as no image.";
+  ASSERT_SUBTEST_SUCCESS(FlushAndWaitForDone(&dc));
+  ASSERT_TRUE(
+      ReadImageData(dc, &readback_scroll, pp::Point(scroll_x, scroll_y)));
+  ASSERT_TRUE(CompareImages(no_image, readback_scroll));
 
   // Test Case 3.
   // The amount is intended to place the image in the free space outside
@@ -556,12 +507,10 @@ std::string TestGraphics2D::TestScroll() {
   scroll_x = 11, scroll_y = 24;
   clip = pp::Rect(0, 0, image_x, image_y);
   dc.Scroll(clip, pp::Point(scroll_x - image_x, scroll_y - image_y));
-  if (!FlushAndWaitForDone(&dc))
-    return "TC3, Couldn't flush to scroll.";
-  if (!ReadImageData(dc, &readback_scroll, pp::Point(scroll_x, scroll_y)))
-    return "TC3, Couldn't read back scrolled image data.";
-  if (!CompareImages(no_image, readback_scroll))
-    return "TC3, Read back scrolled image is not the same as no image.";
+  ASSERT_SUBTEST_SUCCESS(FlushAndWaitForDone(&dc));
+  ASSERT_TRUE(
+      ReadImageData(dc, &readback_scroll, pp::Point(scroll_x, scroll_y)));
+  ASSERT_TRUE(CompareImages(no_image, readback_scroll));
 
   // Test Case 4.
   // Same as TC3, but the clip covers part of the image.
@@ -569,36 +518,30 @@ std::string TestGraphics2D::TestScroll() {
   int part_w = image_width / 2, part_h = image_height / 2;
   clip = pp::Rect(0, 0, image_x + part_w, image_y + part_h);
   dc.Scroll(clip, pp::Point(scroll_x - image_x, scroll_y - image_y));
-  if (!FlushAndWaitForDone(&dc))
-    return "TC4, Couldn't flush to scroll.";
-  if (!ReadImageData(dc, &readback_scroll, pp::Point(scroll_x, scroll_y)))
-    return "TC4, Couldn't read back scrolled image data.";
-  if (CompareImages(test_image, readback_scroll))
-    return "TC4, Read back scrolled image is the same as test image.";
+  ASSERT_SUBTEST_SUCCESS(FlushAndWaitForDone(&dc));
+  ASSERT_TRUE(
+      ReadImageData(dc, &readback_scroll, pp::Point(scroll_x, scroll_y)));
+  ASSERT_FALSE(CompareImages(test_image, readback_scroll));
   pp::Rect part_rect(part_w, part_h);
-  if (!CompareImageRect(test_image, part_rect, readback_scroll, part_rect))
-    return "TC4, Read back scrolled image is not the same as part test image.";
+  ASSERT_TRUE(
+      CompareImageRect(test_image, part_rect, readback_scroll, part_rect));
 
   // Test Case 5
   // Same as TC3, but the clip area covers the entire image.
   // It will be scrolled to the intended origin.
   clip = pp::Rect(0, 0, image_x + image_width, image_y + image_height);
   dc.Scroll(clip, pp::Point(scroll_x - image_x, scroll_y - image_y));
-  if (!FlushAndWaitForDone(&dc))
-    return "TC5, Couldn't flush to scroll.";
-  if (!ReadImageData(dc, &readback_scroll, pp::Point(scroll_x, scroll_y)))
-    return "TC5, Couldn't read back scrolled image data.";
-  if (!CompareImages(test_image, readback_scroll))
-    return "TC5, Read back scrolled image is not the same as test image.";
+  ASSERT_SUBTEST_SUCCESS(FlushAndWaitForDone(&dc));
+  ASSERT_TRUE(
+      ReadImageData(dc, &readback_scroll, pp::Point(scroll_x, scroll_y)));
+  ASSERT_TRUE(CompareImages(test_image, readback_scroll));
 
   // Note that the undefined area left by the scroll does not actually get
   // cleared, so the original image is still there. This is not guaranteed and
   // is not something for users to rely on, but we can test for this here, so
   // we know when the underlying behavior changes.
-  if (!ReadImageData(dc, &readback_image, pp::Point(image_x, image_y)))
-    return "Couldn't read back original image data.";
-  if (!CompareImages(test_image, readback_image))
-    return "Read back original image is not the same as test image.";
+  ASSERT_TRUE(ReadImageData(dc, &readback_image, pp::Point(image_x, image_y)));
+  ASSERT_TRUE(CompareImages(test_image, readback_image));
 
   // Test Case 6.
   // Scroll image to an overlapping space. The clip area is limited
@@ -609,17 +552,14 @@ std::string TestGraphics2D::TestScroll() {
   scroll_y = image_y + dy;
   clip = pp::Rect(image_x, image_y, image_width, image_height);
   dc.Scroll(clip, pp::Point(dx, dy));
-  if (!FlushAndWaitForDone(&dc))
-    return "TC6, Couldn't flush to scroll.";
-  if (!ReadImageData(dc, &readback_image, pp::Point(image_x, image_y)))
-    return "TC6, Couldn't read back image data.";
-  if (CompareImages(test_image, readback_image))
-    return "TC6, Read back image is still the same as test image.";
+  ASSERT_SUBTEST_SUCCESS(FlushAndWaitForDone(&dc));
+  ASSERT_TRUE(ReadImageData(dc, &readback_image, pp::Point(image_x, image_y)));
+  ASSERT_FALSE(CompareImages(test_image, readback_image));
   pp::Rect scroll_rect(image_width - dx, image_height - dy);
-  if (!ReadImageData(dc, &readback_scroll, pp::Point(scroll_x, scroll_y)))
-    return "TC6, Couldn't read back scrolled image data.";
-  if (!CompareImageRect(test_image, scroll_rect, readback_scroll, scroll_rect))
-    return "TC6, Read back scrolled image is not the same as part test image.";
+  ASSERT_TRUE(
+      ReadImageData(dc, &readback_scroll, pp::Point(scroll_x, scroll_y)));
+  ASSERT_TRUE(
+      CompareImageRect(test_image, scroll_rect, readback_scroll, scroll_rect));
 
   PASS();
 }
@@ -627,22 +567,19 @@ std::string TestGraphics2D::TestScroll() {
 std::string TestGraphics2D::TestReplace() {
   const int w = 15, h = 17;
   pp::Graphics2D dc(instance_, pp::Size(w, h), false);
-  if (dc.is_null())
-    return "Failure creating a boring device";
+  ASSERT_FALSE(dc.is_null());
 
   // Replacing with a different size image should fail.
   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";
+  ASSERT_FALSE(weird_size.is_null());
   dc.ReplaceContents(&weird_size);
 
   // Fill the background with blue but don't flush yet.
   const int32_t background_color = 0xFF0000FF;
   pp::ImageData background(instance_, PP_IMAGEDATAFORMAT_BGRA_PREMUL,
                            pp::Size(w, h), true);
-  if (background.is_null())
-    return "Failure to allocate background image";
+  ASSERT_FALSE(background.is_null());
   FillRectInImage(&background, pp::Rect(0, 0, w, h), background_color);
   dc.PaintImageData(background, pp::Point(0, 0));
 
@@ -650,30 +587,25 @@ std::string TestGraphics2D::TestReplace() {
   const int32_t swapped_color = 0x00FF00FF;
   pp::ImageData swapped(instance_, PP_IMAGEDATAFORMAT_BGRA_PREMUL,
                         pp::Size(w, h), true);
-  if (swapped.is_null())
-    return "Failure to allocate swapped image";
+  ASSERT_FALSE(swapped.is_null());
   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).";
+  ASSERT_TRUE(IsDCUniformColor(dc, 0));
 
   // Test the C++ wrapper. The size of the swapped image should be reset.
-  if (swapped.pp_resource() || swapped.size().width() ||
-      swapped.size().height() || swapped.data())
-    return "Size of the swapped image should be reset.";
+  ASSERT_TRUE(!swapped.pp_resource() && !swapped.size().width() &&
+              !swapped.size().height() && !swapped.data());
 
   // Painting with the swapped image should fail.
   dc.PaintImageData(swapped, pp::Point(0, 0));
 
   // Flush and make sure the result is correct.
-  if (!FlushAndWaitForDone(&dc))
-    return "Couldn't flush";
+  ASSERT_SUBTEST_SUCCESS(FlushAndWaitForDone(&dc));
 
   // The background should be green from the swapped image.
-  if (!IsDCUniformColor(dc, swapped_color))
-    return "Flushed color incorrect (or failure in readback).";
+  ASSERT_TRUE(IsDCUniformColor(dc, swapped_color));
 
   PASS();
 }
@@ -683,50 +615,37 @@ std::string TestGraphics2D::TestFlush() {
   // (which is the current one).
   const int w = 15, h = 17;
   pp::Graphics2D dc(instance_, pp::Size(w, h), false);
-  if (dc.is_null())
-    return "Failure creating a boring device";
+  ASSERT_FALSE(dc.is_null());
 
   // Fill the background with blue but don't flush yet.
   pp::ImageData background(instance_, PP_IMAGEDATAFORMAT_BGRA_PREMUL,
                            pp::Size(w, h), true);
-  if (background.is_null())
-    return "Failure to allocate background image";
+  ASSERT_FALSE(background.is_null());
   dc.PaintImageData(background, pp::Point(0, 0));
 
   int32_t rv = dc.Flush(pp::BlockUntilComplete());
-  if (rv == PP_OK || rv == PP_OK_COMPLETIONPENDING)
-    return "Flush succeeded from the main thread with no callback.";
+  ASSERT_EQ(PP_ERROR_BLOCKS_MAIN_THREAD, rv);
 
   // Test flushing with no operations still issues a callback.
   // (This may also hang if the browser never issues the callback).
   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";
+  ASSERT_FALSE(dc.is_null());
+  ASSERT_SUBTEST_SUCCESS(FlushAndWaitForDone(&dc_nopaints));
 
-  int32_t flags = (force_async_ ? 0 : PP_COMPLETIONCALLBACK_FLAG_OPTIONAL);
+  TestCompletionCallback callback_1(instance_->pp_instance(), callback_type());
 
   // Test that multiple flushes fail if we don't get a callback in between.
-  rv = dc_nopaints.Flush(pp::CompletionCallback(&FlushCallbackNOP, NULL,
-                                                flags));
-  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
-    return "Flush must complete asynchronously.";
-  if (rv != PP_OK && rv != PP_OK_COMPLETIONPENDING)
-    return "Couldn't flush first time for multiple flush test.";
-
+  rv = dc_nopaints.Flush(callback_1.GetCallback());
   if (rv == PP_OK_COMPLETIONPENDING) {
     // If the first flush completes asynchronously, then a second should fail.
-    rv = dc_nopaints.Flush(pp::CompletionCallback(&FlushCallbackNOP, NULL,
-                                                  flags));
-    if (force_async_) {
-      if (rv != PP_OK_COMPLETIONPENDING)
-        return "Second flush must fail asynchronously.";
-    } else {
-      if (rv == PP_OK || rv == PP_OK_COMPLETIONPENDING)
-        return "Second flush succeeded before callback ran.";
-    }
+    TestCompletionCallback callback_2(instance_->pp_instance(),
+                                      callback_type());
+    callback_2.WaitForResult(dc_nopaints.Flush(callback_2.GetCallback()));
+    CHECK_CALLBACK_BEHAVIOR(callback_2);
+    ASSERT_EQ(PP_ERROR_INPROGRESS, callback_2.result());
   }
+  callback_1.WaitForResult(rv);
+  ASSERT_EQ(PP_OK, callback_1.result());
 
   PASS();
 }
@@ -763,10 +682,8 @@ std::string TestGraphics2D::TestFlushOffscreenUpdate() {
   const PP_Time kFlushDelaySec = 1. / 30;  // 30 fps
   const int w = 80, h = 80;
   pp::Graphics2D dc(instance_, pp::Size(w, h), true);
-  if (dc.is_null())
-    return "Failure creating a boring device";
-  if (!instance_->BindGraphics(dc))
-    return "Failure to bind the boring device.";
+  ASSERT_FALSE(dc.is_null());
+  ASSERT_TRUE(instance_->BindGraphics(dc));
 
   // Squeeze from top until bottom half of plugin is out of screen.
   ResetViewChangedState();
@@ -777,14 +694,12 @@ std::string TestGraphics2D::TestFlushOffscreenUpdate() {
       "big.setAttribute('id', 'big-div');"
       "big.setAttribute('style', 'height: ' + offset + '; width: 100%;');"
       "document.body.insertBefore(big, document.body.firstChild);");
-  if (!WaitUntilViewChanged())
-    return "View didn't change as expected";
+  ASSERT_TRUE(WaitUntilViewChanged());
 
   // Allocate a red image chunk
   pp::ImageData chunk(instance_, PP_IMAGEDATAFORMAT_RGBA_PREMUL,
                       pp::Size(w/8, h/8), true);
-  if (chunk.is_null())
-    return "Failure to allocate image";
+  ASSERT_FALSE(chunk.is_null());
   const uint32_t kRed = 0xff0000ff;
   FillRectInImage(&chunk, pp::Rect(chunk.size()), kRed);
 
@@ -792,21 +707,18 @@ std::string TestGraphics2D::TestFlushOffscreenUpdate() {
   dc.PaintImageData(chunk, pp::Point(0, h*0.75));
 
   PP_Time begin = pp::Module::Get()->core()->GetTime();
-  if (!FlushAndWaitForDone(&dc))
-    return "Couldn't flush an invisible paint";
+  ASSERT_SUBTEST_SUCCESS(FlushAndWaitForDone(&dc));
   PP_Time actual_time_elapsed = pp::Module::Get()->core()->GetTime() - begin;
   // Expect actual_time_elapsed >= kFlushDelaySec, but loose a bit to avoid
   // precision issue.
-  if (actual_time_elapsed < kFlushDelaySec * 0.9)
-    return "Offscreen painting should be delayed";
+  ASSERT_GE(actual_time_elapsed, kFlushDelaySec * 0.9);
 
   // Remove the padding on the top since test cases here isn't independent.
   instance_->EvalScript(
       "var big = document.getElementById('big-div');"
       "big.parentNode.removeChild(big);");
   ResetViewChangedState();
-  if (!WaitUntilViewChanged())
-    return "View didn't change as expected";
+  ASSERT_TRUE(WaitUntilViewChanged());
 
   PASS();
 }
@@ -816,23 +728,16 @@ std::string TestGraphics2D::TestDev() {
   const int w = 20, h = 16;
   const float scale = 1.0f/2.0f;
   pp::Graphics2D dc(instance_, pp::Size(w, h), false);
-  if (dc.is_null())
-    return "Failure creating a boring device";
+  ASSERT_FALSE(dc.is_null());
   pp::Graphics2D_Dev dc_dev(dc);
-  if (dc_dev.GetScale() != 1.0f)
-    return "GetScale returned unexpected value before SetScale";
-  if (!dc_dev.SetScale(scale))
-    return "SetScale failed";
-  if (dc_dev.GetScale() != scale)
-    return "GetScale mismatch with prior SetScale";
+  ASSERT_EQ(1.0f, dc_dev.GetScale());
+  ASSERT_TRUE(dc_dev.SetScale(scale));
+  ASSERT_EQ(scale, dc_dev.GetScale());
   // Try setting a few invalid scale factors. Ensure that we catch these errors
   // and don't change the actual scale
-  if (dc_dev.SetScale(-1.0f))
-    return "SetScale(-1f) did not fail";
-  if (dc_dev.SetScale(0.0f))
-    return "SetScale(0.0f) did not fail";
-  if (dc_dev.GetScale() != scale)
-    return "SetScale with invalid parameter overwrote the scale";
+  ASSERT_FALSE(dc_dev.SetScale(-1.0f));
+  ASSERT_FALSE(dc_dev.SetScale(0.0f));
+  ASSERT_EQ(scale, dc_dev.GetScale());
 
   // Verify that the context has the specified number of pixels, despite the
   // non-identity scale
@@ -840,12 +745,11 @@ std::string TestGraphics2D::TestDev() {
   size.width = -1;
   size.height = -1;
   PP_Bool is_always_opaque = PP_FALSE;
-  if (!graphics_2d_interface_->Describe(dc_dev.pp_resource(), &size,
-                                        &is_always_opaque))
-    return "Describe failed";
-  if (size.width != w || size.height != h ||
-      is_always_opaque != PP_FromBool(false))
-    return "Mismatch of data.";
+  ASSERT_TRUE(graphics_2d_interface_->Describe(dc_dev.pp_resource(), &size,
+                                               &is_always_opaque));
+  ASSERT_EQ(w, size.width);
+  ASSERT_EQ(h, size.height);
+  ASSERT_EQ(PP_FALSE, is_always_opaque);
 
   PASS();
 }
@@ -901,10 +805,8 @@ std::string TestGraphics2D::TestBindNull() {
 
   const int w = 115, h = 117;
   pp::Graphics2D dc(instance_, pp::Size(w, h), false);
-  if (dc.is_null())
-    return "Failure creating device.";
-  if (!instance_->BindGraphics(dc))
-    return "Failure to bind the boring device.";
+  ASSERT_FALSE(dc.is_null());
+  ASSERT_TRUE(instance_->BindGraphics(dc));
 
   ASSERT_TRUE(instance_->BindGraphics(pp::Graphics2D()));
   ASSERT_TRUE(instance_->BindGraphics(pp::Graphics3D()));
diff --git a/ppapi/tests/test_graphics_2d.h b/ppapi/tests/test_graphics_2d.h
index b54a04b..c905d8a 100644
--- a/ppapi/tests/test_graphics_2d.h
+++ b/ppapi/tests/test_graphics_2d.h
@@ -66,13 +66,10 @@ class TestGraphics2D : public TestCase {
   // Validates that the given device context is filled with the given color.
   bool IsDCUniformColor(const pp::Graphics2D& dc, uint32_t color) const;
 
-  // Returns true if Graphics2D resource is created correctly.
-  bool ResourceHealthCheck(pp::Instance* instance, pp::Graphics2D* context);
-  bool ResourceHealthCheckForC(pp::Instance* instance, PP_Resource graphics_2d);
-
   // Issues a flush on the given device context and blocks until the flush
-  // has issued its callback. Returns true on success.
-  bool FlushAndWaitForDone(pp::Graphics2D* context);
+  // has issued its callback. Returns an empty string on success or an error
+  // message on failure.
+  std::string FlushAndWaitForDone(pp::Graphics2D* context);
 
   // Creates an image and replaces the contents of the Graphics2D with the
   // image, waiting for completion. This returns the resource ID of the image
@@ -107,8 +104,8 @@ class TestGraphics2D : public TestCase {
   std::string TestBindNull();
 
   // Used by the tests that access the C API directly.
-  const PPB_Graphics2D* graphics_2d_interface_;
-  const PPB_ImageData* image_data_interface_;
+  const PPB_Graphics2D_1_1* graphics_2d_interface_;
+  const PPB_ImageData_1_0* image_data_interface_;
 
   // Used to indicate that DidChangeView has happened, in order to make plugin
   // and ui synchronous.
diff --git a/ppapi/tests/test_graphics_3d.cc b/ppapi/tests/test_graphics_3d.cc
index 987d5a8..61bedbf 100644
--- a/ppapi/tests/test_graphics_3d.cc
+++ b/ppapi/tests/test_graphics_3d.cc
@@ -137,11 +137,8 @@ std::string TestGraphics3D::TestExtensionsGL() {
 
 int32_t TestGraphics3D::SwapBuffersSync(pp::Graphics3D* context) {
   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
-  int32_t rv = context->SwapBuffers(callback.GetCallback());
-  if (rv != PP_OK_COMPLETIONPENDING)
-    return rv;
-
-  return callback.WaitForResult();
+  callback.WaitForResult(context->SwapBuffers(callback.GetCallback()));
+  return callback.result();
 }
 
 std::string TestGraphics3D::CheckPixelPPAPI(
diff --git a/ppapi/tests/test_host_resolver_private.cc b/ppapi/tests/test_host_resolver_private.cc
index 5531e83..72153af 100644
--- a/ppapi/tests/test_host_resolver_private.cc
+++ b/ppapi/tests/test_host_resolver_private.cc
@@ -42,33 +42,29 @@ bool TestHostResolverPrivate::Init() {
 
 void TestHostResolverPrivate::RunTests(const std::string& filter) {
   RUN_TEST(Empty, filter);
-  RUN_TEST_FORCEASYNC_AND_NOT(Resolve, filter);
-  RUN_TEST_FORCEASYNC_AND_NOT(ResolveIPv4, filter);
+  RUN_CALLBACK_TEST(TestHostResolverPrivate, Resolve, filter);
+  RUN_CALLBACK_TEST(TestHostResolverPrivate, ResolveIPv4, filter);
 }
 
 std::string TestHostResolverPrivate::SyncConnect(pp::TCPSocketPrivate* socket,
                                                  const std::string& host,
                                                  uint16_t port) {
-  TestCompletionCallback callback(instance_->pp_instance(), force_async_);
-  int32_t rv = socket->Connect(host.c_str(), port, callback.GetCallback());
-  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
-    return ReportError("PPB_TCPSocket_Private::Connect force_async", rv);
-  if (rv == PP_OK_COMPLETIONPENDING)
-    rv = callback.WaitForResult();
-  ASSERT_EQ(PP_OK, rv);
+  TestCompletionCallback callback(instance_->pp_instance(), callback_type());
+  callback.WaitForResult(
+     socket->Connect(host.c_str(), port, callback.GetCallback()));
+  CHECK_CALLBACK_BEHAVIOR(callback);
+  ASSERT_EQ(PP_OK, callback.result());
   PASS();
 }
 
 std::string TestHostResolverPrivate::SyncConnect(
     pp::TCPSocketPrivate* socket,
     const PP_NetAddress_Private& address) {
-  TestCompletionCallback callback(instance_->pp_instance(), force_async_);
-  int32_t rv = socket->ConnectWithNetAddress(&address, callback.GetCallback());
-  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
-    return ReportError("PPB_TCPSocket_Private::Connect force_async", rv);
-  if (rv == PP_OK_COMPLETIONPENDING)
-    rv = callback.WaitForResult();
-  ASSERT_EQ(PP_OK, rv);
+  TestCompletionCallback callback(instance_->pp_instance(), callback_type());
+  callback.WaitForResult(
+      socket->ConnectWithNetAddress(&address, callback.GetCallback()));
+  CHECK_CALLBACK_BEHAVIOR(callback);
+  ASSERT_EQ(PP_OK, callback.result());
   PASS();
 }
 
@@ -76,15 +72,12 @@ std::string TestHostResolverPrivate::SyncRead(pp::TCPSocketPrivate* socket,
                                               char* buffer,
                                               int32_t num_bytes,
                                               int32_t* bytes_read) {
-  TestCompletionCallback callback(instance_->pp_instance(), force_async_);
-  int32_t rv = socket->Read(buffer, num_bytes, callback.GetCallback());
-  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
-    return ReportError("PPB_TCPSocket_Private::Read force_async", rv);
-  if (rv == PP_OK_COMPLETIONPENDING)
-    rv = callback.WaitForResult();
-  if (num_bytes != rv)
-    return ReportError("PPB_TCPSocket_Private::Read", rv);
-  *bytes_read = rv;
+  TestCompletionCallback callback(instance_->pp_instance(), callback_type());
+  callback.WaitForResult(
+      socket->Read(buffer, num_bytes, callback.GetCallback()));
+  CHECK_CALLBACK_BEHAVIOR(callback);
+  ASSERT_EQ(num_bytes, callback.result());
+  *bytes_read = callback.result();
   PASS();
 }
 
@@ -92,15 +85,12 @@ std::string TestHostResolverPrivate::SyncWrite(pp::TCPSocketPrivate* socket,
                                                const char* buffer,
                                                int32_t num_bytes,
                                                int32_t* bytes_written) {
-  TestCompletionCallback callback(instance_->pp_instance(), force_async_);
-  int32_t rv = socket->Write(buffer, num_bytes, callback.GetCallback());
-  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
-    return ReportError("PPB_TCPSocket_Private::Write force_async", rv);
-  if (rv == PP_OK_COMPLETIONPENDING)
-    rv = callback.WaitForResult();
-  if (num_bytes != rv)
-    return ReportError("PPB_TCPSocket_Private::Write", rv);
-  *bytes_written = rv;
+  TestCompletionCallback callback(instance_->pp_instance(), callback_type());
+  callback.WaitForResult(
+      socket->Write(buffer, num_bytes, callback.GetCallback()));
+  CHECK_CALLBACK_BEHAVIOR(callback);
+  ASSERT_EQ(num_bytes, callback.result());
+  *bytes_written = callback.result();
   PASS();
 }
 
@@ -127,14 +117,10 @@ std::string TestHostResolverPrivate::SyncResolve(
     const std::string& host,
     uint16_t port,
     const PP_HostResolver_Private_Hint& hint) {
-  TestCompletionCallback callback(instance_->pp_instance(), force_async_);
-  int32_t rv = host_resolver->Resolve(host, port, hint, callback.GetCallback());
-  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
-    return ReportError("PPB_HostResolver_Private::Resolve force_async", rv);
-  if (rv == PP_OK_COMPLETIONPENDING)
-    rv = callback.WaitForResult();
-  if (rv != PP_OK)
-    return ReportError("PPB_HostResolver_Private::Resolve", rv);
+  TestCompletionCallback callback(instance_->pp_instance(), callback_type());
+  callback.WaitForResult(
+      host_resolver->Resolve(host, port, hint, callback.GetCallback()));
+  CHECK_CALLBACK_BEHAVIOR(callback);
   PASS();
 }
 
diff --git a/ppapi/tests/test_host_resolver_private_disallowed.cc b/ppapi/tests/test_host_resolver_private_disallowed.cc
index cc5bce0..3c0e0d5 100644
--- a/ppapi/tests/test_host_resolver_private_disallowed.cc
+++ b/ppapi/tests/test_host_resolver_private_disallowed.cc
@@ -33,7 +33,7 @@ bool TestHostResolverPrivateDisallowed::Init() {
 }
 
 void TestHostResolverPrivateDisallowed::RunTests(const std::string& filter) {
-  RUN_TEST_FORCEASYNC_AND_NOT(Resolve, filter);
+  RUN_CALLBACK_TEST(TestHostResolverPrivateDisallowed, Resolve, filter);
 }
 
 std::string TestHostResolverPrivateDisallowed::TestResolve() {
@@ -41,14 +41,10 @@ std::string TestHostResolverPrivateDisallowed::TestResolve() {
   PP_HostResolver_Private_Hint hint;
   hint.family = PP_NETADDRESSFAMILY_UNSPECIFIED;
   hint.flags = PP_HOST_RESOLVER_FLAGS_CANONNAME;
-  TestCompletionCallback callback(instance_->pp_instance(), force_async_);
-  int32_t rv = host_resolver.Resolve(host_, port_, hint,
-                                     callback.GetCallback());
-  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
-    return ReportError("PPB_HostResolver_Private::Resolve force_async", rv);
-  if (rv == PP_OK_COMPLETIONPENDING)
-    rv = callback.WaitForResult();
-  if (rv != PP_ERROR_FAILED)
-    return "PPB_HostResolver_Private can resolve without allowing switch";
+  TestCompletionCallback callback(instance_->pp_instance(), callback_type());
+  callback.WaitForResult(
+      host_resolver.Resolve(host_, port_, hint, callback.GetCallback()));
+  CHECK_CALLBACK_BEHAVIOR(callback);
+  ASSERT_EQ(PP_ERROR_FAILED, callback.result());
   PASS();
 }
diff --git a/ppapi/tests/test_net_address_private_untrusted.cc b/ppapi/tests/test_net_address_private_untrusted.cc
index 7ad64e2..06db002 100644
--- a/ppapi/tests/test_net_address_private_untrusted.cc
+++ b/ppapi/tests/test_net_address_private_untrusted.cc
@@ -57,10 +57,9 @@ int32_t TestNetAddressPrivateUntrusted::Connect(TCPSocketPrivate* socket,
                                                 uint16_t port) {
   TestCompletionCallback callback(instance_->pp_instance(), false);
 
-  int32_t rv = socket->Connect(host.c_str(), port, callback.GetCallback());
-  if (rv == PP_OK_COMPLETIONPENDING)
-    rv = callback.WaitForResult();
-  return rv;
+  callback.WaitForResult(
+      socket->Connect(host.c_str(), port, callback.GetCallback()));
+  return callback.result();
 }
 
 std::string TestNetAddressPrivateUntrusted::TestAreEqual() {
diff --git a/ppapi/tests/test_tcp_server_socket_private.cc b/ppapi/tests/test_tcp_server_socket_private.cc
index 26b43e6..47e3020 100644
--- a/ppapi/tests/test_tcp_server_socket_private.cc
+++ b/ppapi/tests/test_tcp_server_socket_private.cc
@@ -60,23 +60,19 @@ bool TestTCPServerSocketPrivate::Init() {
 }
 
 void TestTCPServerSocketPrivate::RunTests(const std::string& filter) {
-  RUN_TEST_FORCEASYNC_AND_NOT(Listen, filter);
-  RUN_TEST_FORCEASYNC_AND_NOT(Backlog, filter);
+  RUN_CALLBACK_TEST(TestTCPServerSocketPrivate, Listen, filter);
+  RUN_CALLBACK_TEST(TestTCPServerSocketPrivate, Backlog, filter);
 }
 
 std::string TestTCPServerSocketPrivate::GetLocalAddress(
     PP_NetAddress_Private* address) {
   TCPSocketPrivate socket(instance_);
-  TestCompletionCallback callback(instance_->pp_instance(), force_async_);
-  int32_t rv = socket.Connect(host_.c_str(), port_, callback.GetCallback());
-  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
-    return ReportError("PPB_TCPSocket_Private::Connect force_async", rv);
-  if (rv == PP_OK_COMPLETIONPENDING)
-    rv = callback.WaitForResult();
-  if (rv != PP_OK)
-    return ReportError("PPB_TCPSocket_Private::Connect", rv);
-  if (!socket.GetLocalAddress(address))
-    return ReportError("PPB_TCPSocket_Private::GetLocalAddress", 0);
+  TestCompletionCallback callback(instance_->pp_instance(), callback_type());
+  callback.WaitForResult(
+      socket.Connect(host_.c_str(), port_, callback.GetCallback()));
+  CHECK_CALLBACK_BEHAVIOR(callback);
+  ASSERT_EQ(PP_OK, callback.result());
+  ASSERT_TRUE(socket.GetLocalAddress(address));
   socket.Disconnect();
   PASS();
 }
@@ -85,16 +81,13 @@ std::string TestTCPServerSocketPrivate::SyncRead(TCPSocketPrivate* socket,
                                                  char* buffer,
                                                  size_t num_bytes) {
   while (num_bytes > 0) {
-    TestCompletionCallback callback(instance_->pp_instance(), force_async_);
-    int32_t rv = socket->Read(buffer, num_bytes, callback.GetCallback());
-    if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
-      return ReportError("PPB_TCPSocket_Private::Read force_async", rv);
-    if (rv == PP_OK_COMPLETIONPENDING)
-      rv = callback.WaitForResult();
-    if (rv < 0)
-      return ReportError("PPB_TCPSocket_Private::Read", rv);
-    buffer += rv;
-    num_bytes -= rv;
+    TestCompletionCallback callback(instance_->pp_instance(), callback_type());
+    callback.WaitForResult(
+        socket->Read(buffer, num_bytes, callback.GetCallback()));
+    CHECK_CALLBACK_BEHAVIOR(callback);
+    ASSERT_TRUE(callback.result() >= 0);
+    buffer += callback.result();
+    num_bytes -= callback.result();
   }
   PASS();
 }
@@ -103,16 +96,13 @@ std::string TestTCPServerSocketPrivate::SyncWrite(TCPSocketPrivate* socket,
                                                   const char* buffer,
                                                   size_t num_bytes) {
   while (num_bytes > 0) {
-    TestCompletionCallback callback(instance_->pp_instance(), force_async_);
-    int32_t rv = socket->Write(buffer, num_bytes, callback.GetCallback());
-    if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
-      return ReportError("PPB_TCPSocket_Private::Write force_async", rv);
-    if (rv == PP_OK_COMPLETIONPENDING)
-      rv = callback.WaitForResult();
-    if (rv < 0)
-      return ReportError("PPB_TCPSocket_Private::Write", rv);
-    buffer += rv;
-    num_bytes -= rv;
+    TestCompletionCallback callback(instance_->pp_instance(), callback_type());
+    callback.WaitForResult(
+        socket->Write(buffer, num_bytes, callback.GetCallback()));
+    CHECK_CALLBACK_BEHAVIOR(callback);
+    ASSERT_TRUE(callback.result() >= 0);
+    buffer += callback.result();
+    num_bytes -= callback.result();
   }
   PASS();
 }
@@ -120,14 +110,11 @@ std::string TestTCPServerSocketPrivate::SyncWrite(TCPSocketPrivate* socket,
 std::string TestTCPServerSocketPrivate::SyncConnect(
     TCPSocketPrivate* socket,
     PP_NetAddress_Private* address) {
-  TestCompletionCallback callback(instance_->pp_instance(), force_async_);
-  int32_t rv = socket->ConnectWithNetAddress(address, callback.GetCallback());
-  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
-    return ReportError("PPB_TCPSocket_Private::Connect force_async", rv);
-  if (rv == PP_OK_COMPLETIONPENDING)
-    rv = callback.WaitForResult();
-  if (rv != PP_OK)
-    return ReportError("PPB_TCPSocket_Private::Connect", rv);
+  TestCompletionCallback callback(instance_->pp_instance(), callback_type());
+  callback.WaitForResult(
+      socket->ConnectWithNetAddress(address, callback.GetCallback()));
+  CHECK_CALLBACK_BEHAVIOR(callback);
+  ASSERT_EQ(PP_OK, callback.result());
   PASS();
 }
 
@@ -153,20 +140,17 @@ std::string TestTCPServerSocketPrivate::SyncListen(
     if (!NetAddressPrivate::ReplacePort(base_address, port, address))
       return ReportError("PPB_NetAddress_Private::ReplacePort", 0);
 
-    TestCompletionCallback callback(instance_->pp_instance(), force_async_);
-    int32_t rv = socket->Listen(address, backlog, callback.GetCallback());
-    if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
-      return ReportError("PPB_TCPServerSocket_Private::Listen force_async", rv);
-    if (rv == PP_OK_COMPLETIONPENDING)
-      rv = callback.WaitForResult();
-    if (rv == PP_OK) {
+    TestCompletionCallback callback(instance_->pp_instance(), callback_type());
+    callback.WaitForResult(
+        socket->Listen(address, backlog, callback.GetCallback()));
+    CHECK_CALLBACK_BEHAVIOR(callback);
+    if (callback.result() == PP_OK) {
       is_free_port_found = true;
       break;
     }
   }
 
-  if (!is_free_port_found)
-    return "Can't find available port";
+  ASSERT_TRUE(is_free_port_found);
   PASS();
 }
 
@@ -178,8 +162,17 @@ std::string TestTCPServerSocketPrivate::TestListen() {
   PP_NetAddress_Private address;
   ASSERT_SUBTEST_SUCCESS(SyncListen(&server_socket, &address, kBacklog));
 
+  // We can't use a blocking callback for Accept, because it will wait forever
+  // for the client to connect, since the client connects after.
   TestCompletionCallback accept_callback(instance_->pp_instance(),
-                                         force_async_);
+                                         PP_REQUIRED);
+  // We need to make sure there's a message loop to run accept_callback on.
+  pp::MessageLoop current_thread_loop(pp::MessageLoop::GetCurrent());
+  if (current_thread_loop.is_null() && testing_interface_->IsOutOfProcess()) {
+    current_thread_loop = pp::MessageLoop(instance_);
+    current_thread_loop.AttachToCurrentThread();
+  }
+
   PP_Resource resource;
   int32_t accept_rv = server_socket.Accept(&resource,
                                            accept_callback.GetCallback());
@@ -187,14 +180,9 @@ std::string TestTCPServerSocketPrivate::TestListen() {
   TCPSocketPrivate client_socket(instance_);
   ForceConnect(&client_socket, &address);
 
-  if (force_async_ && accept_rv != PP_OK_COMPLETIONPENDING) {
-    return ReportError("PPB_TCPServerSocket_Private::Accept force_async",
-                       accept_rv);
-  }
-  if (accept_rv == PP_OK_COMPLETIONPENDING)
-    accept_rv = accept_callback.WaitForResult();
-  if (accept_rv != PP_OK)
-    return ReportError("PPB_TCPServerSocket_Private::Accept", accept_rv);
+  accept_callback.WaitForResult(accept_rv);
+  CHECK_CALLBACK_BEHAVIOR(accept_callback);
+  ASSERT_EQ(PP_OK, accept_callback.result());
 
   ASSERT_TRUE(resource != 0);
   TCPSocketPrivate accepted_socket(pp::PassRef(), resource);
@@ -231,37 +219,29 @@ std::string TestTCPServerSocketPrivate::TestBacklog() {
   for (size_t i = 0; i < kBacklog; ++i) {
     client_sockets[i] = new TCPSocketPrivate(instance_);
     connect_callbacks[i] = new TestCompletionCallback(instance_->pp_instance(),
-                                                      force_async_);
+                                                      callback_type());
     connect_rv[i] = client_sockets[i]->ConnectWithNetAddress(
         &address,
         connect_callbacks[i]->GetCallback());
-    if (force_async_ && connect_rv[i] != PP_OK_COMPLETIONPENDING) {
-      return ReportError("PPB_TCPSocket_Private::Connect force_async",
-                         connect_rv[i]);
-    }
   }
 
   std::vector<PP_Resource> resources(kBacklog);
   std::vector<TCPSocketPrivate*> accepted_sockets(kBacklog);
   for (size_t i = 0; i < kBacklog; ++i) {
-    TestCompletionCallback callback(instance_->pp_instance(), force_async_);
-    int32_t rv = server_socket.Accept(&resources[i], callback.GetCallback());
-    if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
-      return ReportError("PPB_TCPServerSocket_Private::Accept force_async", rv);
-    if (rv == PP_OK_COMPLETIONPENDING)
-      rv = callback.WaitForResult();
-    if (rv != PP_OK)
-      return ReportError("PPB_TCPServerSocket_Private::Accept", rv);
+    TestCompletionCallback callback(instance_->pp_instance(), callback_type());
+    callback.WaitForResult(
+        server_socket.Accept(&resources[i], callback.GetCallback()));
+    CHECK_CALLBACK_BEHAVIOR(callback);
+    ASSERT_EQ(PP_OK, callback.result());
 
     ASSERT_TRUE(resources[i] != 0);
     accepted_sockets[i] = new TCPSocketPrivate(pp::PassRef(), resources[i]);
   }
 
   for (size_t i = 0; i < kBacklog; ++i) {
-    if (connect_rv[i] == PP_OK_COMPLETIONPENDING)
-      connect_rv[i] = connect_callbacks[i]->WaitForResult();
-    if (connect_rv[i] != PP_OK)
-      return ReportError("PPB_TCPSocket_Private::Connect", connect_rv[i]);
+    connect_callbacks[i]->WaitForResult(connect_rv[i]);
+    CHECK_CALLBACK_BEHAVIOR(*connect_callbacks[i]);
+    ASSERT_EQ(PP_OK, connect_callbacks[i]->result());
   }
 
   for (size_t i = 0; i < kBacklog; ++i) {
diff --git a/ppapi/tests/test_tcp_server_socket_private_disallowed.cc b/ppapi/tests/test_tcp_server_socket_private_disallowed.cc
index 55a61a6c..8c89a3a 100644
--- a/ppapi/tests/test_tcp_server_socket_private_disallowed.cc
+++ b/ppapi/tests/test_tcp_server_socket_private_disallowed.cc
@@ -53,7 +53,7 @@ bool TestTCPServerSocketPrivateDisallowed::Init() {
 }
 
 void TestTCPServerSocketPrivateDisallowed::RunTests(const std::string& filter) {
-  RUN_TEST_FORCEASYNC_AND_NOT(Listen, filter);
+  RUN_CALLBACK_TEST(TestTCPServerSocketPrivateDisallowed, Listen, filter);
 }
 
 std::string TestTCPServerSocketPrivateDisallowed::TestListen() {
@@ -69,17 +69,14 @@ std::string TestTCPServerSocketPrivateDisallowed::TestListen() {
     ASSERT_TRUE(pp::NetAddressPrivate::ReplacePort(base_address,
                                                    port,
                                                    &current_address));
-    TestCompletionCallback callback(instance_->pp_instance(), force_async_);
-    int32_t rv = tcp_server_socket_private_interface_->Listen(
+    TestCompletionCallback callback(instance_->pp_instance(), callback_type());
+    callback.WaitForResult(tcp_server_socket_private_interface_->Listen(
         socket,
         &current_address,
         1,
-        callback.GetCallback().pp_completion_callback());
-    if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
-      return ReportError("PPB_TCPServerSocket_Private::Listen force_async", rv);
-    if (rv == PP_OK_COMPLETIONPENDING)
-      rv = callback.WaitForResult();
-    ASSERT_NE(PP_OK, rv);
+        callback.GetCallback().pp_completion_callback()));
+    CHECK_CALLBACK_BEHAVIOR(callback);
+    ASSERT_NE(PP_OK, callback.result());
   }
 
   PASS();
diff --git a/ppapi/tests/test_tcp_socket_private.cc b/ppapi/tests/test_tcp_socket_private.cc
index a15c36e..b6f158f 100644
--- a/ppapi/tests/test_tcp_socket_private.cc
+++ b/ppapi/tests/test_tcp_socket_private.cc
@@ -47,22 +47,20 @@ bool TestTCPSocketPrivate::Init() {
 }
 
 void TestTCPSocketPrivate::RunTests(const std::string& filter) {
-  RUN_TEST_FORCEASYNC_AND_NOT(Basic, filter);
-  RUN_TEST_FORCEASYNC_AND_NOT(ReadWrite, filter);
-  RUN_TEST_FORCEASYNC_AND_NOT(ReadWriteSSL, filter);
-  RUN_TEST_FORCEASYNC_AND_NOT(ConnectAddress, filter);
-  RUN_TEST_FORCEASYNC_AND_NOT(SetOption, filter);
+  RUN_CALLBACK_TEST(TestTCPSocketPrivate, Basic, filter);
+  RUN_CALLBACK_TEST(TestTCPSocketPrivate, ReadWrite, filter);
+  RUN_CALLBACK_TEST(TestTCPSocketPrivate, ReadWriteSSL, filter);
+  RUN_CALLBACK_TEST(TestTCPSocketPrivate, ConnectAddress, filter);
+  RUN_CALLBACK_TEST(TestTCPSocketPrivate, SetOption, filter);
 }
 
 std::string TestTCPSocketPrivate::TestBasic() {
   pp::TCPSocketPrivate socket(instance_);
-  TestCompletionCallback cb(instance_->pp_instance(), force_async_);
+  TestCompletionCallback cb(instance_->pp_instance(), callback_type());
 
-  int32_t rv = socket.Connect(host_.c_str(), port_, cb.GetCallback());
-  ASSERT_TRUE(!force_async_ || rv == PP_OK_COMPLETIONPENDING);
-  if (rv == PP_OK_COMPLETIONPENDING)
-    rv = cb.WaitForResult();
-  ASSERT_EQ(PP_OK, rv);
+  cb.WaitForResult(socket.Connect(host_.c_str(), port_, cb.GetCallback()));
+  CHECK_CALLBACK_BEHAVIOR(cb);
+  ASSERT_EQ(PP_OK, cb.result());
 
   PP_NetAddress_Private unused;
   // TODO(viettrungluu): check the values somehow.
@@ -76,13 +74,11 @@ std::string TestTCPSocketPrivate::TestBasic() {
 
 std::string TestTCPSocketPrivate::TestReadWrite() {
   pp::TCPSocketPrivate socket(instance_);
-  TestCompletionCallback cb(instance_->pp_instance(), force_async_);
+  TestCompletionCallback cb(instance_->pp_instance(), callback_type());
 
-  int32_t rv = socket.Connect(host_.c_str(), port_, cb.GetCallback());
-  ASSERT_TRUE(!force_async_ || rv == PP_OK_COMPLETIONPENDING);
-  if (rv == PP_OK_COMPLETIONPENDING)
-    rv = cb.WaitForResult();
-  ASSERT_EQ(PP_OK, rv);
+  cb.WaitForResult(socket.Connect(host_.c_str(), port_, cb.GetCallback()));
+  CHECK_CALLBACK_BEHAVIOR(cb);
+  ASSERT_EQ(PP_OK, cb.result());
 
   ASSERT_EQ(PP_OK, WriteStringToSocket(&socket, "GET / HTTP/1.0\r\n\r\n"));
 
@@ -98,19 +94,16 @@ std::string TestTCPSocketPrivate::TestReadWrite() {
 
 std::string TestTCPSocketPrivate::TestReadWriteSSL() {
   pp::TCPSocketPrivate socket(instance_);
-  TestCompletionCallback cb(instance_->pp_instance(), force_async_);
+  TestCompletionCallback cb(instance_->pp_instance(), callback_type());
 
-  int32_t rv = socket.Connect(host_.c_str(), ssl_port_, cb.GetCallback());
-  ASSERT_TRUE(!force_async_ || rv == PP_OK_COMPLETIONPENDING);
-  if (rv == PP_OK_COMPLETIONPENDING)
-    rv = cb.WaitForResult();
-  ASSERT_EQ(PP_OK, rv);
+  cb.WaitForResult(socket.Connect(host_.c_str(), ssl_port_, cb.GetCallback()));
+  CHECK_CALLBACK_BEHAVIOR(cb);
+  ASSERT_EQ(PP_OK, cb.result());
 
-  rv = socket.SSLHandshake(host_.c_str(), ssl_port_, cb.GetCallback());
-  ASSERT_TRUE(!force_async_ || rv == PP_OK_COMPLETIONPENDING);
-  if (rv == PP_OK_COMPLETIONPENDING)
-    rv = cb.WaitForResult();
-  ASSERT_EQ(PP_OK, rv);
+  cb.WaitForResult(
+      socket.SSLHandshake(host_.c_str(), ssl_port_, cb.GetCallback()));
+  CHECK_CALLBACK_BEHAVIOR(cb);
+  ASSERT_EQ(PP_OK, cb.result());
 
   ASSERT_EQ(PP_OK, WriteStringToSocket(&socket, "GET / HTTP/1.0\r\n\r\n"));
 
@@ -130,12 +123,10 @@ std::string TestTCPSocketPrivate::TestConnectAddress() {
   // First, bring up a connection and grab the address.
   {
     pp::TCPSocketPrivate socket(instance_);
-    TestCompletionCallback cb(instance_->pp_instance(), force_async_);
-    int32_t rv = socket.Connect(host_.c_str(), port_, cb.GetCallback());
-    ASSERT_TRUE(!force_async_ || rv == PP_OK_COMPLETIONPENDING);
-    if (rv == PP_OK_COMPLETIONPENDING)
-      rv = cb.WaitForResult();
-    ASSERT_EQ(PP_OK, rv);
+    TestCompletionCallback cb(instance_->pp_instance(), callback_type());
+    cb.WaitForResult(socket.Connect(host_.c_str(), port_, cb.GetCallback()));
+    CHECK_CALLBACK_BEHAVIOR(cb);
+    ASSERT_EQ(PP_OK, cb.result());
     ASSERT_TRUE(socket.GetRemoteAddress(&address));
     // Omit the |Disconnect()| here to make sure we don't crash if we just let
     // the resource be destroyed.
@@ -143,12 +134,10 @@ std::string TestTCPSocketPrivate::TestConnectAddress() {
 
   // Connect to that address.
   pp::TCPSocketPrivate socket(instance_);
-  TestCompletionCallback cb(instance_->pp_instance(), force_async_);
-  int32_t rv = socket.ConnectWithNetAddress(&address, cb.GetCallback());
-  ASSERT_TRUE(!force_async_ || rv == PP_OK_COMPLETIONPENDING);
-  if (rv == PP_OK_COMPLETIONPENDING)
-    rv = cb.WaitForResult();
-  ASSERT_EQ(PP_OK, rv);
+  TestCompletionCallback cb(instance_->pp_instance(), callback_type());
+  cb.WaitForResult(socket.ConnectWithNetAddress(&address, cb.GetCallback()));
+  CHECK_CALLBACK_BEHAVIOR(cb);
+  ASSERT_EQ(PP_OK, cb.result());
 
   // Make sure we can read/write to it properly (see |TestReadWrite()|).
   ASSERT_EQ(PP_OK, WriteStringToSocket(&socket, "GET / HTTP/1.0\r\n\r\n"));
@@ -163,32 +152,26 @@ std::string TestTCPSocketPrivate::TestConnectAddress() {
 
 std::string TestTCPSocketPrivate::TestSetOption() {
   pp::TCPSocketPrivate socket(instance_);
-  TestCompletionCallback cb(instance_->pp_instance(), force_async_);
-
-  int32_t rv = socket.SetOption(PP_TCPSOCKETOPTION_NO_DELAY, true,
-                                cb.GetCallback());
-  ASSERT_TRUE(!force_async_ || rv == PP_OK_COMPLETIONPENDING);
-  if (rv == PP_OK_COMPLETIONPENDING)
-    rv = cb.WaitForResult();
-  ASSERT_EQ(PP_ERROR_FAILED, rv);
-
-  rv = socket.Connect(host_.c_str(), port_, cb.GetCallback());
-  ASSERT_TRUE(!force_async_ || rv == PP_OK_COMPLETIONPENDING);
-  if (rv == PP_OK_COMPLETIONPENDING)
-    rv = cb.WaitForResult();
-  ASSERT_EQ(PP_OK, rv);
-
-  rv = socket.SetOption(PP_TCPSOCKETOPTION_NO_DELAY, true, cb.GetCallback());
-  ASSERT_TRUE(!force_async_ || rv == PP_OK_COMPLETIONPENDING);
-  if (rv == PP_OK_COMPLETIONPENDING)
-    rv = cb.WaitForResult();
-  ASSERT_EQ(PP_OK, rv);
-
-  rv = socket.SetOption(PP_TCPSOCKETOPTION_INVALID, true, cb.GetCallback());
-  ASSERT_TRUE(!force_async_ || rv == PP_OK_COMPLETIONPENDING);
-  if (rv == PP_OK_COMPLETIONPENDING)
-    rv = cb.WaitForResult();
-  ASSERT_EQ(PP_ERROR_BADARGUMENT, rv);
+  TestCompletionCallback cb(instance_->pp_instance(), callback_type());
+
+  cb.WaitForResult(
+      socket.SetOption(PP_TCPSOCKETOPTION_NO_DELAY, true, cb.GetCallback()));
+  CHECK_CALLBACK_BEHAVIOR(cb);
+  ASSERT_EQ(PP_ERROR_FAILED, cb.result());
+
+  cb.WaitForResult(socket.Connect(host_.c_str(), port_, cb.GetCallback()));
+  CHECK_CALLBACK_BEHAVIOR(cb);
+  ASSERT_EQ(PP_OK, cb.result());
+
+  cb.WaitForResult(
+      socket.SetOption(PP_TCPSOCKETOPTION_NO_DELAY, true, cb.GetCallback()));
+  CHECK_CALLBACK_BEHAVIOR(cb);
+  ASSERT_EQ(PP_OK, cb.result());
+
+  cb.WaitForResult(
+      socket.SetOption(PP_TCPSOCKETOPTION_INVALID, true, cb.GetCallback()));
+  CHECK_CALLBACK_BEHAVIOR(cb);
+  ASSERT_EQ(PP_ERROR_BADARGUMENT, cb.result());
 
   socket.Disconnect();
 
@@ -203,18 +186,17 @@ int32_t TestTCPSocketPrivate::ReadFirstLineFromSocket(
   s->clear();
   // Make sure we don't just hang if |Read()| spews.
   while (s->size() < 1000000) {
-    TestCompletionCallback cb(instance_->pp_instance(), force_async_);
+    TestCompletionCallback cb(instance_->pp_instance(), callback_type());
     int32_t rv = socket->Read(buffer, sizeof(buffer), cb.GetCallback());
-    if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+    if (callback_type() == PP_REQUIRED && rv != PP_OK_COMPLETIONPENDING)
       return PP_ERROR_FAILED;
-    if (rv == PP_OK_COMPLETIONPENDING)
-      rv = cb.WaitForResult();
-    if (rv < 0)
-      return rv;
-    if (rv == 0)
+    cb.WaitForResult(rv);
+    if (cb.result() < 0)
+      return cb.result();
+    if (cb.result() == 0)
       return PP_ERROR_FAILED;  // Didn't get a \n-terminated line.
-    s->reserve(s->size() + rv);
-    for (int32_t i = 0; i < rv; i++) {
+    s->reserve(s->size() + cb.result());
+    for (int32_t i = 0; i < cb.result(); i++) {
       s->push_back(buffer[i]);
       if (buffer[i] == '\n')
         return PP_OK;
@@ -228,18 +210,17 @@ int32_t TestTCPSocketPrivate::WriteStringToSocket(pp::TCPSocketPrivate* socket,
   const char* buffer = s.data();
   size_t written = 0;
   while (written < s.size()) {
-    TestCompletionCallback cb(instance_->pp_instance(), force_async_);
+    TestCompletionCallback cb(instance_->pp_instance(), callback_type());
     int32_t rv = socket->Write(buffer + written, s.size() - written,
                                cb.GetCallback());
-    if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+    if (callback_type() == PP_REQUIRED && rv != PP_OK_COMPLETIONPENDING)
       return PP_ERROR_FAILED;
-    if (rv == PP_OK_COMPLETIONPENDING)
-      rv = cb.WaitForResult();
-    if (rv < 0)
-      return rv;
-    if (rv == 0)
+    cb.WaitForResult(rv);
+    if (cb.result() < 0)
+      return cb.result();
+    if (cb.result() == 0)
       return PP_ERROR_FAILED;
-    written += rv;
+    written += cb.result();
   }
   if (written != s.size())
     return PP_ERROR_FAILED;
diff --git a/ppapi/tests/test_tcp_socket_private_disallowed.cc b/ppapi/tests/test_tcp_socket_private_disallowed.cc
index 6325a4f..581b54b 100644
--- a/ppapi/tests/test_tcp_socket_private_disallowed.cc
+++ b/ppapi/tests/test_tcp_socket_private_disallowed.cc
@@ -39,15 +39,11 @@ std::string TestTCPSocketPrivateDisallowed::TestConnect() {
       tcp_socket_private_interface_->Create(instance_->pp_instance());
   if (0 != socket) {
     TestCompletionCallback callback(instance_->pp_instance());
-    int32_t rv = tcp_socket_private_interface_->Connect(
+    callback.WaitForResult(tcp_socket_private_interface_->Connect(
         socket, kServerName, kPort,
-        callback.GetCallback().pp_completion_callback());
-
-    if (PP_OK_COMPLETIONPENDING == rv)
-      rv = callback.WaitForResult();
-
-    if (PP_ERROR_FAILED != rv)
-      return "PPB_TCPSocket_Private can connect without allowing switch";
+        callback.GetCallback().pp_completion_callback()));
+    CHECK_CALLBACK_BEHAVIOR(callback);
+    ASSERT_EQ(PP_ERROR_FAILED, callback.result());
   }
   PASS();
 }
diff --git a/ppapi/tests/test_tcp_socket_private_trusted.cc b/ppapi/tests/test_tcp_socket_private_trusted.cc
index 82c2257..1b0e7e7 100644
--- a/ppapi/tests/test_tcp_socket_private_trusted.cc
+++ b/ppapi/tests/test_tcp_socket_private_trusted.cc
@@ -35,24 +35,22 @@ bool TestTCPSocketPrivateTrusted::Init() {
 }
 
 void TestTCPSocketPrivateTrusted::RunTests(const std::string& filter) {
-  RUN_TEST_FORCEASYNC_AND_NOT(GetServerCertificate, filter);
+  RUN_CALLBACK_TEST(TestTCPSocketPrivateTrusted, GetServerCertificate, filter);
 }
 
 std::string TestTCPSocketPrivateTrusted::TestGetServerCertificate() {
   pp::TCPSocketPrivate socket(instance_);
-  TestCompletionCallback cb(instance_->pp_instance(), force_async_);
+  TestCompletionCallback cb(instance_->pp_instance(), callback_type());
 
-  int32_t rv = socket.Connect(host_.c_str(), ssl_port_, cb.GetCallback());
-  ASSERT_TRUE(!force_async_ || rv == PP_OK_COMPLETIONPENDING);
-  if (rv == PP_OK_COMPLETIONPENDING)
-    rv = cb.WaitForResult();
-  ASSERT_EQ(PP_OK, rv);
+  cb.WaitForResult(
+      socket.Connect(host_.c_str(), ssl_port_, cb.GetCallback()));
+  CHECK_CALLBACK_BEHAVIOR(cb);
+  ASSERT_EQ(PP_OK, cb.result());
 
-  rv = socket.SSLHandshake(host_.c_str(), ssl_port_, cb.GetCallback());
-  ASSERT_TRUE(!force_async_ || rv == PP_OK_COMPLETIONPENDING);
-  if (rv == PP_OK_COMPLETIONPENDING)
-    rv = cb.WaitForResult();
-  ASSERT_EQ(PP_OK, rv);
+  cb.WaitForResult(
+      socket.SSLHandshake(host_.c_str(), ssl_port_, cb.GetCallback()));
+  CHECK_CALLBACK_BEHAVIOR(cb);
+  ASSERT_EQ(PP_OK, cb.result());
 
   const pp::X509CertificatePrivate& cert = socket.GetServerCertificate();
   ASSERT_EQ(
diff --git a/ppapi/tests/test_udp_socket_private.cc b/ppapi/tests/test_udp_socket_private.cc
index 995b53a..1380135 100644
--- a/ppapi/tests/test_udp_socket_private.cc
+++ b/ppapi/tests/test_udp_socket_private.cc
@@ -54,25 +54,21 @@ bool TestUDPSocketPrivate::Init() {
 }
 
 void TestUDPSocketPrivate::RunTests(const std::string& filter) {
-  RUN_TEST_FORCEASYNC_AND_NOT(Connect, filter);
-  RUN_TEST_FORCEASYNC_AND_NOT(ConnectFailure, filter);
-  RUN_TEST_FORCEASYNC_AND_NOT(Broadcast, filter);
-  RUN_TEST_FORCEASYNC_AND_NOT(SetSocketFeatureErrors, filter);
+  RUN_CALLBACK_TEST(TestUDPSocketPrivate, Connect, filter);
+  RUN_CALLBACK_TEST(TestUDPSocketPrivate, ConnectFailure, filter);
+  RUN_CALLBACK_TEST(TestUDPSocketPrivate, Broadcast, filter);
+  RUN_CALLBACK_TEST(TestUDPSocketPrivate, SetSocketFeatureErrors, filter);
 }
 
 std::string TestUDPSocketPrivate::GetLocalAddress(
     PP_NetAddress_Private* address) {
   pp::TCPSocketPrivate socket(instance_);
-  TestCompletionCallback callback(instance_->pp_instance(), force_async_);
-  int32_t rv = socket.Connect(host_.c_str(), port_, callback.GetCallback());
-  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
-    return ReportError("PPB_TCPSocket_Private::Connect force_async", rv);
-  if (rv == PP_OK_COMPLETIONPENDING)
-    rv = callback.WaitForResult();
-  if (rv != PP_OK)
-    return ReportError("PPB_TCPSocket_Private::Connect", rv);
-  if (!socket.GetLocalAddress(address))
-    return "PPB_TCPSocket_Private::GetLocalAddress: Failed";
+  TestCompletionCallback callback(instance_->pp_instance(), callback_type());
+  callback.WaitForResult(
+      socket.Connect(host_.c_str(), port_, callback.GetCallback()));
+  CHECK_CALLBACK_BEHAVIOR(callback);
+  ASSERT_EQ(PP_OK, callback.result());
+  ASSERT_TRUE(socket.GetLocalAddress(address));
   socket.Disconnect();
   PASS();
 }
@@ -94,14 +90,10 @@ std::string TestUDPSocketPrivate::SetBroadcastOptions(
 std::string TestUDPSocketPrivate::BindUDPSocket(
     pp::UDPSocketPrivate* socket,
     PP_NetAddress_Private* address) {
-  TestCompletionCallback callback(instance_->pp_instance(), force_async_);
-  int32_t rv = socket->Bind(address, callback.GetCallback());
-  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
-    return ReportError("PPB_UDPSocket_Private::Bind force_async", rv);
-  if (rv == PP_OK_COMPLETIONPENDING)
-    rv = callback.WaitForResult();
-  if (rv != PP_OK)
-    return ReportError("PPB_UDPSocket_Private::Bind", rv);
+  TestCompletionCallback callback(instance_->pp_instance(), callback_type());
+  callback.WaitForResult(socket->Bind(address, callback.GetCallback()));
+  CHECK_CALLBACK_BEHAVIOR(callback);
+  ASSERT_EQ(PP_OK, callback.result());
   PASS();
 }
 
@@ -130,16 +122,11 @@ std::string TestUDPSocketPrivate::LookupPortAndBindUDPSocket(
 std::string TestUDPSocketPrivate::BindUDPSocketFailure(
     pp::UDPSocketPrivate* socket,
     PP_NetAddress_Private *address) {
-  TestCompletionCallback callback(instance_->pp_instance(), force_async_);
-  int32_t rv = socket->Bind(address, callback.GetCallback());
-  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
-    return ReportError("PPB_UDPSocket_Private::Bind force_async", rv);
-  if (rv == PP_OK_COMPLETIONPENDING)
-    rv = callback.WaitForResult();
-  if (rv == PP_OK)
-    return ReportError("PPB_UDPSocket_Private::Bind", rv);
-  if (socket->GetBoundAddress(address))
-      return "PPB_UDPSocket_Private::GetBoundAddress: Failed";
+  TestCompletionCallback callback(instance_->pp_instance(), callback_type());
+  callback.WaitForResult(socket->Bind(address, callback.GetCallback()));
+  CHECK_CALLBACK_BEHAVIOR(callback);
+  ASSERT_NE(PP_OK, callback.result());
+  ASSERT_FALSE(socket->GetBoundAddress(address));
   PASS();
 }
 
@@ -148,14 +135,12 @@ std::string TestUDPSocketPrivate::ReadSocket(pp::UDPSocketPrivate* socket,
                                              size_t size,
                                              std::string* message) {
   std::vector<char> buffer(size);
-  TestCompletionCallback callback(instance_->pp_instance(), force_async_);
-  int32_t rv = socket->RecvFrom(&buffer[0], size, callback.GetCallback());
-  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
-    return ReportError("PPB_UDPSocket_Private::RecvFrom force_async", rv);
-  if (rv == PP_OK_COMPLETIONPENDING)
-    rv = callback.WaitForResult();
-  if (rv < 0 || size != static_cast<size_t>(rv))
-    return ReportError("PPB_UDPSocket_Private::RecvFrom", rv);
+  TestCompletionCallback callback(instance_->pp_instance(), callback_type());
+  callback.WaitForResult(
+      socket->RecvFrom(&buffer[0], size, callback.GetCallback()));
+  CHECK_CALLBACK_BEHAVIOR(callback);
+  ASSERT_FALSE(callback.result() < 0);
+  ASSERT_EQ(size, static_cast<size_t>(callback.result()));
   message->assign(buffer.begin(), buffer.end());
   PASS();
 }
@@ -164,20 +149,16 @@ std::string TestUDPSocketPrivate::PassMessage(pp::UDPSocketPrivate* target,
                                               pp::UDPSocketPrivate* source,
                                               PP_NetAddress_Private* address,
                                               const std::string& message) {
-  TestCompletionCallback callback(instance_->pp_instance(), force_async_);
+  TestCompletionCallback callback(instance_->pp_instance(), callback_type());
   int32_t rv = source->SendTo(message.c_str(), message.size(), address,
                               callback.GetCallback());
-  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
-    return ReportError("PPB_UDPSocket_Private::SendTo force_async", rv);
-
   std::string str;
   ASSERT_SUBTEST_SUCCESS(ReadSocket(target, address, message.size(), &str));
 
-  if (rv == PP_OK_COMPLETIONPENDING)
-    rv = callback.WaitForResult();
-  if (rv < 0 || message.size() != static_cast<size_t>(rv))
-    return ReportError("PPB_UDPSocket_Private::SendTo", rv);
-
+  callback.WaitForResult(rv);
+  CHECK_CALLBACK_BEHAVIOR(callback);
+  ASSERT_FALSE(callback.result() < 0);
+  ASSERT_EQ(message.size(), static_cast<size_t>(callback.result()));
   ASSERT_EQ(message, str);
   PASS();
 }
diff --git a/ppapi/tests/test_udp_socket_private_disallowed.cc b/ppapi/tests/test_udp_socket_private_disallowed.cc
index 655ed35..aaaeba1 100644
--- a/ppapi/tests/test_udp_socket_private_disallowed.cc
+++ b/ppapi/tests/test_udp_socket_private_disallowed.cc
@@ -36,14 +36,10 @@ std::string TestUDPSocketPrivateDisallowed::TestBind() {
     pp::NetAddressPrivate::GetAnyAddress(false, &addr);
 
     TestCompletionCallback callback(instance_->pp_instance());
-    int32_t rv = udp_socket_private_interface_->Bind(socket, &addr,
-        callback.GetCallback().pp_completion_callback());
-
-    if (PP_OK_COMPLETIONPENDING == rv)
-      rv = callback.WaitForResult();
-
-    if (PP_ERROR_FAILED != rv)
-      return "PPB_UDPSocket_Private can bind without allowing switch";
+    callback.WaitForResult(udp_socket_private_interface_->Bind(socket, &addr,
+        callback.GetCallback().pp_completion_callback()));
+    CHECK_CALLBACK_BEHAVIOR(callback);
+    ASSERT_EQ(PP_ERROR_FAILED, callback.result());
   }
   PASS();
 }
diff --git a/ppapi/tests/test_utils.cc b/ppapi/tests/test_utils.cc
index 06a4571..4d251d2 100644
--- a/ppapi/tests/test_utils.cc
+++ b/ppapi/tests/test_utils.cc
@@ -150,17 +150,6 @@ TestCompletionCallback::TestCompletionCallback(PP_Instance instance,
       delegate_(NULL) {
 }
 
-int32_t TestCompletionCallback::WaitForResult() {
-  PP_DCHECK(!wait_for_result_called_);
-  wait_for_result_called_ = true;
-  errors_.clear();
-  if (!have_result_) {
-    post_quit_task_ = true;
-    RunMessageLoop();
-  }
-  return result_;
-}
-
 void TestCompletionCallback::WaitForResult(int32_t result) {
   PP_DCHECK(!wait_for_result_called_);
   wait_for_result_called_ = true;
diff --git a/ppapi/tests/test_utils.h b/ppapi/tests/test_utils.h
index d18b2845..43d531d 100644
--- a/ppapi/tests/test_utils.h
+++ b/ppapi/tests/test_utils.h
@@ -93,14 +93,6 @@ class TestCompletionCallback {
   // The delegate will be reset when Reset() or GetCallback() is called.
   void SetDelegate(Delegate* delegate) { delegate_ = delegate; }
 
-  // Waits for the callback to be called and returns the
-  // result. Returns immediately if the callback was previously called
-  // and the result wasn't returned (i.e. each result value received
-  // by the callback is returned by WaitForResult() once and only
-  // once). DEPRECATED: Please use the one below.
-  // TODO(dmichael): Remove this one when all the tests are updated.
-  int32_t WaitForResult();
-
   // Wait for a result, given the return from the call which took this callback
   // as a parameter. If |result| is PP_OK_COMPLETIONPENDING, WaitForResult will
   // block until its callback has been invoked (in some cases, this will already