PPAPI: Force async callback invocation option.

ppapi/tests/test_directory_reader.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_directory_reader.h"
 
 #include <stdio.h>
 #include <set>
 #include <vector>
 
@@ skipping 62 matching lines @@
 
 bool TestDirectoryReader::Init() {
   return InitTestingInterface() && EnsureRunningOverHTTP();
 }
 
 void TestDirectoryReader::RunTest() {
   RUN_TEST(GetNextFile);
 }
 
 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)
     return ReportError("FileSystem::Open", rv);
 
   // Setup testing directories and files.
   const char* test_dir_name = "/test_get_next_file";
   const char* file_prefix = "file_";
   const char* dir_prefix = "dir_";
 
   pp::FileRef_Dev test_dir(file_system, test_dir_name);
   rv = DeleteDirectoryRecursively(&test_dir, &callback);
   if (rv != PP_OK && rv != PP_ERROR_FILENOTFOUND)
     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)
     return ReportError("FileRef::MakeDirectory", rv);
 
   std::set<std::string> expected_file_names;
   for (int i = 1; i < 4; ++i) {
     char buffer[40];
     sprintf(buffer, "%s/%s%d", test_dir_name, file_prefix, i);
     pp::FileRef_Dev file_ref(file_system, buffer);
 
     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);
 
     expected_file_names.insert(buffer);
   }
 
   std::set<std::string> expected_dir_names;
   for (int i = 1; i < 4; ++i) {
     char buffer[40];
     sprintf(buffer, "%s/%s%d", test_dir_name, dir_prefix, i);
     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)
       return ReportError("FileRef::MakeDirectory", rv);
 
     expected_dir_names.insert(buffer);
   }
 
   // Test that |GetNextEntry()| is able to enumerate all directories and files
   // that we created.
   {
     pp::DirectoryReader_Dev directory_reader(test_dir);
     std::vector<pp::DirectoryEntry_Dev> entries;
     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)
         return ReportError("DirectoryReader::GetNextEntry", rv);
       if (!entry.is_null())
         entries.push_back(entry);
     } while (!entry.is_null());
 
     size_t sum = expected_file_names.size() + expected_dir_names.size();
     if (entries.size() != sum)
@@ skipping 24 matching lines @@
   }
 
   // Test cancellation of asynchronous |GetNextEntry()|.
   {
     // Declaring |entry| here prevents memory corruption for some failure modes
     // and lets us to detect some other failures.
     pp::DirectoryEntry_Dev entry;
     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.";
 
     // If |GetNextEntry()| is completing asynchronously, the callback should be
     // aborted (i.e., called with |PP_ERROR_ABORTED| from the message loop)
     // since the resource was destroyed.
     if (rv == PP_OK_COMPLETIONPENDING) {
       // |GetNextEntry()| *may* have written to |entry| (e.g., synchronously,
       // before the resource was destroyed), but it must not write to it after
       // destruction.
       bool entry_is_null = entry.is_null();
       rv = callback.WaitForResult();
       if (rv != PP_ERROR_ABORTED)
         return "DirectoryReader::GetNextEntry not aborted.";
       if (entry.is_null() != entry_is_null)
         return "DirectoryReader::GetNextEntry wrote result after destruction.";
     } else if (rv != PP_OK) {
       return ReportError("DirectoryReader::GetNextEntry", rv);
     }
   }
 
   PASS();
 }