Add a flag field to PP_CompletionCallback to control if the callback should

always be invoked asynchronously on success or error or skipped if the
operation can complete synchronously without blocking. Keep the default
behavior as-is  until clients update their code. Bump revisions of all
interfaces that take callbacks as args. Update browser interface function
implementations and C++ layer to force callbacks if sync option is not set.
Change ppapi/tests to run tests involving callbacks with both flag options.

BUG=79376
TEST=ppapi_tests + bots
Review URL: http://codereview.chromium.org/6899055

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

13 files changed, 337 insertions, 103 deletions

diff --git a/ppapi/tests/arch_dependent_sizes_32.h b/ppapi/tests/arch_dependent_sizes_32.h
index f797494..34b6d86 100644
--- a/ppapi/tests/arch_dependent_sizes_32.h
+++ b/ppapi/tests/arch_dependent_sizes_32.h
@@ -15,7 +15,7 @@ PP_COMPILE_ASSERT_SIZE_IN_BYTES(GLintptr, 4);
 PP_COMPILE_ASSERT_SIZE_IN_BYTES(GLsizeiptr, 4);
 PP_COMPILE_ASSERT_SIZE_IN_BYTES(PP_CompletionCallback_Func, 4);
 PP_COMPILE_ASSERT_SIZE_IN_BYTES(PP_URLLoaderTrusted_StatusCallback, 4);
-PP_COMPILE_ASSERT_STRUCT_SIZE_IN_BYTES(PP_CompletionCallback, 8);
+PP_COMPILE_ASSERT_STRUCT_SIZE_IN_BYTES(PP_CompletionCallback, 12);
 PP_COMPILE_ASSERT_STRUCT_SIZE_IN_BYTES(PP_FileChooserOptions_Dev, 8);
 PP_COMPILE_ASSERT_STRUCT_SIZE_IN_BYTES(PP_Picture_Dev, 24);
 PP_COMPILE_ASSERT_STRUCT_SIZE_IN_BYTES(PP_VideoBitstreamBuffer_Dev, 12);
diff --git a/ppapi/tests/arch_dependent_sizes_64.h b/ppapi/tests/arch_dependent_sizes_64.h
index 378c5b3..302938a 100644
--- a/ppapi/tests/arch_dependent_sizes_64.h
+++ b/ppapi/tests/arch_dependent_sizes_64.h
@@ -15,7 +15,7 @@ PP_COMPILE_ASSERT_SIZE_IN_BYTES(GLintptr, 8);
 PP_COMPILE_ASSERT_SIZE_IN_BYTES(GLsizeiptr, 8);
 PP_COMPILE_ASSERT_SIZE_IN_BYTES(PP_CompletionCallback_Func, 8);
 PP_COMPILE_ASSERT_SIZE_IN_BYTES(PP_URLLoaderTrusted_StatusCallback, 8);
-PP_COMPILE_ASSERT_STRUCT_SIZE_IN_BYTES(PP_CompletionCallback, 16);
+PP_COMPILE_ASSERT_STRUCT_SIZE_IN_BYTES(PP_CompletionCallback, 24);
 PP_COMPILE_ASSERT_STRUCT_SIZE_IN_BYTES(PP_FileChooserOptions_Dev, 16);
 PP_COMPILE_ASSERT_STRUCT_SIZE_IN_BYTES(PP_Picture_Dev, 24);
 PP_COMPILE_ASSERT_STRUCT_SIZE_IN_BYTES(PP_VideoBitstreamBuffer_Dev, 12);
diff --git a/ppapi/tests/test_case.cc b/ppapi/tests/test_case.cc
index ec9f088..1d91ef5 100644
--- a/ppapi/tests/test_case.cc
+++ b/ppapi/tests/test_case.cc
@@ -11,7 +11,8 @@
 
 TestCase::TestCase(TestingInstance* instance)
     : instance_(instance),
