PPAPI: Force async callback invocation option.

ppapi/tests/test_file_io.cc

 // 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.
 
 #include "ppapi/tests/test_file_io.h"
 
 #include <stdio.h>
 #include <string.h>
 
 #include "ppapi/c/pp_errors.h"
@@ skipping 93 matching lines @@
   return PP_OK;
 }
 
 }  // namespace
 
 bool TestFileIO::Init() {
   return InitTestingInterface() && EnsureRunningOverHTTP();
 }
 
 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)
     return ReportError("FileSystem::Open", rv);
 
   std::string result;
   result = MatchOpenExpectations(
       &file_system,
       PP_FILEOPENFLAG_READ,
       DONT_CREATE_IF_DOESNT_EXIST | OPEN_IF_EXISTS | DONT_TRUNCATE_IF_EXISTS);
@@ skipping 71 matching lines @@
       &file_system,
       PP_FILEOPENFLAG_READ | PP_FILEOPENFLAG_TRUNCATE,
       INVALID_FLAG_COMBINATION);
   if (!result.empty())
     return result;
 
   PASS();
 }
 
 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)
     return ReportError("FileSystem::Open", rv);
 
   pp::FileIO_Dev file_io(instance_);
   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.
   rv = WriteEntireBuffer(instance_->pp_instance(), &file_io, 0, "test_test");
   if (rv != PP_OK)
     return ReportError("FileIO::Write", rv);
 
   // Read the entire file.
   std::string 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.
   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);
   if (rv != PP_OK)
     return ReportError("FileIO::Read", rv);
@@ skipping 17 matching lines @@
   read_buffer.clear();
   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.
   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);
   if (rv != PP_OK)
     return ReportError("FileIO::Read", rv);
@@ skipping 21 matching lines @@
   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());
+  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)
     return ReportError("FileSystem::Open", rv);
 
   pp::FileRef_Dev file_ref(file_system, "/file_touch");
   pp::FileIO_Dev file_io(instance_);
   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.
   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;
   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)
     return ReportError("FileSystem::Open", rv);
 
   // First, create a file which to do ops on.
   {
     pp::FileIO_Dev file_io(instance_);
     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");
     if (rv != PP_OK)
       return ReportError("FileIO::Write", rv);
   }
 
   // Abort |Open()|.
   {
     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) {
       rv = callback.WaitForResult();
       if (rv != PP_ERROR_ABORTED)
         return "FileIO::Open not aborted.";
     } else if (rv != PP_OK) {
       return ReportError("FileIO::Open", rv);
     }
   }
 
   // Abort |Query()|.
   {
     PP_FileInfo_Dev info = { 0 };
     {
       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)
         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|.
     if (rv == PP_OK_COMPLETIONPENDING) {
       // Save a copy and make sure |info| doesn't get written to.
       PP_FileInfo_Dev 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);
     }
   }
 
   // Abort |Touch()|.
   {
     {
       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)
         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|.
     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()|.
   {
     char buf[3] = { 0 };
     {
       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)
         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|.
     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);
     }
   }
 
   // Abort |Write()|.
   {
     char buf[3] = { 0 };
     {
       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)
         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|.
     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_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)
         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|.
     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);
     }
   }
 
   // Abort |Flush()|.
   {
     {
       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)
         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|.
     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);
     }
   }
 
@@ skipping 18 matching lines @@
     for (size_t remains = expectations, end = END_OF_OPEN_EXPECATION_PAIRS;
          end != 0; remains >>= 2, end >>= 2) {
       if (!!(remains & 1) == !!(remains & 2))
         return bad_argument;
     }
   }
   bool create_if_doesnt_exist = !!(expectations & CREATE_IF_DOESNT_EXIST);
   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(
       *file_system, "/match_open_expectation_nonexistent_file");
 
   // 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)
       return ReportError("FileRef::Delete", rv);
 
     pp::FileIO_Dev existent_file_io(instance_);
     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_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) ||
       (!invalid_combination && ((rv == PP_OK) != open_if_exists))) {
     return ReportOpenError(open_flags);
   }
 
   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)
       return ReportError("FileIO::Query", rv);
 
     if (truncate_if_exists != (info.size == 0))
       return ReportOpenError(open_flags);
   }
 
   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) ||
       (!invalid_combination && ((rv == PP_OK) != create_if_doesnt_exist))) {
     return ReportOpenError(open_flags);
   }
 
   return std::string();
 }
 
 // TODO(viettrungluu): Test Close(). crbug.com/69457