Revert 172261

> PPAPI: Convert FileIO tests to new style & test background threads
> 
> BUG=92909
> 
> 
> Review URL: https://chromiumcodereview.appspot.com/11421137

This fails consistently on the Linux debug test bot (see bug 92909 for details).

TBR=dmichael@chromium.org
BUG=92909
Review URL: https://codereview.chromium.org/11458005

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

6 files changed, 714 insertions, 472 deletions

diff --git a/ppapi/tests/test_case.h b/ppapi/tests/test_case.h
index e0910f5..b06f941 100644
--- a/ppapi/tests/test_case.h
+++ b/ppapi/tests/test_case.h
@@ -319,10 +319,9 @@ class TestCaseFactory {
 // Helper macros for checking values in tests, and returning a location
 // description of the test fails.
 #define ASSERT_TRUE(cmd) \
-  do { \
-    if (!(cmd)) \
-      return MakeFailureMessage(__FILE__, __LINE__, #cmd); \
-  } while (false)
+  if (!(cmd)) { \
+    return MakeFailureMessage(__FILE__, __LINE__, #cmd); \
+  }
 #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))
diff --git a/ppapi/tests/test_file_io.cc b/ppapi/tests/test_file_io.cc
index 1aae699..9f88f00 100644
--- a/ppapi/tests/test_file_io.cc
+++ b/ppapi/tests/test_file_io.cc
@@ -62,21 +62,21 @@ std::string ReportOpenError(int32_t open_flags) {
 int32_t ReadEntireFile(PP_Instance instance,
                        pp::FileIO* file_io,
                        int32_t offset,
-                       std::string* data,
-                       CallbackType callback_type) {
-  TestCompletionCallback callback(instance, callback_type);
+                       std::string* data) {
+  TestCompletionCallback callback(instance);
   char buf[256];
   int32_t read_offset = offset;
 
   for (;;) {
-    callback.WaitForResult(
-        file_io->Read(read_offset, buf, sizeof(buf), callback));
-    if (callback.result() < 0)
-      return callback.result();
-    if (callback.result() == 0)
+    int32_t rv = file_io->Read(read_offset, buf, sizeof(buf), callback);
+    if (rv == PP_OK_COMPLETIONPENDING)
+      rv = callback.WaitForResult();
+    if (rv < 0)
+      return rv;
+    if (rv == 0)
       break;
-    read_offset += callback.result();
-    data->append(buf, callback.result());
+    read_offset += rv;
+    data->append(buf, rv);
   }
 
   return PP_OK;
@@ -86,9 +86,9 @@ int32_t ReadToArrayEntireFile(PP_Instance instance,
                               pp::FileIO* file_io,
                               int32_t offset,
                               std::string* data,
-                              CallbackType callback_type) {
+                              bool force_async) {
   TestCompletionCallbackWithOutput< std::vector<char> > callback(
-      instance, callback_type);
+      instance, force_async);
 
   for (;;) {
     callback.WaitForResult(file_io->Read(offset, 256, callback));
@@ -108,23 +108,22 @@ int32_t ReadToArrayEntireFile(PP_Instance instance,
 int32_t WriteEntireBuffer(PP_Instance instance,
                           pp::FileIO* file_io,
                           int32_t offset,
-                          const std::string& data,
-                          CallbackType callback_type) {
-  TestCompletionCallback callback(instance, callback_type);
+                          const std::string& data) {
+  TestCompletionCallback callback(instance);
   int32_t write_offset = offset;
   const char* buf = data.c_str();
   int32_t size = data.size();
 
   while (write_offset < offset + size) {
-    callback.WaitForResult(file_io->Write(write_offset,
-                                          &buf[write_offset - offset],
-                                          size - write_offset + offset,
-                                          callback));
-    if (callback.result() < 0)
-      return callback.result();
-    if (callback.result() == 0)
+    int32_t rv = file_io->Write(write_offset, &buf[write_offset - offset],
+                                size - write_offset + offset, callback);
+    if (rv == PP_OK_COMPLETIONPENDING)
+      rv = callback.WaitForResult();
+    if (rv < 0)
+      return rv;
+    if (rv == 0)
       return PP_ERROR_FAILED;
-    write_offset += callback.result();
+    write_offset += rv;
   }
 
   return PP_OK;
@@ -137,15 +136,15 @@ bool TestFileIO::Init() {
 }
 
 void TestFileIO::RunTests(const std::string& filter) {
-  RUN_CALLBACK_TEST(TestFileIO, Open, filter);
-  RUN_CALLBACK_TEST(TestFileIO, ReadWriteSetLength, filter);
-  RUN_CALLBACK_TEST(TestFileIO, ReadToArrayWriteSetLength, filter);
-  RUN_CALLBACK_TEST(TestFileIO, TouchQuery, filter);
-  RUN_CALLBACK_TEST(TestFileIO, AbortCalls, filter);
-  RUN_CALLBACK_TEST(TestFileIO, ParallelReads, filter);
-  RUN_CALLBACK_TEST(TestFileIO, ParallelWrites, filter);
-  RUN_CALLBACK_TEST(TestFileIO, NotAllowMixedReadWrite, filter);
-  RUN_CALLBACK_TEST(TestFileIO, WillWriteWillSetLength, filter);
+  RUN_TEST_FORCEASYNC_AND_NOT(Open, filter);
+  RUN_TEST_FORCEASYNC_AND_NOT(ReadWriteSetLength, filter);
+  RUN_TEST_FORCEASYNC_AND_NOT(ReadToArrayWriteSetLength, filter);
+  RUN_TEST_FORCEASYNC_AND_NOT(TouchQuery, filter);
+  RUN_TEST_FORCEASYNC_AND_NOT(AbortCalls, filter);
+  RUN_TEST_FORCEASYNC_AND_NOT(ParallelReads, filter);
+  RUN_TEST_FORCEASYNC_AND_NOT(ParallelWrites, filter);
+  RUN_TEST_FORCEASYNC_AND_NOT(NotAllowMixedReadWrite, filter);
+  RUN_TEST_FORCEASYNC_AND_NOT(WillWriteWillSetLength, filter);
 
   // TODO(viettrungluu): add tests:
   //  - that PP_ERROR_PENDING is correctly returned
@@ -153,13 +152,17 @@ void TestFileIO::RunTests(const std::string& filter) {
 }
 
 std::string TestFileIO::TestOpen() {
-  TestCompletionCallback callback(instance_->pp_instance(), callback_type());
+  TestCompletionCallback callback(instance_->pp_instance(), force_async_);
 
   pp::FileSystem file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
   pp::FileRef file_ref(file_system, "/file_open");
-  callback.WaitForResult(file_system.Open(1024, callback));
-  CHECK_CALLBACK_BEHAVIOR(callback);
-  ASSERT_EQ(PP_OK, callback.result());
+  int32_t rv = file_system.Open(1024, callback);
+  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+    return ReportError("FileSystem::Open force_async", rv);
+  if (rv == PP_OK_COMPLETIONPENDING)
+    rv = callback.WaitForResult();
+  if (rv != PP_OK)
+    return ReportError("FileSystem::Open", rv);
 
   std::string result;
   result = MatchOpenExpectations(
@@ -247,106 +250,133 @@ std::string TestFileIO::TestOpen() {
 }
 
 std::string TestFileIO::TestReadWriteSetLength() {
-  TestCompletionCallback callback(instance_->pp_instance(), callback_type());
+  TestCompletionCallback callback(instance_->pp_instance(), force_async_);
 
   pp::FileSystem file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
   pp::FileRef file_ref(file_system, "/file_read_write_setlength");
-  callback.WaitForResult(file_system.Open(1024, callback));
-  CHECK_CALLBACK_BEHAVIOR(callback);
-  ASSERT_EQ(PP_OK, callback.result());
+  int32_t rv = file_system.Open(1024, callback);
+  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+    return ReportError("FileSystem::Open force_async", rv);
+  if (rv == PP_OK_COMPLETIONPENDING)
+    rv = callback.WaitForResult();
+  if (rv != PP_OK)
+    return ReportError("FileSystem::Open", rv);
 
   pp::FileIO file_io(instance_);
-  callback.WaitForResult(file_io.Open(file_ref,
-                                      PP_FILEOPENFLAG_CREATE |
-                                      PP_FILEOPENFLAG_TRUNCATE |
-                                      PP_FILEOPENFLAG_READ |
-                                      PP_FILEOPENFLAG_WRITE,
-                                      callback));
-  CHECK_CALLBACK_BEHAVIOR(callback);
-  ASSERT_EQ(PP_OK, callback.result());
+  rv = file_io.Open(file_ref,
+                    PP_FILEOPENFLAG_CREATE |
+                    PP_FILEOPENFLAG_TRUNCATE |
+                    PP_FILEOPENFLAG_READ |
+                    PP_FILEOPENFLAG_WRITE,
+                    callback);
+  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+    return ReportError("FileIO::Open force_async", rv);
+  if (rv == PP_OK_COMPLETIONPENDING)
+    rv = callback.WaitForResult();
+  if (rv != PP_OK)
+    return ReportError("FileIO::Open", rv);
 
   // Write something to the file.
-  int32_t rv = WriteEntireBuffer(instance_->pp_instance(), &file_io, 0,
-                                 "test_test", callback_type());
-  ASSERT_EQ(PP_OK, rv);
+  rv = WriteEntireBuffer(instance_->pp_instance(), &file_io, 0, "test_test");
+  if (rv != PP_OK)
+    return ReportError("FileIO::Write", rv);
 
-  // Attempt to read a negative number of bytes; it should fail.
+  // Check for failing read operation.
   char buf[256];
-  callback.WaitForResult(file_io.Read(0,
-                                      buf,
-                                      -1,
-                                      callback));
-  CHECK_CALLBACK_BEHAVIOR(callback);
-  ASSERT_EQ(PP_ERROR_FAILED, callback.result());
+  rv = file_io.Read(0, buf, -1,  // negative number of bytes to read
+                    callback);
+  if (rv == PP_OK_COMPLETIONPENDING)
+    rv = callback.WaitForResult();
+  if (rv != PP_ERROR_FAILED)
+    return ReportError("FileIO::Read", rv);
 
   // Read the entire file.
   std::string read_buffer;
-  rv = ReadEntireFile(instance_->pp_instance(), &file_io, 0, &read_buffer,
-                      callback_type());
-  ASSERT_EQ(PP_OK, rv);
-  ASSERT_EQ(std::string("test_test"), read_buffer);
+  rv = ReadEntireFile(instance_->pp_instance(), &file_io, 0, &read_buffer);
+  if (rv != PP_OK)
+    return ReportError("FileIO::Read", rv);
+  if (read_buffer != "test_test")
+    return ReportMismatch("FileIO::Read", read_buffer, "test_test");
 
   // Truncate the file.
-  callback.WaitForResult(file_io.SetLength(4, callback));
-  CHECK_CALLBACK_BEHAVIOR(callback);
-  ASSERT_EQ(PP_OK, callback.result());
+  rv = file_io.SetLength(4, callback);
+  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+    return ReportError("FileIO::SetLength force_async", rv);
+  if (rv == PP_OK_COMPLETIONPENDING)
+    rv = callback.WaitForResult();
+  if (rv != PP_OK)
+    return ReportError("FileIO::SetLength", rv);
 
   // Check the file contents.
   read_buffer.clear();
-  rv = ReadEntireFile(instance_->pp_instance(), &file_io, 0, &read_buffer,
-                      callback_type());
-  ASSERT_EQ(PP_OK, rv);
-  ASSERT_EQ(std::string("test"), read_buffer);
+  rv = ReadEntireFile(instance_->pp_instance(), &file_io, 0, &read_buffer);
+  if (rv != PP_OK)
+    return ReportError("FileIO::Read", rv);
+  if (read_buffer != "test")
+    return ReportMismatch("FileIO::Read", read_buffer, "test");
 
   // Try to read past the end of the file.
   read_buffer.clear();
-  rv = ReadEntireFile(instance_->pp_instance(), &file_io, 100, &read_buffer,
-                      callback_type());
-  ASSERT_EQ(PP_OK, rv);
-  ASSERT_TRUE(read_buffer.empty());
+  rv = ReadEntireFile(instance_->pp_instance(), &file_io, 100, &read_buffer);
+  if (rv != PP_OK)
+    return ReportError("FileIO::Read", rv);
+  if (!read_buffer.empty())
+    return ReportMismatch("FileIO::Read", read_buffer, "<empty string>");
 
   // Write past the end of the file. The file should be zero-padded.
-  rv = WriteEntireBuffer(instance_->pp_instance(), &file_io, 8, "test",
-                         callback_type());
-  ASSERT_EQ(PP_OK, rv);
+  rv = WriteEntireBuffer(instance_->pp_instance(), &file_io, 8, "test");
+  if (rv != PP_OK)
+    return ReportError("FileIO::Write", rv);
 
   // Check the contents of the file.
   read_buffer.clear();
-  rv = ReadEntireFile(instance_->pp_instance(), &file_io, 0, &read_buffer,
-                      callback_type());
-  ASSERT_EQ(PP_OK, rv);
-  ASSERT_EQ(std::string("test\0\0\0\0test", 12), read_buffer);
+  rv = ReadEntireFile(instance_->pp_instance(), &file_io, 0, &read_buffer);
+  if (rv != PP_OK)
+    return ReportError("FileIO::Read", rv);
+  if (read_buffer != std::string("test\0\0\0\0test", 12))
+    return ReportMismatch("FileIO::Read", read_buffer,
+                          std::string("test\0\0\0\0test", 12));
 
   // Extend the file.
-  callback.WaitForResult(file_io.SetLength(16, callback));
-  CHECK_CALLBACK_BEHAVIOR(callback);
-  ASSERT_EQ(PP_OK, callback.result());
+  rv = file_io.SetLength(16, callback);
+  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+    return ReportError("FileIO::SetLength force_async", rv);
+  if (rv == PP_OK_COMPLETIONPENDING)
+    rv = callback.WaitForResult();
+  if (rv != PP_OK)
+    return ReportError("FileIO::SetLength", rv);
 
   // Check the contents of the file.
   read_buffer.clear();
-  rv = ReadEntireFile(instance_->pp_instance(), &file_io, 0, &read_buffer,
-                      callback_type());
-  ASSERT_EQ(PP_OK, rv);
-  ASSERT_EQ(std::string("test\0\0\0\0test\0\0\0\0", 16), read_buffer);
+  rv = ReadEntireFile(instance_->pp_instance(), &file_io, 0, &read_buffer);
+  if (rv != PP_OK)
+    return ReportError("FileIO::Read", rv);
+  if (read_buffer != std::string("test\0\0\0\0test\0\0\0\0", 16))
+    return ReportMismatch("FileIO::Read", read_buffer,
+                          std::string("test\0\0\0\0test\0\0\0\0", 16));
 
   // Write in the middle of the file.
-  rv = WriteEntireBuffer(instance_->pp_instance(), &file_io, 4, "test",
-                         callback_type());
-  ASSERT_EQ(PP_OK, rv);
+  rv = WriteEntireBuffer(instance_->pp_instance(), &file_io, 4, "test");
+  if (rv != PP_OK)
+    return ReportError("FileIO::Write", rv);
 
   // Check the contents of the file.
   read_buffer.clear();
-  rv = ReadEntireFile(instance_->pp_instance(), &file_io, 0, &read_buffer,
-                      callback_type());
-  ASSERT_EQ(PP_OK, rv);
-  ASSERT_EQ(std::string("testtesttest\0\0\0\0", 16), read_buffer);
+  rv = ReadEntireFile(instance_->pp_instance(), &file_io, 0, &read_buffer);
+  if (rv != PP_OK)
+    return ReportError("FileIO::Read", rv);
+  if (read_buffer != std::string("testtesttest\0\0\0\0", 16))
+    return ReportMismatch("FileIO::Read", read_buffer,
+                          std::string("testtesttest\0\0\0\0", 16));
 
   // Read from the middle of the file.
   read_buffer.clear();
-  rv = ReadEntireFile(instance_->pp_instance(), &file_io, 4, &read_buffer,
-                      callback_type());
-  ASSERT_EQ(PP_OK, rv);
-  ASSERT_EQ(std::string("testtest\0\0\0\0", 12), read_buffer);
+  rv = ReadEntireFile(instance_->pp_instance(), &file_io, 4, &read_buffer);
+  if (rv != PP_OK)
+    return ReportError("FileIO::Read", rv);
+  if (read_buffer != std::string("testtest\0\0\0\0", 12))
+    return ReportMismatch("FileIO::Read", read_buffer,
+                          std::string("testtest\0\0\0\0", 12));
 
   PASS();
 }
@@ -355,149 +385,201 @@ std::string TestFileIO::TestReadWriteSetLength() {
 // API.  With this test case, we can make sure the two Read's have the same
 // behavior.
 std::string TestFileIO::TestReadToArrayWriteSetLength() {
-  if (callback_type() == PP_BLOCKING) {
-    // This test does not make sense for blocking callbacks.
-    PASS();
-  }
-  TestCompletionCallback callback(instance_->pp_instance(), callback_type());
+  TestCompletionCallback callback(instance_->pp_instance(), force_async_);
 
   pp::FileSystem file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
   pp::FileRef file_ref(file_system, "/file_read_write_setlength");
-  callback.WaitForResult(file_system.Open(1024, callback));
-  CHECK_CALLBACK_BEHAVIOR(callback);
-  ASSERT_EQ(PP_OK, callback.result());
+  int32_t rv = file_system.Open(1024, callback);
+  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+    return ReportError("FileSystem::Open force_async", rv);
+  if (rv == PP_OK_COMPLETIONPENDING)
+    rv = callback.WaitForResult();
+  if (rv != PP_OK)
+    return ReportError("FileSystem::Open", rv);
 
   pp::FileIO file_io(instance_);
-  callback.WaitForResult(file_io.Open(file_ref,
-                                      PP_FILEOPENFLAG_CREATE |
-                                      PP_FILEOPENFLAG_TRUNCATE |
-                                      PP_FILEOPENFLAG_READ |
-                                      PP_FILEOPENFLAG_WRITE,
-                                      callback));
-  CHECK_CALLBACK_BEHAVIOR(callback);
-  ASSERT_EQ(PP_OK, callback.result());
+  rv = file_io.Open(file_ref,
+                    PP_FILEOPENFLAG_CREATE |
+                    PP_FILEOPENFLAG_TRUNCATE |
+                    PP_FILEOPENFLAG_READ |
+                    PP_FILEOPENFLAG_WRITE,
+                    callback);
+  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+    return ReportError("FileIO::Open force_async", rv);
+  if (rv == PP_OK_COMPLETIONPENDING)
+    rv = callback.WaitForResult();
+  if (rv != PP_OK)
+    return ReportError("FileIO::Open", rv);
 
   // Write something to the file.
-  int32_t rv = WriteEntireBuffer(instance_->pp_instance(), &file_io, 0,
-                                 "test_test", callback_type());
-  ASSERT_EQ(PP_OK, rv);
+  rv = WriteEntireBuffer(instance_->pp_instance(), &file_io, 0, "test_test");
+  if (rv != PP_OK)
+    return ReportError("FileIO::Write", rv);
 
   TestCompletionCallbackWithOutput< std::vector<char> > callback2(
-      instance_->pp_instance(), callback_type());
-  // Attempt to read a negative number of bytes; it should fail.
-  callback2.WaitForResult(file_io.Read(0, -1, callback2));
+      instance_->pp_instance(), force_async_);
+  // Check for failing read operation.
+  callback2.WaitForResult(
+      file_io.Read(0, -1,  // negative number of bytes to read
+                   callback2));
   CHECK_CALLBACK_BEHAVIOR(callback2);
-  ASSERT_EQ(PP_ERROR_FAILED, callback2.result());
+  if (callback2.result() != PP_ERROR_FAILED)
+    return ReportError("FileIO::Read", callback2.result());
 
   // Read the entire file.
   std::string read_buffer;
   read_buffer.reserve(10);
   rv = ReadToArrayEntireFile(instance_->pp_instance(), &file_io, 0,
-                             &read_buffer, callback_type());
-  ASSERT_EQ(PP_OK, rv);
-  ASSERT_EQ(std::string("test_test"), read_buffer);
+                             &read_buffer, force_async_);
+  if (rv != PP_OK)
+    return ReportError("FileIO::Read", rv);
+  if (read_buffer != "test_test")
+    return ReportMismatch("FileIO::Read", read_buffer, "test_test");
 
   // Truncate the file.
-  callback.WaitForResult(file_io.SetLength(4, callback));
-  CHECK_CALLBACK_BEHAVIOR(callback);
-  ASSERT_EQ(PP_OK, rv);
+  rv = file_io.SetLength(4, callback);
+  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+    return ReportError("FileIO::SetLength force_async", rv);
+  if (rv == PP_OK_COMPLETIONPENDING)
+    rv = callback.WaitForResult();
+  if (rv != PP_OK)
+    return ReportError("FileIO::SetLength", rv);
 
   // Check the file contents.
   read_buffer.clear();
   rv = ReadToArrayEntireFile(instance_->pp_instance(), &file_io, 0,
-                             &read_buffer, callback_type());
-  ASSERT_EQ(PP_OK, rv);
-  ASSERT_EQ(std::string("test"), read_buffer);
+                             &read_buffer, force_async_);
+  if (rv != PP_OK)
+    return ReportError("FileIO::Read", rv);
+  if (read_buffer != "test")
+    return ReportMismatch("FileIO::Read", read_buffer, "test");
 
   // Try to read past the end of the file.
   read_buffer.clear();
   rv = ReadToArrayEntireFile(instance_->pp_instance(), &file_io, 100,
-                             &read_buffer, callback_type());
-  ASSERT_EQ(PP_OK, rv);
-  ASSERT_TRUE(read_buffer.empty());
+                             &read_buffer, force_async_);
+  if (rv != PP_OK)
+    return ReportError("FileIO::Read", rv);
+  if (!read_buffer.empty())
+    return ReportMismatch("FileIO::Read", read_buffer, "<empty string>");
 
   // Write past the end of the file. The file should be zero-padded.
-  rv = WriteEntireBuffer(instance_->pp_instance(), &file_io, 8, "test",
-                         callback_type());
-  ASSERT_EQ(PP_OK, rv);
+  rv = WriteEntireBuffer(instance_->pp_instance(), &file_io, 8, "test");
+  if (rv != PP_OK)
+    return ReportError("FileIO::Write", rv);
 
   // Check the contents of the file.
   read_buffer.clear();
   rv = ReadToArrayEntireFile(instance_->pp_instance(), &file_io, 0,
-                             &read_buffer, callback_type());
-  ASSERT_EQ(PP_OK, rv);
-  ASSERT_EQ(std::string("test\0\0\0\0test", 12), read_buffer);
+                             &read_buffer, force_async_);
+  if (rv != PP_OK)
+    return ReportError("FileIO::Read", rv);
+  if (read_buffer != std::string("test\0\0\0\0test", 12))
+    return ReportMismatch("FileIO::Read", read_buffer,
+                          std::string("test\0\0\0\0test", 12));
 
   // Extend the file.
-  callback.WaitForResult(file_io.SetLength(16, callback));
-  CHECK_CALLBACK_BEHAVIOR(callback);
-  ASSERT_EQ(PP_OK, callback.result());
+  rv = file_io.SetLength(16, callback);
+  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+    return ReportError("FileIO::SetLength force_async", rv);
+  if (rv == PP_OK_COMPLETIONPENDING)
+    rv = callback.WaitForResult();
+  if (rv != PP_OK)
+    return ReportError("FileIO::SetLength", rv);
 
   // Check the contents of the file.
   read_buffer.clear();
   rv = ReadToArrayEntireFile(instance_->pp_instance(), &file_io, 0,
-                             &read_buffer, callback_type());
-  ASSERT_EQ(PP_OK, rv);
-  ASSERT_EQ(std::string("test\0\0\0\0test\0\0\0\0", 16), read_buffer);
+                             &read_buffer, force_async_);
+  if (rv != PP_OK)
+    return ReportError("FileIO::Read", rv);
+  if (read_buffer != std::string("test\0\0\0\0test\0\0\0\0", 16))
+    return ReportMismatch("FileIO::Read", read_buffer,
+                          std::string("test\0\0\0\0test\0\0\0\0", 16));
 
   // Write in the middle of the file.
-  rv = WriteEntireBuffer(instance_->pp_instance(), &file_io, 4, "test",
-                         callback_type());
-  ASSERT_EQ(PP_OK, rv);
+  rv = WriteEntireBuffer(instance_->pp_instance(), &file_io, 4, "test");
+  if (rv != PP_OK)
+    return ReportError("FileIO::Write", rv);
 
   // Check the contents of the file.
   read_buffer.clear();
   rv = ReadToArrayEntireFile(instance_->pp_instance(), &file_io, 0,
-                             &read_buffer, callback_type());
-  ASSERT_EQ(PP_OK, rv);
-  ASSERT_EQ(std::string("testtesttest\0\0\0\0", 16), read_buffer);
+                             &read_buffer, force_async_);
+  if (rv != PP_OK)
+    return ReportError("FileIO::Read", rv);
+  if (read_buffer != std::string("testtesttest\0\0\0\0", 16))
+    return ReportMismatch("FileIO::Read", read_buffer,
+                          std::string("testtesttest\0\0\0\0", 16));
 
   // Read from the middle of the file.
   read_buffer.clear();
   rv = ReadToArrayEntireFile(instance_->pp_instance(), &file_io, 4,
-                             &read_buffer, callback_type());
-  ASSERT_EQ(PP_OK, rv);
-  ASSERT_EQ(std::string("testtest\0\0\0\0", 12), read_buffer);
+                             &read_buffer, force_async_);
+  if (rv != PP_OK)
+    return ReportError("FileIO::Read", rv);
+  if (read_buffer != std::string("testtest\0\0\0\0", 12))
+    return ReportMismatch("FileIO::Read", read_buffer,
+                          std::string("testtest\0\0\0\0", 12));
 
   PASS();
 }
 
 std::string TestFileIO::TestTouchQuery() {
-  TestCompletionCallback callback(instance_->pp_instance(), callback_type());
+  TestCompletionCallback callback(instance_->pp_instance(), force_async_);
 
   pp::FileSystem file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
-  callback.WaitForResult(file_system.Open(1024, callback));
-  CHECK_CALLBACK_BEHAVIOR(callback);
-  ASSERT_EQ(PP_OK, callback.result());
+  int32_t rv = file_system.Open(1024, callback);
+  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+    return ReportError("FileSystem::Open force_async", rv);
+  if (rv == PP_OK_COMPLETIONPENDING)
+    rv = callback.WaitForResult();
+  if (rv != PP_OK)
+    return ReportError("FileSystem::Open", rv);
 
   pp::FileRef file_ref(file_system, "/file_touch");
   pp::FileIO file_io(instance_);
-  callback.WaitForResult(file_io.Open(file_ref,
-                                      PP_FILEOPENFLAG_CREATE |
-                                      PP_FILEOPENFLAG_TRUNCATE |
-                                      PP_FILEOPENFLAG_WRITE,
-                                      callback));
-  CHECK_CALLBACK_BEHAVIOR(callback);
-  ASSERT_EQ(PP_OK, callback.result());
+  rv = file_io.Open(file_ref,
+                    PP_FILEOPENFLAG_CREATE |
+                    PP_FILEOPENFLAG_TRUNCATE |
+                    PP_FILEOPENFLAG_WRITE,
+                    callback);
+  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+    return ReportError("FileIO::Open force_async", rv);
+  if (rv == PP_OK_COMPLETIONPENDING)
+    rv = callback.WaitForResult();
+  if (rv != PP_OK)
+    return ReportError("FileIO::Open", rv);
 
   // Write some data to have a non-zero file size.
-  callback.WaitForResult(file_io.Write(0, "test", 4, callback));
-  CHECK_CALLBACK_BEHAVIOR(callback);
-  ASSERT_EQ(4, callback.result());
+  rv = file_io.Write(0, "test", 4, callback);
+  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+    return ReportError("FileIO::Write force_async", rv);
+  if (rv == PP_OK_COMPLETIONPENDING)
+    rv = callback.WaitForResult();
+  if (rv != 4)
+    return ReportError("FileIO::Write", rv);
 
   // last_access_time's granularity is 1 day
   // last_modified_time's granularity is 2 seconds
   const PP_Time last_access_time = 123 * 24 * 3600.0;
   const PP_Time last_modified_time = 246.0;
-  callback.WaitForResult(file_io.Touch(last_access_time, last_modified_time,
-                                       callback));
-  CHECK_CALLBACK_BEHAVIOR(callback);
-  ASSERT_EQ(PP_OK, callback.result());
+  rv = file_io.Touch(last_access_time, last_modified_time, callback);
+  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+    return ReportError("FileIO::Touch force_async", rv);
+  if (rv == PP_OK_COMPLETIONPENDING)
+    rv = callback.WaitForResult();
+  if (rv != PP_OK)
+    return ReportError("FileIO::Touch", rv);
 
   PP_FileInfo info;
-  callback.WaitForResult(file_io.Query(&info, callback));
-  CHECK_CALLBACK_BEHAVIOR(callback);
-  ASSERT_EQ(PP_OK, callback.result());
+  rv = file_io.Query(&info, callback);
+  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+    return ReportError("FileIO::Query force_async", rv);
+  if (rv == PP_OK_COMPLETIONPENDING)
+    rv = callback.WaitForResult();
+  if (rv != PP_OK)
+    return ReportError("FileIO::Query", rv);
 
   if ((info.size != 4) ||
       (info.type != PP_FILETYPE_REGULAR) ||
@@ -507,75 +589,99 @@ std::string TestFileIO::TestTouchQuery() {
     return "FileIO::Query() has returned bad data.";
 
   // Call |Query()| again, to make sure it works a second time.
-  callback.WaitForResult(file_io.Query(&info, callback));
-  CHECK_CALLBACK_BEHAVIOR(callback);
-  ASSERT_EQ(PP_OK, callback.result());
+  rv = file_io.Query(&info, callback);
+  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+    return ReportError("FileIO::Query force_async", rv);
+  if (rv == PP_OK_COMPLETIONPENDING)
+    rv = callback.WaitForResult();
+  if (rv != PP_OK)
+    return ReportError("FileIO::Query", rv);
 
   PASS();
 }
 
 std::string TestFileIO::TestAbortCalls() {
-  TestCompletionCallback callback(instance_->pp_instance(), callback_type());
+  TestCompletionCallback callback(instance_->pp_instance(), force_async_);
 
   pp::FileSystem file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
   pp::FileRef file_ref(file_system, "/file_abort_calls");
-  callback.WaitForResult(file_system.Open(1024, callback));
-  CHECK_CALLBACK_BEHAVIOR(callback);
-  ASSERT_EQ(PP_OK, callback.result());
-
-  int32_t rv = PP_ERROR_FAILED;
-  // First, create a file on which to do ops.
+  int32_t rv = file_system.Open(1024, callback);
+  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+    return ReportError("FileSystem::Open force_async", rv);
+  if (rv == PP_OK_COMPLETIONPENDING)
+    rv = callback.WaitForResult();
+  if (rv != PP_OK)
+    return ReportError("FileSystem::Open", rv);
+
+  // First, create a file which to do ops on.
   {
     pp::FileIO file_io(instance_);
-    callback.WaitForResult(
-        file_io.Open(file_ref,
-                     PP_FILEOPENFLAG_CREATE | PP_FILEOPENFLAG_WRITE,
-                     callback));
-    CHECK_CALLBACK_BEHAVIOR(callback);
-    ASSERT_EQ(PP_OK, callback.result());
+    rv = file_io.Open(file_ref,
+                      PP_FILEOPENFLAG_CREATE | PP_FILEOPENFLAG_WRITE,
+                      callback);
+    if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+      return ReportError("FileIO::Open force_async", rv);
+    if (rv == PP_OK_COMPLETIONPENDING)
+      rv = callback.WaitForResult();
+    if (rv != PP_OK)
+      return ReportError("FileIO::Open", rv);
 
     // N.B.: Should write at least 3 bytes.
-    rv = WriteEntireBuffer(instance_->pp_instance(), &file_io, 0,
-                           "foobarbazquux", callback_type());
-    ASSERT_EQ(PP_OK, rv);
+    rv = WriteEntireBuffer(instance_->pp_instance(),
+                           &file_io,
+                           0,
+                           "foobarbazquux");
+    if (rv != PP_OK)
+      return ReportError("FileIO::Write", rv);
   }
 
   // Abort |Open()|.
   {
+    callback.reset_run_count();
     rv = pp::FileIO(instance_)
-        .Open(file_ref, PP_FILEOPENFLAG_READ, callback);
+        .Open(file_ref, PP_FILEOPENFLAG_READ,callback);
+    if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+      return ReportError("FileIO::Open force_async", rv);
+    if (callback.run_count() > 0)
+      return "FileIO::Open ran callback synchronously.";
+    if (rv == PP_OK_COMPLETIONPENDING) {
+      rv = callback.WaitForResult();
+      if (rv != PP_ERROR_ABORTED)
+        return "FileIO::Open not aborted.";
+    } else if (rv != PP_OK) {
+      return ReportError("FileIO::Open", rv);
+    }
   }
-  callback.WaitForResult(rv);
-  CHECK_CALLBACK_BEHAVIOR(callback);
-  if (callback_type() == PP_BLOCKING)
-    ASSERT_EQ(callback.result(), PP_OK);
-  else
-    ASSERT_EQ(callback.result(), PP_ERROR_ABORTED);
 
   // Abort |Query()|.
   {
     PP_FileInfo info = { 0 };
-    // Save a copy and make sure |info| doesn't get written to if it is aborted.
-    PP_FileInfo info_copy;
-    memcpy(&info_copy, &info, sizeof(info));
     {
       pp::FileIO file_io(instance_);
-      callback.WaitForResult(file_io.Open(file_ref, PP_FILEOPENFLAG_READ,
-                                          callback));
-      CHECK_CALLBACK_BEHAVIOR(callback);
-      ASSERT_EQ(PP_OK, callback.result());
-
+      rv = file_io.Open(file_ref, PP_FILEOPENFLAG_READ, callback);
+      if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+        return ReportError("FileIO::Open force_async", rv);
+      if (rv == PP_OK_COMPLETIONPENDING)
+        rv = callback.WaitForResult();
+      if (rv != PP_OK)
+        return ReportError("FileIO::Open", rv);
+
+      callback.reset_run_count();
       rv = file_io.Query(&info, callback);
+      if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+        return ReportError("FileIO::Query force_async", rv);
     }  // Destroy |file_io|.
-    callback.WaitForResult(rv);
-    CHECK_CALLBACK_BEHAVIOR(callback);
-    if (callback_type() == PP_BLOCKING) {
-      ASSERT_EQ(callback.result(), PP_OK);
-      // The operation completed synchronously, so |info| should have changed.
-      ASSERT_NE(0, memcmp(&info_copy, &info, sizeof(info)));
-    } else {
-      ASSERT_EQ(callback.result(), PP_ERROR_ABORTED);
-      ASSERT_EQ(0, memcmp(&info_copy, &info, sizeof(info)));
+    if (rv == PP_OK_COMPLETIONPENDING) {
+      // Save a copy and make sure |info| doesn't get written to.
+      PP_FileInfo info_copy;
+      memcpy(&info_copy, &info, sizeof(info));
+      rv = callback.WaitForResult();
+      if (rv != PP_ERROR_ABORTED)
+        return "FileIO::Query not aborted.";
+      if (memcmp(&info_copy, &info, sizeof(info)) != 0)
+        return "FileIO::Query wrote data after resource destruction.";
+    } else if (rv != PP_OK) {
+      return ReportError("FileIO::Query", rv);
     }
   }
 
@@ -583,19 +689,26 @@ std::string TestFileIO::TestAbortCalls() {
   {
     {
       pp::FileIO file_io(instance_);
-      callback.WaitForResult(file_io.Open(file_ref, PP_FILEOPENFLAG_WRITE,
-                                          callback));
-      CHECK_CALLBACK_BEHAVIOR(callback);
-      ASSERT_EQ(PP_OK, callback.result());
-
+      rv = file_io.Open(file_ref, PP_FILEOPENFLAG_WRITE, callback);
+      if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+        return ReportError("FileIO::Open force_async", rv);
+      if (rv == PP_OK_COMPLETIONPENDING)
+        rv = callback.WaitForResult();
+      if (rv != PP_OK)
+        return ReportError("FileIO::Open", rv);
+
+      callback.reset_run_count();
       rv = file_io.Touch(0, 0, callback);
+      if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+        return ReportError("FileIO::Touch force_async", rv);
     }  // Destroy |file_io|.
-    callback.WaitForResult(rv);
-    CHECK_CALLBACK_BEHAVIOR(callback);
-    if (callback_type() == PP_BLOCKING)
-      ASSERT_EQ(callback.result(), PP_OK);
-    else
-      ASSERT_EQ(callback.result(), PP_ERROR_ABORTED);
+    if (rv == PP_OK_COMPLETIONPENDING) {
+      rv = callback.WaitForResult();
+      if (rv != PP_ERROR_ABORTED)
+        return "FileIO::Touch not aborted.";
+    } else if (rv != PP_OK) {
+      return ReportError("FileIO::Touch", rv);
+    }
   }
 
   // Abort |Read()|.
@@ -603,23 +716,30 @@ std::string TestFileIO::TestAbortCalls() {
     char buf[3] = { 0 };
     {
       pp::FileIO file_io(instance_);
-      callback.WaitForResult(file_io.Open(file_ref, PP_FILEOPENFLAG_READ,
-                                          callback));
-      CHECK_CALLBACK_BEHAVIOR(callback);
-      ASSERT_EQ(PP_OK, callback.result());
-
+      rv = file_io.Open(file_ref, PP_FILEOPENFLAG_READ, callback);
+      if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+        return ReportError("FileIO::Open force_async", rv);
+      if (rv == PP_OK_COMPLETIONPENDING)
+        rv = callback.WaitForResult();
+      if (rv != PP_OK)
+        return ReportError("FileIO::Open", rv);
+
+      callback.reset_run_count();
       rv = file_io.Read(0, buf, sizeof(buf), callback);
+      if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+        return ReportError("FileIO::Read force_async", rv);
     }  // Destroy |file_io|.
-    // Save a copy to make sure buf isn't written to in the async case.
-    char buf_copy[3];
-    memcpy(&buf_copy, &buf, sizeof(buf));
-    callback.WaitForResult(rv);
-    CHECK_CALLBACK_BEHAVIOR(callback);
-    if (callback_type() == PP_BLOCKING) {
-      ASSERT_EQ(callback.result(), sizeof(buf));
-    } else {
-      ASSERT_EQ(callback.result(), PP_ERROR_ABORTED);
-      ASSERT_EQ(0, memcmp(&buf_copy, &buf, sizeof(buf)));
+    if (rv == PP_OK_COMPLETIONPENDING) {
+      // Save a copy and make sure |buf| doesn't get written to.
+      char buf_copy[3];
+      memcpy(&buf_copy, &buf, sizeof(buf));
+      rv = callback.WaitForResult();
+      if (rv != PP_ERROR_ABORTED)
+        return "FileIO::Read not aborted.";
+      if (memcmp(&buf_copy, &buf, sizeof(buf)) != 0)
+        return "FileIO::Read wrote data after resource destruction.";
+    } else if (rv != PP_OK) {
+      return ReportError("FileIO::Read", rv);
     }
   }
 
@@ -628,38 +748,51 @@ std::string TestFileIO::TestAbortCalls() {
     char buf[3] = { 0 };
     {
       pp::FileIO file_io(instance_);
-      callback.WaitForResult(file_io.Open(file_ref, PP_FILEOPENFLAG_WRITE,
-                                          callback));
-      CHECK_CALLBACK_BEHAVIOR(callback);
-      ASSERT_EQ(PP_OK, callback.result());
-
+      rv = file_io.Open(file_ref, PP_FILEOPENFLAG_READ, callback);
+      if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+        return ReportError("FileIO::Open force_async", rv);
+      if (rv == PP_OK_COMPLETIONPENDING)
+        rv = callback.WaitForResult();
+      if (rv != PP_OK)
+        return ReportError("FileIO::Open", rv);
+
+      callback.reset_run_count();
       rv = file_io.Write(0, buf, sizeof(buf), callback);
+      if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+        return ReportError("FileIO::Write force_async", rv);
     }  // Destroy |file_io|.
-    callback.WaitForResult(rv);
-    CHECK_CALLBACK_BEHAVIOR(callback);
-    if (callback_type() == PP_BLOCKING)
-      ASSERT_EQ(callback.result(), sizeof(buf));
-    else
-      ASSERT_EQ(callback.result(), PP_ERROR_ABORTED);
+    if (rv == PP_OK_COMPLETIONPENDING) {
+      rv = callback.WaitForResult();
+      if (rv != PP_ERROR_ABORTED)
+        return "FileIO::Write not aborted.";
+    } else if (rv != PP_OK) {
+      return ReportError("FileIO::Write", rv);
+    }
   }
 
   // Abort |SetLength()|.
   {
     {
       pp::FileIO file_io(instance_);
-      callback.WaitForResult(file_io.Open(file_ref, PP_FILEOPENFLAG_READ,
-                                          callback));
-      CHECK_CALLBACK_BEHAVIOR(callback);
-      ASSERT_EQ(PP_OK, callback.result());
-
+      rv = file_io.Open(file_ref, PP_FILEOPENFLAG_READ, callback);
+      if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+        return ReportError("FileIO::Open force_async", rv);
+      if (rv == PP_OK_COMPLETIONPENDING)
+        rv = callback.WaitForResult();
+      if (rv != PP_OK)
+        return ReportError("FileIO::Open", rv);
+
+      callback.reset_run_count();
       rv = file_io.SetLength(3, callback);
+      if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+        return ReportError("FileIO::SetLength force_async", rv);
     }  // Destroy |file_io|.
-    callback.WaitForResult(rv);
-    CHECK_CALLBACK_BEHAVIOR(callback);
-    if (callback_type() == PP_BLOCKING) {
-      ASSERT_EQ(callback.result(), PP_OK);
-    } else {
-      ASSERT_EQ(callback.result(), PP_ERROR_ABORTED);
+    if (rv == PP_OK_COMPLETIONPENDING) {
+      rv = callback.WaitForResult();
+      if (rv != PP_ERROR_ABORTED)
+        return "FileIO::SetLength not aborted.";
+    } else if (rv != PP_OK) {
+      return ReportError("FileIO::SetLength", rv);
     }
   }
 
@@ -667,19 +800,25 @@ std::string TestFileIO::TestAbortCalls() {
   {
     {
       pp::FileIO file_io(instance_);
-      callback.WaitForResult(file_io.Open(file_ref, PP_FILEOPENFLAG_WRITE,
-                                          callback));
-      CHECK_CALLBACK_BEHAVIOR(callback);
-      ASSERT_EQ(PP_OK, callback.result());
-
+      rv = file_io.Open(file_ref, PP_FILEOPENFLAG_READ, callback);
+      if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+        return ReportError("FileIO::Open force_async", rv);
+      if (rv == PP_OK_COMPLETIONPENDING)
+        rv = callback.WaitForResult();
+      if (rv != PP_OK)
+        return ReportError("FileIO::Open", rv);
+
+      callback.reset_run_count();
       rv = file_io.Flush(callback);
+      if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+        return ReportError("FileIO::Flush force_async", rv);
     }  // Destroy |file_io|.
-    callback.WaitForResult(rv);
-    CHECK_CALLBACK_BEHAVIOR(callback);
-    if (callback_type() == PP_BLOCKING) {
-      ASSERT_EQ(callback.result(), PP_OK);
-    } else {
-      ASSERT_EQ(callback.result(), PP_ERROR_ABORTED);
+    if (rv == PP_OK_COMPLETIONPENDING) {
+      rv = callback.WaitForResult();
+      if (rv != PP_ERROR_ABORTED)
+        return "FileIO::Flush not aborted.";
+    } else if (rv != PP_OK) {
+      return ReportError("FileIO::Flush", rv);
     }
   }
 
@@ -690,33 +829,41 @@ std::string TestFileIO::TestAbortCalls() {
 }
 
 std::string TestFileIO::TestParallelReads() {
-  TestCompletionCallback callback(instance_->pp_instance(), callback_type());
+  TestCompletionCallback callback(instance_->pp_instance(), force_async_);
   pp::FileSystem file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
   pp::FileRef file_ref(file_system, "/file_parallel_reads");
-  callback.WaitForResult(file_system.Open(1024, callback));
-  CHECK_CALLBACK_BEHAVIOR(callback);
-  ASSERT_EQ(PP_OK, callback.result());
+  int32_t rv = file_system.Open(1024, callback);
+  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+    return ReportError("FileSystem::Open force_async", rv);
+  if (rv == PP_OK_COMPLETIONPENDING)
+    rv = callback.WaitForResult();
+  if (rv != PP_OK)
+    return ReportError("FileSystem::Open", rv);
 
   pp::FileIO file_io(instance_);
-  callback.WaitForResult(file_io.Open(file_ref,
-                                      PP_FILEOPENFLAG_CREATE |
-                                      PP_FILEOPENFLAG_TRUNCATE |
-                                      PP_FILEOPENFLAG_READ |
-                                      PP_FILEOPENFLAG_WRITE,
-                                      callback));
-  CHECK_CALLBACK_BEHAVIOR(callback);
-  ASSERT_EQ(PP_OK, callback.result());
+  rv = file_io.Open(file_ref,
+                    PP_FILEOPENFLAG_CREATE |
+                    PP_FILEOPENFLAG_TRUNCATE |
+                    PP_FILEOPENFLAG_READ |
+                    PP_FILEOPENFLAG_WRITE,
+                    callback);
+  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+    return ReportError("FileIO::Open force_async", rv);
+  if (rv == PP_OK_COMPLETIONPENDING)
+    rv = callback.WaitForResult();
+  if (rv != PP_OK)
+    return ReportError("FileIO::Open", rv);
 
   // Set up testing contents.
-  int32_t rv = WriteEntireBuffer(instance_->pp_instance(), &file_io, 0,
-                                 "abcdefghijkl", callback_type());
-  ASSERT_EQ(PP_OK, rv);
+  rv = WriteEntireBuffer(instance_->pp_instance(), &file_io, 0, "abcdefghijkl");
+  if (rv != PP_OK)
+    return ReportError("FileIO::Write", rv);
 
   // Parallel read operations.
   const char* border = "__border__";
   const int32_t border_size = strlen(border);
 
-  TestCompletionCallback callback_1(instance_->pp_instance(), callback_type());
+  TestCompletionCallback callback_1(instance_->pp_instance(), force_async_);
   int32_t read_offset_1 = 0;
   int32_t size_1 = 3;
   std::vector<char> extended_buf_1(border_size * 2 + size_1);
@@ -724,7 +871,7 @@ std::string TestFileIO::TestParallelReads() {
   memcpy(&extended_buf_1[0], border, border_size);
   memcpy(buf_1 + size_1, border, border_size);
 
-  TestCompletionCallback callback_2(instance_->pp_instance(), callback_type());
+  TestCompletionCallback callback_2(instance_->pp_instance(), force_async_);
   int32_t read_offset_2 = size_1;
   int32_t size_2 = 9;
   std::vector<char> extended_buf_2(border_size * 2 + size_2);
@@ -735,68 +882,91 @@ std::string TestFileIO::TestParallelReads() {
   int32_t rv_1 = PP_OK;
   int32_t rv_2 = PP_OK;
   while (size_1 >= 0 && size_2 >= 0 && size_1 + size_2 > 0) {
-    if (size_1 > 0)
+    if (size_1 > 0) {
       rv_1 = file_io.Read(read_offset_1, buf_1, size_1, callback_1);
-    if (size_2 > 0)
+      if (rv_1 != PP_OK_COMPLETIONPENDING)
+        return ReportError("FileIO::Read", rv_1);
+    }
+
+    if (size_2 > 0) {
       rv_2 = file_io.Read(read_offset_2, buf_2, size_2, callback_2);
+      if (rv_2 != PP_OK_COMPLETIONPENDING)
+        return ReportError("FileIO::Read", rv_2);
+    }
+
     if (size_1 > 0) {
-      callback_1.WaitForResult(rv_1);
-      CHECK_CALLBACK_BEHAVIOR(callback_1);
-      ASSERT_TRUE(callback_1.result() > 0);
-      read_offset_1 += callback_1.result();
-      buf_1 += callback_1.result();
-      size_1 -= callback_1.result();
+      rv_1 = callback_1.WaitForResult();
+      if (rv_1 <= 0)
+        return ReportError("FileIO::Read", rv_1);
+      read_offset_1 += rv_1;
+      buf_1 += rv_1;
+      size_1 -= rv_1;
     }
 
     if (size_2 > 0) {
-      callback_2.WaitForResult(rv_2);
-      CHECK_CALLBACK_BEHAVIOR(callback_2);
-      ASSERT_TRUE(callback_2.result() > 0);
-      read_offset_2 += callback_2.result();
-      buf_2 += callback_2.result();
-      size_2 -= callback_2.result();
+      rv_2 = callback_2.WaitForResult();
+      if (rv_2 <= 0)
+        return ReportError("FileIO::Read", rv_2);
+      read_offset_2 += rv_2;
+      buf_2 += rv_2;
+      size_2 -= rv_2;
     }
   }
 
-  // If |size_1| or |size_2| is not 0, we have invoked wrong callback(s).
-  ASSERT_EQ(0, size_1);
-  ASSERT_EQ(0, size_2);
+  // If |size_1| or |size_2| is less than 0, we have invoked wrong
+  // callback(s).
+  if (size_1 < 0 || size_2 < 0) {
+    return std::string(
+        "Parallel FileIO::Read operations have invoked wrong callbacks.");
+  }
 
   // Make sure every read operation writes into the correct buffer.
   const char expected_result_1[] = "__border__abc__border__";
   const char expected_result_2[] = "__border__defghijkl__border__";
-  ASSERT_TRUE(strncmp(&extended_buf_1[0], expected_result_1,
-                      strlen(expected_result_1)) == 0);
-  ASSERT_TRUE(strncmp(&extended_buf_2[0], expected_result_2,
-                      strlen(expected_result_2)) == 0);
+  if (strncmp(&extended_buf_1[0], expected_result_1,
+              strlen(expected_result_1)) != 0 ||
+      strncmp(&extended_buf_2[0], expected_result_2,
+              strlen(expected_result_2)) != 0) {
+    return std::string(
+        "Parallel FileIO::Read operations have written into wrong buffers.");
+  }
+
   PASS();
 }
 
 std::string TestFileIO::TestParallelWrites() {
-  TestCompletionCallback callback(instance_->pp_instance(), callback_type());
+  TestCompletionCallback callback(instance_->pp_instance(), force_async_);
   pp::FileSystem file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
   pp::FileRef file_ref(file_system, "/file_parallel_writes");
-  callback.WaitForResult(file_system.Open(1024, callback));
-  CHECK_CALLBACK_BEHAVIOR(callback);
-  ASSERT_EQ(PP_OK, callback.result());
+  int32_t rv = file_system.Open(1024, callback);
+  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+    return ReportError("FileSystem::Open force_async", rv);
+  if (rv == PP_OK_COMPLETIONPENDING)
+    rv = callback.WaitForResult();
+  if (rv != PP_OK)
+    return ReportError("FileSystem::Open", rv);
 
   pp::FileIO file_io(instance_);
-  callback.WaitForResult(file_io.Open(file_ref,
-                                      PP_FILEOPENFLAG_CREATE |
-                                      PP_FILEOPENFLAG_TRUNCATE |
-                                      PP_FILEOPENFLAG_READ |
-                                      PP_FILEOPENFLAG_WRITE,
-                                      callback));
-  CHECK_CALLBACK_BEHAVIOR(callback);
-  ASSERT_EQ(PP_OK, callback.result());
+  rv = file_io.Open(file_ref,
+                    PP_FILEOPENFLAG_CREATE |
+                    PP_FILEOPENFLAG_TRUNCATE |
+                    PP_FILEOPENFLAG_READ |
+                    PP_FILEOPENFLAG_WRITE,
+                    callback);
+  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+    return ReportError("FileIO::Open force_async", rv);
+  if (rv == PP_OK_COMPLETIONPENDING)
+    rv = callback.WaitForResult();
+  if (rv != PP_OK)
+    return ReportError("FileIO::Open", rv);
 
   // Parallel write operations.
-  TestCompletionCallback callback_1(instance_->pp_instance(), callback_type());
+  TestCompletionCallback callback_1(instance_->pp_instance(), force_async_);
   int32_t write_offset_1 = 0;
   const char* buf_1 = "abc";
   int32_t size_1 = strlen(buf_1);
 
-  TestCompletionCallback callback_2(instance_->pp_instance(), callback_type());
+  TestCompletionCallback callback_2(instance_->pp_instance(), force_async_);
   int32_t write_offset_2 = size_1;
   const char* buf_2 = "defghijkl";
   int32_t size_2 = strlen(buf_2);
@@ -804,181 +974,227 @@ std::string TestFileIO::TestParallelWrites() {
   int32_t rv_1 = PP_OK;
   int32_t rv_2 = PP_OK;
   while (size_1 >= 0 && size_2 >= 0 && size_1 + size_2 > 0) {
-    if (size_1 > 0)
+    if (size_1 > 0) {
       rv_1 = file_io.Write(write_offset_1, buf_1, size_1, callback_1);
-    if (size_2 > 0)
+      if (rv_1 != PP_OK_COMPLETIONPENDING)
+        return ReportError("FileIO::Write", rv_1);
+    }
+
+    if (size_2 > 0) {
       rv_2 = file_io.Write(write_offset_2, buf_2, size_2, callback_2);
+      if (rv_2 != PP_OK_COMPLETIONPENDING)
+        return ReportError("FileIO::Write", rv_2);
+    }
 
     if (size_1 > 0) {
-      callback_1.WaitForResult(rv_1);
-      CHECK_CALLBACK_BEHAVIOR(callback_1);
-      ASSERT_TRUE(callback_1.result() > 0);
-      write_offset_1 += callback_1.result();
-      buf_1 += callback_1.result();
-      size_1 -= callback_1.result();
+      rv_1 = callback_1.WaitForResult();
+      if (rv_1 <= 0)
+        return ReportError("FileIO::Write", rv_1);
+      write_offset_1 += rv_1;
+      buf_1 += rv_1;
+      size_1 -= rv_1;
     }
 
     if (size_2 > 0) {
-      callback_2.WaitForResult(rv_2);
-      CHECK_CALLBACK_BEHAVIOR(callback_2);
-      ASSERT_TRUE(callback_2.result() > 0);
-      write_offset_2 += callback_2.result();
-      buf_2 += callback_2.result();
-      size_2 -= callback_2.result();
+      rv_2 = callback_2.WaitForResult();
+      if (rv_2 <= 0)
+        return ReportError("FileIO::Write", rv_2);
+      write_offset_2 += rv_2;
+      buf_2 += rv_2;
+      size_2 -= rv_2;
     }
   }
 
-  // If |size_1| or |size_2| is not 0, we have invoked wrong callback(s).
-  ASSERT_EQ(0, size_1);
-  ASSERT_EQ(0, size_2);
+  // If |size_1| or |size_2| is less than 0, we have invoked wrong
+  // callback(s).
+  if (size_1 < 0 || size_2 < 0) {
+    return std::string(
+        "Parallel FileIO::Write operations have invoked wrong callbacks.");
+  }
 
   // Check the file contents.
   std::string read_buffer;
-  int32_t rv = ReadEntireFile(instance_->pp_instance(), &file_io, 0,
-                              &read_buffer, callback_type());
-  ASSERT_EQ(PP_OK, rv);
-  ASSERT_EQ(std::string("abcdefghijkl"), read_buffer);
+  rv = ReadEntireFile(instance_->pp_instance(), &file_io, 0, &read_buffer);
+  if (rv != PP_OK)
+    return ReportError("FileIO::Read", rv);
+  if (read_buffer != "abcdefghijkl")
+    return ReportMismatch("FileIO::Read", read_buffer, "abcdefghijkl");
 
   PASS();
 }
 
 std::string TestFileIO::TestNotAllowMixedReadWrite() {
-  if (callback_type() == PP_BLOCKING) {
-    // This test does not make sense for blocking callbacks.
-    PASS();
-  }
-  TestCompletionCallback callback(instance_->pp_instance(), callback_type());
+  TestCompletionCallback callback(instance_->pp_instance(), force_async_);
 
   pp::FileSystem file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
   pp::FileRef file_ref(file_system, "/file_not_allow_mixed_read_write");
-  callback.WaitForResult(file_system.Open(1024, callback));
-  CHECK_CALLBACK_BEHAVIOR(callback);
-  ASSERT_EQ(PP_OK, callback.result());
+  int32_t rv = file_system.Open(1024, callback);
+  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+    return ReportError("FileSystem::Open force_async", rv);
+  if (rv == PP_OK_COMPLETIONPENDING)
+    rv = callback.WaitForResult();
+  if (rv != PP_OK)
+    return ReportError("FileSystem::Open", rv);
 
   pp::FileIO file_io(instance_);
-  callback.WaitForResult(file_io.Open(file_ref,
-                                      PP_FILEOPENFLAG_CREATE |
-                                      PP_FILEOPENFLAG_TRUNCATE |
-                                      PP_FILEOPENFLAG_READ |
-                                      PP_FILEOPENFLAG_WRITE,
-                                      callback));
-  CHECK_CALLBACK_BEHAVIOR(callback);
-  ASSERT_EQ(PP_OK, callback.result());
-
-  TestCompletionCallback callback_1(instance_->pp_instance(), callback_type());
+  rv = file_io.Open(file_ref,
+                    PP_FILEOPENFLAG_CREATE |
+                    PP_FILEOPENFLAG_TRUNCATE |
+                    PP_FILEOPENFLAG_READ |
+                    PP_FILEOPENFLAG_WRITE,
+                    callback);
+  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+    return ReportError("FileIO::Open force_async", rv);
+  if (rv == PP_OK_COMPLETIONPENDING)
+    rv = callback.WaitForResult();
+  if (rv != PP_OK)
+    return ReportError("FileIO::Open", rv);
+
+  // Cannot read and write in parallel.
+  TestCompletionCallback callback_1(instance_->pp_instance(), force_async_);
   int32_t write_offset_1 = 0;
   const char* buf_1 = "mnopqrstuvw";
   int32_t rv_1 = file_io.Write(write_offset_1, buf_1, strlen(buf_1),
                                callback_1);
-  ASSERT_EQ(PP_OK_COMPLETIONPENDING, rv_1);
+  if (rv_1 != PP_OK_COMPLETIONPENDING)
+    return ReportError("FileIO::Write", rv_1);
 
-  TestCompletionCallback callback_2(instance_->pp_instance(), callback_type());
+  TestCompletionCallback callback_2(instance_->pp_instance(), force_async_);
   int32_t read_offset_2 = 4;
   char buf_2[3];
-  callback_2.WaitForResult(file_io.Read(read_offset_2, buf_2, sizeof(buf_2),
-                                        callback_2));
-  CHECK_CALLBACK_BEHAVIOR(callback_2);
-  ASSERT_EQ(PP_ERROR_INPROGRESS, callback_2.result());
-  callback_1.WaitForResult(rv_1);
-  CHECK_CALLBACK_BEHAVIOR(callback_1);
+  int32_t rv_2 = file_io.Read(read_offset_2, buf_2, sizeof(buf_2),
+                              callback_2);
+  if (force_async_ && rv_2 != PP_OK_COMPLETIONPENDING)
+    return ReportError("FileIO::Read force_async", rv_2);
+  if (rv_2 == PP_OK_COMPLETIONPENDING)
+    rv_2 = callback_2.WaitForResult();
+  if (rv_2 != PP_ERROR_INPROGRESS)
+    return ReportError("FileIO::Read", rv_2);
+  callback_1.WaitForResult();
 
   // Cannot query while a write is pending.
   rv_1 = file_io.Write(write_offset_1, buf_1, strlen(buf_1), callback_1);
   ASSERT_EQ(PP_OK_COMPLETIONPENDING, rv_1);
+  TestCompletionCallback callback_3(instance_->pp_instance(), force_async_);
   PP_FileInfo info;
-  callback_2.WaitForResult(file_io.Query(&info, callback_2));
-  CHECK_CALLBACK_BEHAVIOR(callback_2);
-  ASSERT_EQ(PP_ERROR_INPROGRESS, callback_2.result());
-  callback_1.WaitForResult(rv_1);
-  CHECK_CALLBACK_BEHAVIOR(callback_1);
+  int32_t rv_3 = file_io.Query(&info, callback_3);
+  if (rv_3 == PP_OK_COMPLETIONPENDING)
+    rv_3 = callback_3.WaitForResult();
+  if (rv_3 != PP_ERROR_INPROGRESS)
+    return ReportError("FileIO::Query", rv_3);
+  callback_1.WaitForResult();
 
   // Cannot touch while a write is pending.
   rv_1 = file_io.Write(write_offset_1, buf_1, strlen(buf_1), callback_1);
   ASSERT_EQ(PP_OK_COMPLETIONPENDING, rv_1);
-  callback_2.WaitForResult(file_io.Touch(1234.0, 5678.0, callback_2));
-  CHECK_CALLBACK_BEHAVIOR(callback_2);
-  ASSERT_EQ(PP_ERROR_INPROGRESS, callback_2.result());
-  callback_1.WaitForResult(rv_1);
-  CHECK_CALLBACK_BEHAVIOR(callback_1);
+  TestCompletionCallback callback_4(instance_->pp_instance(), force_async_);
+  int32_t rv_4 = file_io.Touch(1234.0, 5678.0, callback_4);
+  if (rv_4 == PP_OK_COMPLETIONPENDING)
+    rv_4 = callback_4.WaitForResult();
+  if (rv_4 != PP_ERROR_INPROGRESS)
+    return ReportError("FileIO::Touch", rv_4);
+  callback_1.WaitForResult();
 
   // Cannot set length while a write is pending.
   rv_1 = file_io.Write(write_offset_1, buf_1, strlen(buf_1), callback_1);
   ASSERT_EQ(PP_OK_COMPLETIONPENDING, rv_1);
-  callback_2.WaitForResult(file_io.SetLength(123, callback_2));
-  CHECK_CALLBACK_BEHAVIOR(callback_2);
-  ASSERT_EQ(PP_ERROR_INPROGRESS, callback_2.result());
-  callback_1.WaitForResult(rv_1);
-  CHECK_CALLBACK_BEHAVIOR(callback_1);
+  TestCompletionCallback callback_5(instance_->pp_instance(), force_async_);
+  int32_t rv_5 = file_io.SetLength(123, callback_5);
+  if (rv_5 == PP_OK_COMPLETIONPENDING)
+    rv_5 = callback_5.WaitForResult();
+  if (rv_5 != PP_ERROR_INPROGRESS)
+    return ReportError("FileIO::SetLength", rv_5);
+  callback_1.WaitForResult();
 
   PASS();
 }
 
 std::string TestFileIO::TestWillWriteWillSetLength() {
-  TestCompletionCallback callback(instance_->pp_instance(), callback_type());
+  TestCompletionCallback callback(instance_->pp_instance(), force_async_);
 
   pp::FileSystem file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
   pp::FileRef file_ref(file_system, "/file_will_write");
-  callback.WaitForResult(file_system.Open(1024, callback));
-  CHECK_CALLBACK_BEHAVIOR(callback);
-  ASSERT_EQ(PP_OK, callback.result());
+  int32_t rv = file_system.Open(1024, callback);
+  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+    return ReportError("FileSystem::Open force_async", rv);
+  if (rv == PP_OK_COMPLETIONPENDING)
+    rv = callback.WaitForResult();
+  if (rv != PP_OK)
+    return ReportError("FileSystem::Open", rv);
 
   pp::FileIO file_io(instance_);
-  callback.WaitForResult(file_io.Open(file_ref,
-                                      PP_FILEOPENFLAG_CREATE |
-                                      PP_FILEOPENFLAG_TRUNCATE |
-                                      PP_FILEOPENFLAG_READ |
-                                      PP_FILEOPENFLAG_WRITE,
-                                      callback));
-  CHECK_CALLBACK_BEHAVIOR(callback);
-  ASSERT_EQ(PP_OK, callback.result());
+  rv = file_io.Open(file_ref,
+                    PP_FILEOPENFLAG_CREATE |
+                    PP_FILEOPENFLAG_TRUNCATE |
+                    PP_FILEOPENFLAG_READ |
+                    PP_FILEOPENFLAG_WRITE,
+                    callback);
+  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+    return ReportError("FileIO::Open force_async", rv);
+  if (rv == PP_OK_COMPLETIONPENDING)
+    rv = callback.WaitForResult();
+  if (rv != PP_OK)
+    return ReportError("FileIO::Open", rv);
 
   const PPB_FileIOTrusted* trusted = static_cast<const PPB_FileIOTrusted*>(
       pp::Module::Get()->GetBrowserInterface(PPB_FILEIOTRUSTED_INTERFACE));
-  ASSERT_TRUE(trusted);
+  if (!trusted)
+    return ReportError("FileIOTrusted", PP_ERROR_FAILED);
 
   // Get file descriptor. This is only supported in-process for now, so don't
   // test out of process.
   const PPB_Testing_Dev* testing_interface = GetTestingInterface();
   if (testing_interface && !testing_interface->IsOutOfProcess()) {
     int32_t fd = trusted->GetOSFileDescriptor(file_io.pp_resource());
-    ASSERT_TRUE(fd >= 0);
+    if (fd < 0)
+      return "FileIO::GetOSFileDescriptor() returned a bad file descriptor.";
   }
 
   // Calling WillWrite.
-  callback.WaitForResult(trusted->WillWrite(
+  rv = trusted->WillWrite(
       file_io.pp_resource(), 0, 9,
-      callback.GetCallback().pp_completion_callback()));
-  CHECK_CALLBACK_BEHAVIOR(callback);
-  ASSERT_EQ(9, callback.result());
+      static_cast<pp::CompletionCallback>(callback).pp_completion_callback());
+  if (rv == PP_OK_COMPLETIONPENDING)
+    rv = callback.WaitForResult();
+  if (rv != 9)
+    return ReportError("WillWrite", rv);
 
   // Writing the actual data.
-  int32_t rv = WriteEntireBuffer(instance_->pp_instance(), &file_io, 0,
-                                 "test_test", callback_type());
-  ASSERT_EQ(PP_OK, rv);
+  rv = WriteEntireBuffer(instance_->pp_instance(), &file_io, 0, "test_test");
+  if (rv != PP_OK)
+    return ReportError("FileIO::Write", rv);
 
   std::string read_buffer;
-  rv = ReadEntireFile(instance_->pp_instance(), &file_io, 0, &read_buffer,
-                      callback_type());
-  ASSERT_EQ(PP_OK, rv);
-  ASSERT_EQ(std::string("test_test"), read_buffer);
+  rv = ReadEntireFile(instance_->pp_instance(), &file_io, 0, &read_buffer);
+  if (rv != PP_OK)
+    return ReportError("FileIO::Read", rv);
+  if (read_buffer != "test_test")
+    return ReportMismatch("FileIO::Read", read_buffer, "test_test");
 
   // Calling WillSetLength.
-  callback.WaitForResult(trusted->WillSetLength(
+  rv = trusted->WillSetLength(
       file_io.pp_resource(), 4,
-      callback.GetCallback().pp_completion_callback()));
-  CHECK_CALLBACK_BEHAVIOR(callback);
-  ASSERT_EQ(PP_OK, rv);
+      static_cast<pp::CompletionCallback>(callback).pp_completion_callback());
+  if (rv == PP_OK_COMPLETIONPENDING)
+    rv = callback.WaitForResult();
+  if (rv != PP_OK)
+    return ReportError("WillSetLength", rv);
 
   // Calling actual SetLength.
-  callback.WaitForResult(file_io.SetLength(4, callback));
-  CHECK_CALLBACK_BEHAVIOR(callback);
-  ASSERT_EQ(PP_OK, rv);
+  rv = file_io.SetLength(4, callback);
+  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+    return ReportError("FileIO::SetLength force_async", rv);
+  if (rv == PP_OK_COMPLETIONPENDING)
+    rv = callback.WaitForResult();
+  if (rv != PP_OK)
+    return ReportError("FileIO::SetLength", rv);
 
   read_buffer.clear();
-  rv = ReadEntireFile(instance_->pp_instance(), &file_io, 0, &read_buffer,
-                      callback_type());
-  ASSERT_EQ(PP_OK, rv);
-  ASSERT_EQ(std::string("test"), read_buffer);
+  rv = ReadEntireFile(instance_->pp_instance(), &file_io, 0, &read_buffer);
+  if (rv != PP_OK)
+    return ReportError("FileIO::Read", rv);
+  if (read_buffer != "test")
+    return ReportMismatch("FileIO::Read", read_buffer, "test");
 
   PASS();
 }
@@ -1005,7 +1221,7 @@ std::string TestFileIO::MatchOpenExpectations(pp::FileSystem* file_system,
   bool open_if_exists = !!(expectations & OPEN_IF_EXISTS);
   bool truncate_if_exists = !!(expectations & TRUNCATE_IF_EXISTS);
 
-  TestCompletionCallback callback(instance_->pp_instance(), callback_type());
+  TestCompletionCallback callback(instance_->pp_instance(), force_async_);
   pp::FileRef existent_file_ref(
       *file_system, "/match_open_expectation_existent_non_empty_file");
   pp::FileRef nonexistent_file_ref(
@@ -1013,53 +1229,72 @@ std::string TestFileIO::MatchOpenExpectations(pp::FileSystem* file_system,
 
   // Setup files for test.
   {
-    callback.WaitForResult(existent_file_ref.Delete(callback));
-    CHECK_CALLBACK_BEHAVIOR(callback);
-    ASSERT_TRUE(callback.result() == PP_OK ||
-                callback.result() == PP_ERROR_FILENOTFOUND);
-    callback.WaitForResult(nonexistent_file_ref.Delete(callback));
-    CHECK_CALLBACK_BEHAVIOR(callback);
-    ASSERT_TRUE(callback.result() == PP_OK ||
-                callback.result() == PP_ERROR_FILENOTFOUND);
+    int32_t rv = existent_file_ref.Delete(callback);
+    if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+      return ReportError("FileRef::Delete force_async", rv);
+    if (rv == PP_OK_COMPLETIONPENDING)
+      rv = callback.WaitForResult();
+    if (rv != PP_OK && rv != PP_ERROR_FILENOTFOUND)
+      return ReportError("FileRef::Delete", rv);
+
+    rv = nonexistent_file_ref.Delete(callback);
+    if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+      return ReportError("FileRef::Delete force_async", rv);
+    if (rv == PP_OK_COMPLETIONPENDING)
+      rv = callback.WaitForResult();
+    if (rv != PP_OK && rv != PP_ERROR_FILENOTFOUND)
+      return ReportError("FileRef::Delete", rv);
 
     pp::FileIO existent_file_io(instance_);
-    callback.WaitForResult(existent_file_io.Open(
-        existent_file_ref,
-        PP_FILEOPENFLAG_CREATE | PP_FILEOPENFLAG_WRITE,
-        callback));
-    CHECK_CALLBACK_BEHAVIOR(callback);
-    ASSERT_EQ(PP_OK, callback.result());
-    int32_t rv = WriteEntireBuffer(instance_->pp_instance(), &existent_file_io,
-                                   0, "foobar", callback_type());
-    ASSERT_EQ(PP_OK, rv);
+    rv = existent_file_io.Open(existent_file_ref,
+                               PP_FILEOPENFLAG_CREATE | PP_FILEOPENFLAG_WRITE,
+                               callback);
+    if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+      return ReportError("FileIO::Open force_async", rv);
+    if (rv == PP_OK_COMPLETIONPENDING)
+      rv = callback.WaitForResult();
+    if (rv != PP_OK)
+      return ReportError("FileIO::Open", rv);
+
+    rv = WriteEntireBuffer(instance_->pp_instance(), &existent_file_io, 0,
+                           "foobar");
+    if (rv != PP_OK)
+      return ReportError("FileIO::Write", rv);
   }
 
   pp::FileIO existent_file_io(instance_);
-  callback.WaitForResult(existent_file_io.Open(existent_file_ref, open_flags,
-                                               callback));
-  CHECK_CALLBACK_BEHAVIOR(callback);
-  if ((invalid_combination && callback.result() == PP_OK) ||
-      (!invalid_combination &&
-       ((callback.result() == PP_OK) != open_if_exists))) {
+  int32_t rv = existent_file_io.Open(existent_file_ref, open_flags, callback);
+  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+    return ReportError("FileIO::Open force_async", rv);
+  if (rv == PP_OK_COMPLETIONPENDING)
+    rv = callback.WaitForResult();
+  if ((invalid_combination && rv == PP_OK) ||
+      (!invalid_combination && ((rv == PP_OK) != open_if_exists))) {
     return ReportOpenError(open_flags);
   }
 
   if (!invalid_combination && open_if_exists) {
     PP_FileInfo info;
-    callback.WaitForResult(existent_file_io.Query(&info, callback));
-    CHECK_CALLBACK_BEHAVIOR(callback);
-    ASSERT_EQ(PP_OK, callback.result());
+    rv = existent_file_io.Query(&info, callback);
+    if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+      return ReportError("FileIO::Query force_async", rv);
+    if (rv == PP_OK_COMPLETIONPENDING)
+      rv = callback.WaitForResult();
+    if (rv != PP_OK)
+      return ReportError("FileIO::Query", rv);
+
     if (truncate_if_exists != (info.size == 0))
       return ReportOpenError(open_flags);
   }
 
   pp::FileIO nonexistent_file_io(instance_);
-  callback.WaitForResult(nonexistent_file_io.Open(nonexistent_file_ref,
-                                                  open_flags, callback));
-  CHECK_CALLBACK_BEHAVIOR(callback);
-  if ((invalid_combination && callback.result() == PP_OK) ||
-      (!invalid_combination &&
-       ((callback.result() == PP_OK) != create_if_doesnt_exist))) {
+  rv = nonexistent_file_io.Open(nonexistent_file_ref, open_flags, callback);
+  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+    return ReportError("FileIO::Open force_async", rv);
+  if (rv == PP_OK_COMPLETIONPENDING)
+    rv = callback.WaitForResult();
+  if ((invalid_combination && rv == PP_OK) ||
+      (!invalid_combination && ((rv == PP_OK) != create_if_doesnt_exist))) {
     return ReportOpenError(open_flags);
   }
 
diff --git a/ppapi/tests/test_url_request.cc b/ppapi/tests/test_url_request.cc
index fd904db..00e6d2e 100644
--- a/ppapi/tests/test_url_request.cc
+++ b/ppapi/tests/test_url_request.cc
@@ -111,7 +111,7 @@ std::string TestURLRequest::TestCreateAndIsURLRequestInfo() {
 
   // IsURLRequestInfo: Released URLRequestInfo resource -> false.
   ppb_core_interface_->ReleaseResource(url_request);
-  ASSERT_NE(PP_TRUE, ppb_url_request_interface_->IsURLRequestInfo(url_request));
+  ASSERT_NE(PP_TRUE, ppb_url_request_interface_->IsURLRequestInfo(url_request))
 
   return error;  // == PASS() if empty.
 }
diff --git a/ppapi/tests/test_utils.h b/ppapi/tests/test_utils.h
index 0869be6..09e0b94 100644
--- a/ppapi/tests/test_utils.h
+++ b/ppapi/tests/test_utils.h
@@ -178,14 +178,14 @@ class TestCompletionCallbackWithOutput : public TestCompletionCallback {
   explicit TestCompletionCallbackWithOutput(PP_Instance instance) :
     TestCompletionCallback(instance) {
   }
-  // We purposely don't define a force_async constructor, since force_async
-  // is going away. TODO(dmichael): remove this comment with force_async.
+
+  TestCompletionCallbackWithOutput(PP_Instance instance, bool force_async) :
+    TestCompletionCallback(instance, force_async) {
+  }
 
   TestCompletionCallbackWithOutput(PP_Instance instance,
                                    CallbackType callback_type) :
     TestCompletionCallback(instance, callback_type) {
-    // Callbacks with output don't make sense for blocking calls.
-    PP_DCHECK(callback_type != PP_BLOCKING);
   }
 
   pp::CompletionCallbackWithOutput<OutputT> GetCallbackWithOutput();
@@ -203,6 +203,14 @@ template <typename OutputT>
 pp::CompletionCallbackWithOutput<OutputT>
 TestCompletionCallbackWithOutput<OutputT>::GetCallbackWithOutput() {
   Reset();
+  if (callback_type_ == PP_BLOCKING) {
+    pp::CompletionCallbackWithOutput<OutputT> cc(
+        &TestCompletionCallback::Handler,
+        this,
+        &output_storage_);
+    return cc;
+  }
+
   target_loop_ = pp::MessageLoop::GetCurrent();
   pp::CompletionCallbackWithOutput<OutputT> cc(
         &TestCompletionCallback::Handler,
diff --git a/ppapi/tests/test_websocket.cc b/ppapi/tests/test_websocket.cc
index 56d6d84..d5dc486 100644
--- a/ppapi/tests/test_websocket.cc
+++ b/ppapi/tests/test_websocket.cc
@@ -1350,7 +1350,7 @@ std::string TestWebSocket::TestUtilityValidClose() {
     ASSERT_EQ(PP_ERROR_INPROGRESS, result);
     websocket.WaitForClosed();
     const std::vector<WebSocketEvent>& events = websocket.GetSeenEvents();
-    ASSERT_TRUE(events.size() == 2 || events.size() == 3);
+    ASSERT_TRUE(events.size() == 2 || events.size() == 3)
     int index = 0;
     if (events.size() == 3)
       ASSERT_EQ(WebSocketEvent::EVENT_OPEN, events[index++].event_type);
diff --git a/ppapi/thunk/enter.cc b/ppapi/thunk/enter.cc
index 030b945..296a8b4 100644
--- a/ppapi/thunk/enter.cc
+++ b/ppapi/thunk/enter.cc
@@ -133,8 +133,8 @@ void EnterBase::SetStateForCallbackError(bool report_error) {
       // the plugin won't expect any return code other than
       // PP_OK_COMPLETIONPENDING. So we crash to make the problem more obvious.
       if (callback_->is_required()) {
-        std::string message("Attempted to use a required callback, but there "
-                            "is no attached message loop on which to run the "
+        std::string message("Attempted to use a required callback, but there"
+                            "is no attached message loop on which to run the"
                             "callback.");
         PpapiGlobals::Get()->BroadcastLogWithSource(0, PP_LOGLEVEL_ERROR,
                                                     std::string(), message);