-      testing_interface_(NULL) {
+      testing_interface_(NULL),
+      force_async_(false) {
 }
 
 TestCase::~TestCase() {
diff --git a/ppapi/tests/test_case.h b/ppapi/tests/test_case.h
index 5e77d0d..5ec4435 100644
--- a/ppapi/tests/test_case.h
+++ b/ppapi/tests/test_case.h
@@ -69,6 +69,9 @@ class TestCase {
   // NULL unless InitTestingInterface is called.
   const PPB_Testing_Dev* testing_interface_;
 
+  // Force asynchronous completion of any operation taking a callback.
+  bool force_async_;
+
  private:
   // Holds the test object, if any was retrieved from CreateTestObject.
   pp::Var test_object_;
@@ -114,10 +117,22 @@ class TestCaseFactory {
 
 // Helper macro for calling functions implementing specific tests in the
 // RunTest function. This assumes the function name is TestFoo where Foo is the
-// test name,
+// test |name|.
 #define RUN_TEST(name) \
+  force_async_ = false; \
   instance_->LogTest(#name, Test##name());
 
+// Like RUN_TEST above but forces functions taking callbacks to complete
+// asynchronously on success or error.
+#define RUN_TEST_FORCEASYNC(name) \
+  force_async_ = true; \
+  instance_->LogTest(#name"ForceAsync", Test##name());
+
+#define RUN_TEST_FORCEASYNC_AND_NOT(name) \
+  RUN_TEST_FORCEASYNC(name); \
+  RUN_TEST(name);
+
+
 // Helper macros for checking values in tests, and returning a location
 // description of the test fails.
 #define ASSERT_TRUE(cmd) \
diff --git a/ppapi/tests/test_directory_reader.cc b/ppapi/tests/test_directory_reader.cc
index 91996f3..874abcb 100644
--- a/ppapi/tests/test_directory_reader.cc
+++ b/ppapi/tests/test_directory_reader.cc
@@ -80,10 +80,12 @@ void TestDirectoryReader::RunTest() {
 }
 
 std::string TestDirectoryReader::TestGetNextFile() {
-  TestCompletionCallback callback(instance_->pp_instance());
+  TestCompletionCallback callback(instance_->pp_instance(), force_async_);
   pp::FileSystem_Dev file_system(
       instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
   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)
@@ -100,6 +102,8 @@ std::string TestDirectoryReader::TestGetNextFile() {
     return ReportError("DeleteDirectoryRecursively", rv);
 
   rv = test_dir.MakeDirectory(callback);
+  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+    return ReportError("FileRef::MakeDirectory force_async", rv);
   if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
@@ -113,6 +117,8 @@ std::string TestDirectoryReader::TestGetNextFile() {
 
     pp::FileIO_Dev file_io(instance_);
     rv = file_io.Open(file_ref, PP_FILEOPENFLAG_CREATE, 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)
@@ -128,6 +134,8 @@ std::string TestDirectoryReader::TestGetNextFile() {
     pp::FileRef_Dev file_ref(file_system, buffer);
 
     rv = file_ref.MakeDirectory(callback);
+    if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+      return ReportError("FileRef::MakeDirectory force_async", rv);
     if (rv == PP_OK_COMPLETIONPENDING)
       rv = callback.WaitForResult();
     if (rv != PP_OK)
@@ -144,6 +152,8 @@ std::string TestDirectoryReader::TestGetNextFile() {
     pp::DirectoryEntry_Dev entry;
     do {
       rv = directory_reader.GetNextEntry(&entry, callback);
+      if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+        return ReportError("DirectoryReader::GetNextEntry force_async", rv);
       if (rv == PP_OK_COMPLETIONPENDING)
         rv = callback.WaitForResult();
       if (rv != PP_OK)
@@ -188,6 +198,8 @@ std::string TestDirectoryReader::TestGetNextFile() {
     callback.reset_run_count();
     // Note that the directory reader will be deleted immediately.
     rv = pp::DirectoryReader_Dev(test_dir).GetNextEntry(&entry, callback);
+    if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+      return ReportError("DirectoryReader::GetNextEntry force_async", rv);
     if (callback.run_count() > 0)
       return "DirectoryReader::GetNextEntry ran callback synchronously.";
 
diff --git a/ppapi/tests/test_file_io.cc b/ppapi/tests/test_file_io.cc
index 423016a..c6c2d63 100644
--- a/ppapi/tests/test_file_io.cc
+++ b/ppapi/tests/test_file_io.cc
@@ -111,21 +111,25 @@ bool TestFileIO::Init() {
 }
 
 void TestFileIO::RunTest() {
-  RUN_TEST(Open);
-  RUN_TEST(ReadWriteSetLength);
-  RUN_TEST(TouchQuery);
-  RUN_TEST(AbortCalls);
+  RUN_TEST_FORCEASYNC_AND_NOT(Open);
+  RUN_TEST_FORCEASYNC_AND_NOT(ReadWriteSetLength);
+  RUN_TEST_FORCEASYNC_AND_NOT(TouchQuery);
+  RUN_TEST_FORCEASYNC_AND_NOT(TouchQuery);
+  RUN_TEST_FORCEASYNC_AND_NOT(AbortCalls);
+  RUN_TEST_FORCEASYNC_AND_NOT(AbortCalls);
   // TODO(viettrungluu): add tests:
   //  - that PP_ERROR_PENDING is correctly returned
   //  - that operations respect the file open modes (flags)
 }
 
 std::string TestFileIO::TestOpen() {
-  TestCompletionCallback callback(instance_->pp_instance());
+  TestCompletionCallback callback(instance_->pp_instance(), force_async_);
 
   pp::FileSystem_Dev file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
   pp::FileRef_Dev file_ref(file_system, "/file_open");
   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)
@@ -217,11 +221,13 @@ std::string TestFileIO::TestOpen() {
 }
 
 std::string TestFileIO::TestReadWriteSetLength() {
-  TestCompletionCallback callback(instance_->pp_instance());
+  TestCompletionCallback callback(instance_->pp_instance(), force_async_);
 
   pp::FileSystem_Dev file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
   pp::FileRef_Dev file_ref(file_system, "/file_read_write_setlength");
   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)
@@ -234,6 +240,8 @@ std::string TestFileIO::TestReadWriteSetLength() {
                     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)
@@ -254,6 +262,8 @@ std::string TestFileIO::TestReadWriteSetLength() {
 
   // Truncate the file.
   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)
@@ -291,6 +301,8 @@ std::string TestFileIO::TestReadWriteSetLength() {
 
   // Extend the file.
   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)
@@ -332,10 +344,12 @@ std::string TestFileIO::TestReadWriteSetLength() {
 }
 
 std::string TestFileIO::TestTouchQuery() {
-  TestCompletionCallback callback(instance_->pp_instance());
+  TestCompletionCallback callback(instance_->pp_instance(), force_async_);
 
   pp::FileSystem_Dev file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
   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)
@@ -348,6 +362,8 @@ std::string TestFileIO::TestTouchQuery() {
                     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)
@@ -355,6 +371,8 @@ std::string TestFileIO::TestTouchQuery() {
 
   // Write some data to have a non-zero file size.
   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)
@@ -365,41 +383,49 @@ std::string TestFileIO::TestTouchQuery() {
   const PP_Time last_access_time = 123 * 24 * 3600.0;
   const PP_Time last_modified_time = 246.0;
   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("FileSystem::Touch", rv);
+    return ReportError("FileIO::Touch", rv);
 
   PP_FileInfo_Dev info;
   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("FileSystem::Query", rv);
+    return ReportError("FileIO::Query", rv);
 
   if ((info.size != 4) ||
       (info.type != PP_FILETYPE_REGULAR) ||
       (info.system_type != PP_FILESYSTEMTYPE_LOCALTEMPORARY) ||
       (info.last_access_time != last_access_time) ||
       (info.last_modified_time != last_modified_time))
-    return "FileSystem::Query() has returned bad data.";
+    return "FileIO::Query() has returned bad data.";
 
   // Call |Query()| again, to make sure it works a second time.
   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("FileSystem::Query", rv);
+    return ReportError("FileIO::Query", rv);
 
   PASS();
 }
 
 std::string TestFileIO::TestAbortCalls() {
-  TestCompletionCallback callback(instance_->pp_instance());
+  TestCompletionCallback callback(instance_->pp_instance(), force_async_);
 
   pp::FileSystem_Dev file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
   pp::FileRef_Dev file_ref(file_system, "/file_abort_calls");
   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)
@@ -411,6 +437,8 @@ std::string TestFileIO::TestAbortCalls() {
     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)
@@ -430,6 +458,8 @@ std::string TestFileIO::TestAbortCalls() {
     callback.reset_run_count();
     rv = pp::FileIO_Dev(instance_)
         .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) {
@@ -447,6 +477,8 @@ std::string TestFileIO::TestAbortCalls() {
     {
       pp::FileIO_Dev file_io(instance_);
       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)
@@ -454,6 +486,8 @@ std::string TestFileIO::TestAbortCalls() {
 
       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|.
     if (rv == PP_OK_COMPLETIONPENDING) {
       // Save a copy and make sure |info| doesn't get written to.
@@ -474,6 +508,8 @@ std::string TestFileIO::TestAbortCalls() {
     {
       pp::FileIO_Dev file_io(instance_);
       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)
@@ -481,6 +517,8 @@ std::string TestFileIO::TestAbortCalls() {
 
       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|.
     if (rv == PP_OK_COMPLETIONPENDING) {
       rv = callback.WaitForResult();
@@ -497,6 +535,8 @@ std::string TestFileIO::TestAbortCalls() {
     {
       pp::FileIO_Dev file_io(instance_);
       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)
@@ -504,6 +544,8 @@ std::string TestFileIO::TestAbortCalls() {
 
       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|.
     if (rv == PP_OK_COMPLETIONPENDING) {
       // Save a copy and make sure |buf| doesn't get written to.
@@ -525,6 +567,8 @@ std::string TestFileIO::TestAbortCalls() {
     {
       pp::FileIO_Dev file_io(instance_);
       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)
@@ -532,6 +576,8 @@ std::string TestFileIO::TestAbortCalls() {
 
       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|.
     if (rv == PP_OK_COMPLETIONPENDING) {
       rv = callback.WaitForResult();
@@ -547,6 +593,8 @@ std::string TestFileIO::TestAbortCalls() {
     {
       pp::FileIO_Dev file_io(instance_);
       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)
@@ -554,6 +602,8 @@ std::string TestFileIO::TestAbortCalls() {
 
       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|.
     if (rv == PP_OK_COMPLETIONPENDING) {
       rv = callback.WaitForResult();
@@ -569,6 +619,8 @@ std::string TestFileIO::TestAbortCalls() {
     {
       pp::FileIO_Dev file_io(instance_);
       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)
@@ -576,6 +628,8 @@ std::string TestFileIO::TestAbortCalls() {
 
       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|.
     if (rv == PP_OK_COMPLETIONPENDING) {
       rv = callback.WaitForResult();
@@ -614,7 +668,7 @@ std::string TestFileIO::MatchOpenExpectations(pp::FileSystem_Dev* file_system,
   bool open_if_exists = !!(expectations & OPEN_IF_EXISTS);
   bool truncate_if_exists = !!(expectations & TRUNCATE_IF_EXISTS);
 
-  TestCompletionCallback callback(instance_->pp_instance());
+  TestCompletionCallback callback(instance_->pp_instance(), force_async_);
   pp::FileRef_Dev existent_file_ref(
       *file_system, "/match_open_expectation_existent_non_empty_file");
   pp::FileRef_Dev nonexistent_file_ref(
@@ -623,12 +677,16 @@ std::string TestFileIO::MatchOpenExpectations(pp::FileSystem_Dev* file_system,
   // Setup files for test.
   {
     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)
@@ -638,6 +696,8 @@ std::string TestFileIO::MatchOpenExpectations(pp::FileSystem_Dev* file_system,
     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)
@@ -651,6 +711,8 @@ std::string TestFileIO::MatchOpenExpectations(pp::FileSystem_Dev* file_system,
 
   pp::FileIO_Dev existent_file_io(instance_);
   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) ||
@@ -661,6 +723,8 @@ std::string TestFileIO::MatchOpenExpectations(pp::FileSystem_Dev* file_system,
   if (!invalid_combination && open_if_exists) {
     PP_FileInfo_Dev info;
     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)
@@ -672,6 +736,8 @@ std::string TestFileIO::MatchOpenExpectations(pp::FileSystem_Dev* file_system,
 
   pp::FileIO_Dev nonexistent_file_io(instance_);
   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) ||
diff --git a/ppapi/tests/test_file_ref.cc b/ppapi/tests/test_file_ref.cc
index 2fa8e5b..7ca032f 100644
--- a/ppapi/tests/test_file_ref.cc
+++ b/ppapi/tests/test_file_ref.cc
@@ -44,14 +44,14 @@ bool TestFileRef::Init() {
 }
 
 void TestFileRef::RunTest() {
-  RUN_TEST(GetFileSystemType);
-  RUN_TEST(GetName);
-  RUN_TEST(GetPath);
-  RUN_TEST(GetParent);
-  RUN_TEST(MakeDirectory);
-  RUN_TEST(QueryAndTouchFile);
-  RUN_TEST(DeleteFileAndDirectory);
-  RUN_TEST(RenameFileAndDirectory);
+  RUN_TEST_FORCEASYNC_AND_NOT(GetFileSystemType);
+  RUN_TEST_FORCEASYNC_AND_NOT(GetName);
+  RUN_TEST_FORCEASYNC_AND_NOT(GetPath);
+  RUN_TEST_FORCEASYNC_AND_NOT(GetParent);
+  RUN_TEST_FORCEASYNC_AND_NOT(MakeDirectory);
+  RUN_TEST_FORCEASYNC_AND_NOT(QueryAndTouchFile);
+  RUN_TEST_FORCEASYNC_AND_NOT(DeleteFileAndDirectory);
+  RUN_TEST_FORCEASYNC_AND_NOT(RenameFileAndDirectory);
 }
 
 std::string TestFileRef::TestGetFileSystemType() {
@@ -72,10 +72,12 @@ std::string TestFileRef::TestGetFileSystemType() {
   request.SetURL("test_url_loader_data/hello.txt");
   request.SetStreamToFile(true);
 
-  TestCompletionCallback callback(instance_->pp_instance());
+  TestCompletionCallback callback(instance_->pp_instance(), force_async_);
 
   pp::URLLoader loader(instance_);
   int32_t rv = loader.Open(request, callback);
+  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+    return ReportError("URLLoader::Open force_async", rv);
   if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
@@ -121,10 +123,12 @@ std::string TestFileRef::TestGetName() {
   request.SetURL("test_url_loader_data/hello.txt");
   request.SetStreamToFile(true);
 
-  TestCompletionCallback callback(instance_->pp_instance());
+  TestCompletionCallback callback(instance_->pp_instance(), force_async_);
 
   pp::URLLoader loader(instance_);
   int32_t rv = loader.Open(request, callback);
+  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+    return ReportError("URLLoader::Open force_async", rv);
   if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
@@ -165,10 +169,12 @@ std::string TestFileRef::TestGetPath() {
   request.SetURL("test_url_loader_data/hello.txt");
   request.SetStreamToFile(true);
 
-  TestCompletionCallback callback(instance_->pp_instance());
+  TestCompletionCallback callback(instance_->pp_instance(), force_async_);
 
   pp::URLLoader loader(instance_);
   int32_t rv = loader.Open(request, callback);
+  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+    return ReportError("URLLoader::Open force_async", rv);
   if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
@@ -220,10 +226,12 @@ std::string TestFileRef::TestGetParent() {
   request.SetURL("test_url_loader_data/hello.txt");
   request.SetStreamToFile(true);
 
-  TestCompletionCallback callback(instance_->pp_instance());
+  TestCompletionCallback callback(instance_->pp_instance(), force_async_);
 
   pp::URLLoader loader(instance_);
   int32_t rv = loader.Open(request, callback);
+  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+    return ReportError("URLLoader::Open force_async", rv);
   if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
@@ -244,11 +252,13 @@ std::string TestFileRef::TestGetParent() {
 }
 
 std::string TestFileRef::TestMakeDirectory() {
-  TestCompletionCallback callback(instance_->pp_instance());
+  TestCompletionCallback callback(instance_->pp_instance(), force_async_);
 
   // Open.
   pp::FileSystem_Dev file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
   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)
@@ -257,6 +267,8 @@ std::string TestFileRef::TestMakeDirectory() {
   // MakeDirectory.
   pp::FileRef_Dev dir_ref(file_system, "/test_dir_make_directory");
   rv = dir_ref.MakeDirectory(callback);
+  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+    return ReportError("FileSystem::MakeDirectory force_async", rv);
   if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
@@ -268,6 +280,8 @@ std::string TestFileRef::TestMakeDirectory() {
       .MakeDirectory(callback);
   if (callback.run_count() > 0)
     return "FileSystem::MakeDirectory ran callback synchronously.";
+  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+    return ReportError("FileSystem::MakeDirectory force_async", rv);
   if (rv == PP_OK_COMPLETIONPENDING) {
     rv = callback.WaitForResult();
     if (rv != PP_ERROR_ABORTED)
@@ -279,6 +293,8 @@ std::string TestFileRef::TestMakeDirectory() {
   // MakeDirectoryIncludingAncestors.
   dir_ref = pp::FileRef_Dev(file_system, "/dir_make_dir_1/dir_make_dir_2");
   rv = dir_ref.MakeDirectoryIncludingAncestors(callback);
+  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+    return ReportError("FileSystem::MakeDirectory force_async", rv);
   if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
@@ -292,6 +308,9 @@ std::string TestFileRef::TestMakeDirectory() {
     return "FileSystem::MakeDirectoryIncludingAncestors "
            "ran callback synchronously.";
   }
+  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+    return ReportError(
+        "FileSystem::MakeDirectoryIncludingAncestors force_async", rv);
   if (rv == PP_OK_COMPLETIONPENDING) {
     rv = callback.WaitForResult();
     if (rv != PP_ERROR_ABORTED)
@@ -303,6 +322,8 @@ std::string TestFileRef::TestMakeDirectory() {
   // MakeDirectory with nested path.
   dir_ref = pp::FileRef_Dev(file_system, "/dir_make_dir_3/dir_make_dir_4");
   rv = dir_ref.MakeDirectory(callback);
+  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+    return ReportError("FileSystem::MakeDirectory force_async", rv);
   if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv == PP_OK) {
@@ -314,9 +335,11 @@ std::string TestFileRef::TestMakeDirectory() {
 }
 
 std::string TestFileRef::TestQueryAndTouchFile() {
-  TestCompletionCallback callback(instance_->pp_instance());
+  TestCompletionCallback callback(instance_->pp_instance(), force_async_);
   pp::FileSystem_Dev file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
   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)
@@ -329,6 +352,8 @@ std::string TestFileRef::TestQueryAndTouchFile() {
                     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)
@@ -336,6 +361,8 @@ std::string TestFileRef::TestQueryAndTouchFile() {
 
   // Write some data to have a non-zero file size.
   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)
@@ -347,6 +374,8 @@ std::string TestFileRef::TestQueryAndTouchFile() {
   const PP_Time last_access_time = 123 * 24 * 3600.0;
   const PP_Time last_modified_time = 246.0;
   rv = file_ref.Touch(last_access_time, last_modified_time, callback);
+  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+    return ReportError("FileSystem::Touch force_async", rv);
   if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
@@ -358,6 +387,8 @@ std::string TestFileRef::TestQueryAndTouchFile() {
       .Touch(last_access_time, last_modified_time, callback);
   if (callback.run_count() > 0)
     return "FileSystem::Touch ran callback synchronously.";
+  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+    return ReportError("FileSystem::Touch force_async", rv);
   if (rv == PP_OK_COMPLETIONPENDING) {
     rv = callback.WaitForResult();
     if (rv != PP_ERROR_ABORTED)
@@ -369,6 +400,8 @@ std::string TestFileRef::TestQueryAndTouchFile() {
   // Query.
   PP_FileInfo_Dev info;
   rv = file_io.Query(&info, callback);
+  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+    return ReportError("FileSystem::Query force_async", rv);
   if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
@@ -389,6 +422,8 @@ std::string TestFileRef::TestQueryAndTouchFile() {
       last_access_time, last_modified_time, callback);
   if (callback.run_count() > 0)
     return "FileSystem::Touch ran callback synchronously.";
+  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+    return ReportError("FileSystem::Touch force_async", rv);
   if (rv == PP_OK_COMPLETIONPENDING) {
     rv = callback.WaitForResult();
     if (rv != PP_ERROR_ABORTED)
@@ -401,9 +436,11 @@ std::string TestFileRef::TestQueryAndTouchFile() {
 }
 
 std::string TestFileRef::TestDeleteFileAndDirectory() {
-  TestCompletionCallback callback(instance_->pp_instance());
+  TestCompletionCallback callback(instance_->pp_instance(), force_async_);
   pp::FileSystem_Dev file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
   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)
@@ -412,57 +449,73 @@ std::string TestFileRef::TestDeleteFileAndDirectory() {
   pp::FileRef_Dev file_ref(file_system, "/file_delete");
   pp::FileIO_Dev file_io(instance_);
   rv = file_io.Open(file_ref, PP_FILEOPENFLAG_CREATE, 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 = 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)
-    return ReportError("FileSystem::Delete", rv);
+    return ReportError("FileRef::Delete", rv);
 
   pp::FileRef_Dev dir_ref(file_system, "/dir_delete");
   rv = dir_ref.MakeDirectory(callback);
+  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+    return ReportError("FileRef::MakeDirectory force_async", rv);
   if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
-    return ReportError("FileSystem::MakeDirectory", rv);
+    return ReportError("FileRef::MakeDirectory", rv);
 
   rv = dir_ref.Delete(callback);
+  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+    return ReportError("FileRef::Open force_async", rv);
   if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
-    return ReportError("FileSystem::Delete", rv);
+    return ReportError("FileRef::Delete", rv);
 
   pp::FileRef_Dev nested_dir_ref(file_system, "/dir_delete_1/dir_delete_2");
   rv = nested_dir_ref.MakeDirectoryIncludingAncestors(callback);
+  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+    return ReportError("FileRef::Open force_async", rv);
   if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
-    return ReportError("FileSystem::MakeDirectoryIncludingAncestors", rv);
+    return ReportError("FileRef::MakeDirectoryIncludingAncestors", rv);
 
   // Hang on to a ref to the parent; otherwise the callback will be aborted.
   pp::FileRef_Dev parent_dir_ref = nested_dir_ref.GetParent();
   rv = parent_dir_ref.Delete(callback);
+  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+    return ReportError("FileRef::Open force_async", rv);
   if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_ERROR_FAILED)
-    return ReportError("FileSystem::Delete", rv);
+    return ReportError("FileRef::Delete", rv);
 
   pp::FileRef_Dev nonexistent_file_ref(file_system, "/nonexistent_file_delete");
   rv = nonexistent_file_ref.Delete(callback);
+  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+    return ReportError("FileRef::Open force_async", rv);
   if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_ERROR_FILENOTFOUND)
-    return ReportError("FileSystem::Delete", rv);
+    return ReportError("FileRef::Delete", rv);
 
   // Delete aborted.
   {
     pp::FileRef_Dev file_ref_abort(file_system, "/file_delete_abort");
     pp::FileIO_Dev file_io_abort(instance_);
     rv = file_io_abort.Open(file_ref_abort, PP_FILEOPENFLAG_CREATE, 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)
@@ -472,22 +525,26 @@ std::string TestFileRef::TestDeleteFileAndDirectory() {
     rv = file_ref_abort.Delete(callback);
   }
   if (callback.run_count() > 0)
-    return "FileSystem::Delete ran callback synchronously.";
+    return "FileRef::Delete ran callback synchronously.";
+  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+    return ReportError("FileRef::Open force_async", rv);
   if (rv == PP_OK_COMPLETIONPENDING) {
     rv = callback.WaitForResult();
     if (rv != PP_ERROR_ABORTED)
-      return "FileSystem::Delete not aborted.";
+      return "FileRef::Delete not aborted.";
   } else if (rv != PP_OK) {
-    return ReportError("FileSystem::Delete", rv);
+    return ReportError("FileRef::Delete", rv);
   }
 
   PASS();
 }
 
 std::string TestFileRef::TestRenameFileAndDirectory() {
-  TestCompletionCallback callback(instance_->pp_instance());
+  TestCompletionCallback callback(instance_->pp_instance(), force_async_);
   pp::FileSystem_Dev file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
   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)
@@ -496,6 +553,8 @@ std::string TestFileRef::TestRenameFileAndDirectory() {
   pp::FileRef_Dev file_ref(file_system, "/file_rename");
   pp::FileIO_Dev file_io(instance_);
   rv = file_io.Open(file_ref, PP_FILEOPENFLAG_CREATE, 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)
@@ -503,38 +562,48 @@ std::string TestFileRef::TestRenameFileAndDirectory() {
 
   pp::FileRef_Dev target_file_ref(file_system, "/target_file_rename");
   rv = file_ref.Rename(target_file_ref, callback);
+  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+    return ReportError("FileRef::Rename force_async", rv);
   if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
-    return ReportError("FileSystem::Rename", rv);
+    return ReportError("FileRef::Rename", rv);
 
   pp::FileRef_Dev dir_ref(file_system, "/dir_rename");
   rv = dir_ref.MakeDirectory(callback);
+  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+    return ReportError("FileRef::MakeDirectory force_async", rv);
   if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
-    return ReportError("FileSystem::MakeDirectory", rv);
+    return ReportError("FileRef::MakeDirectory", rv);
 
   pp::FileRef_Dev target_dir_ref(file_system, "/target_dir_rename");
   rv = dir_ref.Rename(target_dir_ref, callback);
+  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+    return ReportError("FileRef::Rename force_async", rv);
   if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
-    return ReportError("FileSystem::Rename", rv);
+    return ReportError("FileRef::Rename", rv);
 
   pp::FileRef_Dev nested_dir_ref(file_system, "/dir_rename_1/dir_rename_2");
   rv = nested_dir_ref.MakeDirectoryIncludingAncestors(callback);
+  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+    return ReportError("FileRef::MakeDirectory force_async", rv);
   if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
-    return ReportError("FileSystem::MakeDirectoryIncludingAncestors", rv);
+    return ReportError("FileRef::MakeDirectoryIncludingAncestors", rv);
 
   pp::FileRef_Dev target_nested_dir_ref(file_system, "/dir_rename_1");
   rv = nested_dir_ref.Rename(target_nested_dir_ref, callback);
+  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+    return ReportError("FileRef::Open force_async", rv);
   if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_ERROR_FAILED)
-    return ReportError("FileSystem::Rename", rv);
+    return ReportError("FileRef::Rename", rv);
 
   // Rename aborted.
   // TODO(viettrungluu): Figure out what we want to do if the target file
@@ -545,6 +614,8 @@ std::string TestFileRef::TestRenameFileAndDirectory() {
     pp::FileRef_Dev file_ref_abort(file_system, "/file_rename_abort");
     pp::FileIO_Dev file_io_abort(instance_);
     rv = file_io_abort.Open(file_ref_abort, PP_FILEOPENFLAG_CREATE, 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)
@@ -555,6 +626,8 @@ std::string TestFileRef::TestRenameFileAndDirectory() {
   }
   if (callback.run_count() > 0)
     return "FileSystem::Rename ran callback synchronously.";
+  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+    return ReportError("FileSystem::Rename force_async", rv);
   if (rv == PP_OK_COMPLETIONPENDING) {
     rv = callback.WaitForResult();
     if (rv != PP_ERROR_ABORTED)
diff --git a/ppapi/tests/test_file_system.cc b/ppapi/tests/test_file_system.cc
index 7758f5f..fe5c902 100644
--- a/ppapi/tests/test_file_system.cc
+++ b/ppapi/tests/test_file_system.cc
@@ -18,12 +18,12 @@ bool TestFileSystem::Init() {
 }
 
 void TestFileSystem::RunTest() {
-  RUN_TEST(Open);
-  RUN_TEST(MultipleOpens);
+  RUN_TEST_FORCEASYNC_AND_NOT(Open);
+  RUN_TEST_FORCEASYNC_AND_NOT(MultipleOpens);
 }
 
 std::string TestFileSystem::TestOpen() {
-  TestCompletionCallback callback(instance_->pp_instance());
+  TestCompletionCallback callback(instance_->pp_instance(), force_async_);
 
   // Open.
   pp::FileSystem_Dev file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
@@ -39,6 +39,8 @@ std::string TestFileSystem::TestOpen() {
       .Open(1024, callback);
   if (callback.run_count() > 0)
     return "FileSystem::Open ran callback synchronously.";
+  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_ERROR_ABORTED)
@@ -53,27 +55,32 @@ std::string TestFileSystem::TestOpen() {
 std::string TestFileSystem::TestMultipleOpens() {
   // Should not allow multiple opens, no matter the first open has completed or
   // not.
-  TestCompletionCallback callback_1(instance_->pp_instance());
+  TestCompletionCallback callback_1(instance_->pp_instance(), force_async_);
   pp::FileSystem_Dev file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
   int32_t rv_1 = file_system.Open(1024, callback_1);
   if (callback_1.run_count() > 0)
-    return "FileSystem::Open ran callback synchronously.";
+    return "FileSystem::Open1 ran callback synchronously.";
+  if (force_async_ && rv_1 != PP_OK_COMPLETIONPENDING)
+    return ReportError("FileSystem::Open1 force_async", rv_1);
 
-  TestCompletionCallback callback_2(instance_->pp_instance());
+  TestCompletionCallback callback_2(instance_->pp_instance(), force_async_);
   int32_t rv_2 = file_system.Open(1024, callback_2);
+  if (force_async_ && rv_2 != PP_OK_COMPLETIONPENDING)
+    return ReportError("FileSystem::Open2 force_async", rv_2);
   if (rv_2 == PP_OK_COMPLETIONPENDING || rv_2 == PP_OK)
-    return "FileSystem::Open should not allow multiple opens.";
+    return "FileSystem::Open2 should not allow multiple opens.";
 
   if (rv_1 == PP_OK_COMPLETIONPENDING)
     rv_1 = callback_1.WaitForResult();
   if (rv_1 != PP_OK)
-    return ReportError("FileSystem::Open", rv_1);
+    return ReportError("FileSystem::Open1", rv_1);
 
-  TestCompletionCallback callback_3(instance_->pp_instance());
+  TestCompletionCallback callback_3(instance_->pp_instance(), force_async_);
   int32_t rv_3 = file_system.Open(1024, callback_3);
+  if (force_async_ && rv_3 != PP_OK_COMPLETIONPENDING)
+    return ReportError("FileSystem::Open3 force_async", rv_3);
   if (rv_3 == PP_OK_COMPLETIONPENDING || rv_3 == PP_OK)
-    return "FileSystem::Open should not allow multiple opens.";
+    return "FileSystem::Open3 should not allow multiple opens.";
 
   PASS();
 }
-
diff --git a/ppapi/tests/test_graphics_2d.cc b/ppapi/tests/test_graphics_2d.cc
index 28483b4..2917180 100644
--- a/ppapi/tests/test_graphics_2d.cc
+++ b/ppapi/tests/test_graphics_2d.cc
@@ -43,15 +43,15 @@ bool TestGraphics2D::Init() {
 }
 
 void TestGraphics2D::RunTest() {
-  instance_->LogTest("InvalidResource", TestInvalidResource());
-  instance_->LogTest("InvalidSize", TestInvalidSize());
-  instance_->LogTest("Humongous", TestHumongous());
-  instance_->LogTest("InitToZero", TestInitToZero());
-  instance_->LogTest("Describe", TestDescribe());
-  instance_->LogTest("Paint", TestPaint());
-  //instance_->LogTest("Scroll", TestScroll());  // TODO(brettw) implement.
-  instance_->LogTest("Replace", TestReplace());
-  instance_->LogTest("Flush", TestFlush());
+  RUN_TEST(InvalidResource);
+  RUN_TEST(InvalidSize);
+  RUN_TEST(Humongous);
+  RUN_TEST(InitToZero);
+  RUN_TEST(Describe);
+  RUN_TEST_FORCEASYNC_AND_NOT(Paint);
+  // RUN_TEST_FORCEASYNC_AND_NOT(Scroll);  // TODO(brettw) implement.
+  RUN_TEST_FORCEASYNC_AND_NOT(Replace);
+  RUN_TEST_FORCEASYNC_AND_NOT(Flush);
 }
 
 void TestGraphics2D::QuitMessageLoop() {
@@ -79,8 +79,11 @@ bool TestGraphics2D::IsDCUniformColor(const pp::Graphics2D& dc,
 }
 
 bool TestGraphics2D::FlushAndWaitForDone(pp::Graphics2D* context) {
-  pp::CompletionCallback cc(&FlushCallbackQuitMessageLoop, this);
+  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)
@@ -209,11 +212,11 @@ std::string TestGraphics2D::TestInvalidResource() {
   // Flush.
   if (graphics_2d_interface_->Flush(
           image.pp_resource(),
-          PP_MakeCompletionCallback(&FlushCallbackNOP, NULL)) == PP_OK)
+          PP_MakeOptionalCompletionCallback(&FlushCallbackNOP, NULL)) == PP_OK)
     return "Flush succeeded with a different resource";
   if (graphics_2d_interface_->Flush(
           null_context.pp_resource(),
-          PP_MakeCompletionCallback(&FlushCallbackNOP, NULL)) == PP_OK)
+          PP_MakeOptionalCompletionCallback(&FlushCallbackNOP, NULL)) == PP_OK)
     return "Flush succeeded with a NULL resource";
 
   // ReadImageData.
@@ -526,16 +529,27 @@ std::string TestGraphics2D::TestFlush() {
   if (!FlushAndWaitForDone(&dc_nopaints))
     return "Couldn't flush the nopaint device";
 
+  int32_t flags = (force_async_ ? 0 : PP_COMPLETIONCALLBACK_FLAG_OPTIONAL);
+
   // Test that multiple flushes fail if we don't get a callback in between.
-  rv = dc_nopaints.Flush(pp::CompletionCallback(&FlushCallbackNOP, NULL));
+  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.";
 
-  if (rv != PP_OK) {
-    // If the first flush would block, then a second should fail.
-    rv = dc_nopaints.Flush(pp::CompletionCallback(&FlushCallbackNOP, NULL));
-    if (rv == PP_OK || rv == PP_OK_COMPLETIONPENDING)
-      return "Second flush succeeded before callback ran.";
+  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.";
+    }
   }
 
   PASS();
diff --git a/ppapi/tests/test_transport.cc b/ppapi/tests/test_transport.cc
index fc41f17..d45112a 100644
--- a/ppapi/tests/test_transport.cc
+++ b/ppapi/tests/test_transport.cc
@@ -54,7 +54,7 @@ class StreamReader {
       buffer_.resize(kReadBufferSize);
       int result = transport_->Recv(
           &buffer_[0], buffer_.size(),
-          callback_factory_.NewCallback(&StreamReader::OnReadFinished));
+          callback_factory_.NewOptionalCallback(&StreamReader::OnReadFinished));
       if (result > 0)
         DidFinishRead(result);
       else
@@ -104,7 +104,7 @@ bool TestTransport::Init() {
 void TestTransport::RunTest() {
   RUN_TEST(Create);
   RUN_TEST(Connect);
-  RUN_TEST(SendDataUdp);
+  RUN_TEST_FORCEASYNC(SendDataUdp);
   RUN_TEST(SendDataTcp);
   RUN_TEST(ConnectAndCloseUdp);
   RUN_TEST(ConnectAndCloseTcp);
@@ -198,10 +198,15 @@ std::string TestTransport::TestSendDataUdp() {
     // Put packet index in the beginning.
     memcpy(&send_buffer[0], &i, sizeof(i));
 
-    TestCompletionCallback send_cb(instance_->pp_instance());
-    ASSERT_EQ(
-        transport2_->Send(&send_buffer[0], send_buffer.size(), send_cb),
-        static_cast<int>(send_buffer.size()));
+    TestCompletionCallback send_cb(instance_->pp_instance(), force_async_);
+    int32_t result = transport2_->Send(&send_buffer[0], send_buffer.size(),
+                                       send_cb);
+    if (force_async_) {
+      ASSERT_EQ(result, PP_OK_COMPLETIONPENDING);
+      ASSERT_EQ(send_cb.WaitForResult(), static_cast<int>(send_buffer.size()));
+    } else {
+      ASSERT_EQ(result, static_cast<int>(send_buffer.size()));
+    }
     sent_packets[i] = send_buffer;
   }
 
@@ -243,9 +248,11 @@ std::string TestTransport::TestSendDataTcp() {
 
   int pos = 0;
   while (pos < static_cast<int>(send_buffer.size())) {
-    TestCompletionCallback send_cb(instance_->pp_instance());
+    TestCompletionCallback send_cb(instance_->pp_instance(), force_async_);
     int result = transport2_->Send(
         &send_buffer[0] + pos, send_buffer.size() - pos, send_cb);
+    if (force_async_)
+      ASSERT_EQ(result, PP_OK_COMPLETIONPENDING);
     if (result == PP_OK_COMPLETIONPENDING)
       result = send_cb.WaitForResult();
     ASSERT_TRUE(result > 0);
diff --git a/ppapi/tests/test_url_loader.cc b/ppapi/tests/test_url_loader.cc
index 8fda286..6ecb15d 100644
--- a/ppapi/tests/test_url_loader.cc
+++ b/ppapi/tests/test_url_loader.cc
@@ -44,27 +44,29 @@ bool TestURLLoader::Init() {
 
 void TestURLLoader::RunTest() {
   RUN_TEST(BasicGET);
-  RUN_TEST(BasicPOST);
-  RUN_TEST(CompoundBodyPOST);
-  RUN_TEST(EmptyDataPOST);
+  RUN_TEST_FORCEASYNC(BasicPOST);
+  RUN_TEST_FORCEASYNC_AND_NOT(CompoundBodyPOST);
+  RUN_TEST_FORCEASYNC(EmptyDataPOST);
   RUN_TEST(BinaryDataPOST);
-  RUN_TEST(CustomRequestHeader);
-  RUN_TEST(IgnoresBogusContentLength);
+  RUN_TEST_FORCEASYNC_AND_NOT(CustomRequestHeader);
+  RUN_TEST_FORCEASYNC(IgnoresBogusContentLength);
   RUN_TEST(SameOriginRestriction);
-  RUN_TEST(CrossOriginRequest);
-  RUN_TEST(StreamToFile);
+  RUN_TEST_FORCEASYNC(CrossOriginRequest);
+  RUN_TEST_FORCEASYNC_AND_NOT(StreamToFile);
   RUN_TEST(AuditURLRedirect);
-  RUN_TEST(AbortCalls);
+  RUN_TEST_FORCEASYNC(AbortCalls);
 }
 
 std::string TestURLLoader::ReadEntireFile(pp::FileIO_Dev* file_io,
                                           std::string* data) {
-  TestCompletionCallback callback(instance_->pp_instance());
+  TestCompletionCallback callback(instance_->pp_instance(), force_async_);
   char buf[256];
   int64_t offset = 0;
 
   for (;;) {
     int32_t rv = file_io->Read(offset, buf, sizeof(buf), callback);
+    if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+      return ReportError("FileIO::Read force_async", rv);
     if (rv == PP_OK_COMPLETIONPENDING)
       rv = callback.WaitForResult();
     if (rv < 0)
@@ -80,11 +82,13 @@ std::string TestURLLoader::ReadEntireFile(pp::FileIO_Dev* file_io,
 
 std::string TestURLLoader::ReadEntireResponseBody(pp::URLLoader* loader,
                                                   std::string* body) {
-  TestCompletionCallback callback(instance_->pp_instance());
+  TestCompletionCallback callback(instance_->pp_instance(), force_async_);
   char buf[2];  // Small so that multiple reads are needed.
 
   for (;;) {
     int32_t rv = loader->ReadResponseBody(buf, sizeof(buf), callback);
+    if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+      return ReportError("URLLoader::ReadResponseBody force_async", rv);
     if (rv == PP_OK_COMPLETIONPENDING)
       rv = callback.WaitForResult();
     if (rv < 0)
@@ -100,10 +104,12 @@ std::string TestURLLoader::ReadEntireResponseBody(pp::URLLoader* loader,
 std::string TestURLLoader::LoadAndCompareBody(
     const pp::URLRequestInfo& request,
     const std::string& expected_body) {
-  TestCompletionCallback callback(instance_->pp_instance());
+  TestCompletionCallback callback(instance_->pp_instance(), force_async_);
 
   pp::URLLoader loader(*instance_);
   int32_t rv = loader.Open(request, callback);
+  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+    return ReportError("URLLoader::Open force_async", rv);
   if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
@@ -197,10 +203,12 @@ std::string TestURLLoader::TestStreamToFile() {
   request.SetURL("test_url_loader_data/hello.txt");
   request.SetStreamToFile(true);
 
-  TestCompletionCallback callback(instance_->pp_instance());
+  TestCompletionCallback callback(instance_->pp_instance(), force_async_);
 
   pp::URLLoader loader(*instance_);
   int32_t rv = loader.Open(request, callback);
+  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+    return ReportError("URLLoader::Open force_async", rv);
   if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
@@ -218,6 +226,8 @@ std::string TestURLLoader::TestStreamToFile() {
     return "URLResponseInfo::GetBody returned null";
 
   rv = loader.FinishStreamingToFile(callback);
+  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+    return ReportError("URLLoader::FinishStreamingToFile force_async", rv);
   if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
@@ -225,6 +235,8 @@ std::string TestURLLoader::TestStreamToFile() {
 
   pp::FileIO_Dev reader(instance_);
   rv = reader.Open(body, 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)
@@ -253,10 +265,12 @@ std::string TestURLLoader::TestSameOriginRestriction() {
   pp::URLRequestInfo request(instance_);
   request.SetURL("http://www.google.com/");
 
-  TestCompletionCallback callback(instance_->pp_instance());
+  TestCompletionCallback callback(instance_->pp_instance(), force_async_);
 
   pp::URLLoader loader(*instance_);
   int32_t rv = loader.Open(request, callback);
+  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+    return ReportError("URLLoader::Open force_async", rv);
   if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
 
@@ -290,11 +304,13 @@ std::string TestURLLoader::TestCrossOriginRequest() {
   request.SetURL(cross_origin_url);
   request.SetAllowCrossOriginRequests(true);
 
-  TestCompletionCallback callback(instance_->pp_instance());
+  TestCompletionCallback callback(instance_->pp_instance(), force_async_);
 
   pp::URLLoader loader(*instance_);
   int32_t rv = loader.Open(request, callback);
-  if (rv == PP_ERROR_WOULDBLOCK)
+  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+    return ReportError("URLLoader::Open force_async", rv);
+  if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
 
   // We expect success since we allowed a cross-origin request.
@@ -312,10 +328,12 @@ std::string TestURLLoader::TestAuditURLRedirect() {
   request.SetURL("/server-redirect?www.google.com");
   request.SetFollowRedirects(false);
 
-  TestCompletionCallback callback(instance_->pp_instance());
+  TestCompletionCallback callback(instance_->pp_instance(), force_async_);
 
   pp::URLLoader loader(*instance_);
   int32_t rv = loader.Open(request, callback);
+  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+    return ReportError("URLLoader::Open force_async", rv);
   if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
@@ -339,13 +357,15 @@ std::string TestURLLoader::TestAbortCalls() {
   pp::URLRequestInfo request(instance_);
   request.SetURL("test_url_loader_data/hello.txt");
 
-  TestCompletionCallback callback(instance_->pp_instance());
+  TestCompletionCallback callback(instance_->pp_instance(), force_async_);
   int32_t rv;
 
   // Abort |Open()|.
   {
     callback.reset_run_count();
     rv = pp::URLLoader(*instance_).Open(request, callback);
+    if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+      return ReportError("URLLoader::Open force_async", rv);
     if (callback.run_count() > 0)
       return "URLLoader::Open ran callback synchronously.";
     if (rv == PP_OK_COMPLETIONPENDING) {
@@ -363,6 +383,8 @@ std::string TestURLLoader::TestAbortCalls() {
     {
       pp::URLLoader loader(*instance_);
       rv = loader.Open(request, callback);
+      if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+        return ReportError("URLLoader::Open force_async", rv);
       if (rv == PP_OK_COMPLETIONPENDING)
         rv = callback.WaitForResult();
       if (rv != PP_OK)
@@ -370,6 +392,8 @@ std::string TestURLLoader::TestAbortCalls() {
 
       callback.reset_run_count();
       rv = loader.ReadResponseBody(buf, sizeof(buf), callback);
+      if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+        return ReportError("URLLoader::ReadResponseBody force_async", rv);
     }  // Destroy |loader|.
     if (rv == PP_OK_COMPLETIONPENDING) {
       // Save a copy and make sure |buf| doesn't get written to.
diff --git a/ppapi/tests/test_utils.cc b/ppapi/tests/test_utils.cc
index 01557ce..b51634bc 100644
--- a/ppapi/tests/test_utils.cc
+++ b/ppapi/tests/test_utils.cc
@@ -29,6 +29,17 @@ std::string ReportError(const char* method, int32_t error) {
 TestCompletionCallback::TestCompletionCallback(PP_Instance instance)
     : have_result_(false),
       result_(PP_OK_COMPLETIONPENDING),
+      force_async_(false),
+      post_quit_task_(false),
+      run_count_(0),
+      instance_(instance) {
+}
+
+TestCompletionCallback::TestCompletionCallback(PP_Instance instance,
+                                               bool force_async)
+    : have_result_(false),
+      result_(PP_OK_COMPLETIONPENDING),
+      force_async_(force_async),
       post_quit_task_(false),
       run_count_(0),
       instance_(instance) {
@@ -45,8 +56,10 @@ int32_t TestCompletionCallback::WaitForResult() {
 }
 
 TestCompletionCallback::operator pp::CompletionCallback() const {
+  int32_t flags = (force_async_ ? 0 : PP_COMPLETIONCALLBACK_FLAG_OPTIONAL);
   return pp::CompletionCallback(&TestCompletionCallback::Handler,
-                                const_cast<TestCompletionCallback*>(this));
+                                const_cast<TestCompletionCallback*>(this),
+                                flags);
 }
 
 // static
diff --git a/ppapi/tests/test_utils.h b/ppapi/tests/test_utils.h
index 721a048..e786aa8 100644
--- a/ppapi/tests/test_utils.h
+++ b/ppapi/tests/test_utils.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
@@ -18,6 +18,7 @@ std::string ReportError(const char* method, int32_t error);
 class TestCompletionCallback {
  public:
   TestCompletionCallback(PP_Instance instance);
+  TestCompletionCallback(PP_Instance instance, bool force_async);
 
   // Waits for the callback to be called and returns the
   // result. Returns immediately if the callback was previously called
@@ -38,6 +39,7 @@ class TestCompletionCallback {
 
   bool have_result_;
   int32_t result_;
+  bool force_async_;
   bool post_quit_task_;
   unsigned run_count_;
   PP_Instance instance_;