PPAPI: Make blocking completion callbacks work.

ppapi/tests/test_url_loader.cc

 // Copyright (c) 2012 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_url_loader.h"
 
 #include <stdio.h>
 #include <string.h>
 #include <string>
 
@@ skipping 15 matching lines @@
 #include "ppapi/tests/test_utils.h"
 #include "ppapi/tests/testing_instance.h"
 
 REGISTER_TEST_CASE(URLLoader);
 
 namespace {
 
 int32_t WriteEntireBuffer(PP_Instance instance,
                           pp::FileIO* file_io,
                           int32_t offset,
-                          const std::string& data) {
-  TestCompletionCallback callback(instance);
+                          const std::string& data,
+                          CallbackType callback_type) {
+  TestCompletionCallback callback(instance, callback_type);
   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)
@@ skipping 40 matching lines @@
     if (file_io_trusted_interface_)
       instance_->AppendError("FileIOTrusted interface is supported by NaCl");
     if (url_loader_trusted_interface_)
       instance_->AppendError("URLLoaderTrusted interface is supported by NaCl");
 #endif
   }
   return EnsureRunningOverHTTP();
 }
 
 void TestURLLoader::RunTests(const std::string& filter) {
-  RUN_TEST_FORCEASYNC_AND_NOT(BasicGET, filter);
-  RUN_TEST_FORCEASYNC_AND_NOT(BasicPOST, filter);
-  RUN_TEST_FORCEASYNC_AND_NOT(BasicFilePOST, filter);
-  RUN_TEST_FORCEASYNC_AND_NOT(BasicFileRangePOST, filter);
-  RUN_TEST_FORCEASYNC_AND_NOT(CompoundBodyPOST, filter);
-  RUN_TEST_FORCEASYNC_AND_NOT(EmptyDataPOST, filter);
-  RUN_TEST_FORCEASYNC_AND_NOT(BinaryDataPOST, filter);
-  RUN_TEST_FORCEASYNC_AND_NOT(CustomRequestHeader, filter);
-  RUN_TEST_FORCEASYNC_AND_NOT(FailsBogusContentLength, filter);
-  RUN_TEST_FORCEASYNC_AND_NOT(StreamToFile, filter);
-  RUN_TEST_FORCEASYNC_AND_NOT(UntrustedSameOriginRestriction, filter);
-  RUN_TEST_FORCEASYNC_AND_NOT(TrustedSameOriginRestriction, filter);
-  RUN_TEST_FORCEASYNC_AND_NOT(UntrustedCrossOriginRequest, filter);
-  RUN_TEST_FORCEASYNC_AND_NOT(TrustedCrossOriginRequest, filter);
-  RUN_TEST_FORCEASYNC_AND_NOT(UntrustedJavascriptURLRestriction, filter);
-  RUN_TEST_FORCEASYNC_AND_NOT(TrustedJavascriptURLRestriction, filter);
-  RUN_TEST_FORCEASYNC_AND_NOT(UntrustedHttpRequests, filter);
-  RUN_TEST_FORCEASYNC_AND_NOT(TrustedHttpRequests, filter);
-  RUN_TEST_FORCEASYNC_AND_NOT(FollowURLRedirect, filter);
-  RUN_TEST_FORCEASYNC_AND_NOT(AuditURLRedirect, filter);
-  RUN_TEST_FORCEASYNC_AND_NOT(AbortCalls, filter);
-  RUN_TEST_FORCEASYNC_AND_NOT(UntendedLoad, filter);
-  RUN_TEST_FORCEASYNC_AND_NOT(PrefetchBufferThreshold, filter);
+  RUN_CALLBACK_TEST(TestURLLoader, BasicGET, filter);
+  RUN_CALLBACK_TEST(TestURLLoader, BasicPOST, filter);
+  RUN_CALLBACK_TEST(TestURLLoader, BasicFilePOST, filter);
+  RUN_CALLBACK_TEST(TestURLLoader, BasicFileRangePOST, filter);
+  RUN_CALLBACK_TEST(TestURLLoader, CompoundBodyPOST, filter);
+  RUN_CALLBACK_TEST(TestURLLoader, EmptyDataPOST, filter);
+  RUN_CALLBACK_TEST(TestURLLoader, BinaryDataPOST, filter);
+  RUN_CALLBACK_TEST(TestURLLoader, CustomRequestHeader, filter);
+  RUN_CALLBACK_TEST(TestURLLoader, FailsBogusContentLength, filter);
+  RUN_CALLBACK_TEST(TestURLLoader, StreamToFile, filter);
+  RUN_CALLBACK_TEST(TestURLLoader, UntrustedSameOriginRestriction, filter);
+  RUN_CALLBACK_TEST(TestURLLoader, TrustedSameOriginRestriction, filter);
+  RUN_CALLBACK_TEST(TestURLLoader, UntrustedCrossOriginRequest, filter);
+  RUN_CALLBACK_TEST(TestURLLoader, TrustedCrossOriginRequest, filter);
+  RUN_CALLBACK_TEST(TestURLLoader, UntrustedJavascriptURLRestriction, filter);
+  RUN_CALLBACK_TEST(TestURLLoader, TrustedJavascriptURLRestriction, filter);
+  RUN_CALLBACK_TEST(TestURLLoader, UntrustedHttpRequests, filter);
+  RUN_CALLBACK_TEST(TestURLLoader, TrustedHttpRequests, filter);
+  RUN_CALLBACK_TEST(TestURLLoader, FollowURLRedirect, filter);
+  RUN_CALLBACK_TEST(TestURLLoader, AuditURLRedirect, filter);
+  RUN_CALLBACK_TEST(TestURLLoader, AbortCalls, filter);
+  RUN_CALLBACK_TEST(TestURLLoader, UntendedLoad, filter);
+  RUN_CALLBACK_TEST(TestURLLoader, PrefetchBufferThreshold, filter);
 }
 
 std::string TestURLLoader::ReadEntireFile(pp::FileIO* file_io,
                                           std::string* data) {
   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
   char buf[256];
   int64_t offset = 0;
 
   for (;;) {
     callback.WaitForResult(file_io->Read(offset, buf, sizeof(buf), callback));
@@ skipping 84 matching lines @@
                                       callback));
   if (callback.failed()) {
     message->assign(callback.errors());
     return callback.result();
   }
   if (callback.result() != PP_OK) {
     message->assign("FileIO::Open failed.");
     return callback.result();
   }
 
-  int32_t rv = WriteEntireBuffer(instance_->pp_instance(), &file_io, 0, data);
+  int32_t rv = WriteEntireBuffer(instance_->pp_instance(), &file_io, 0, data,
+                                 callback_type());
   if (rv != PP_OK) {
     message->assign("FileIO::Write failed.");
     return rv;
   }
 
   return rv;
 }
 
 std::string TestURLLoader::GetReachableAbsoluteURL(
     const std::string& file_name) {
@@ skipping 544 matching lines @@
   // another callback function, to make sure the loader works with no callback.
   int64_t bytes_received = 0;
   int64_t total_bytes_to_be_received = 0;
   while (true) {
     loader.GetDownloadProgress(&bytes_received, &total_bytes_to_be_received);
     if (total_bytes_to_be_received <= 0)
       return ReportError("URLLoader::GetDownloadProgress total size",
           total_bytes_to_be_received);
     if (bytes_received == total_bytes_to_be_received)
       break;
-    pp::Module::Get()->core()->CallOnMainThread(10, callback);
-    callback.WaitForResult();
+    // TODO(dmichael): This should probably compare pp::MessageLoop::GetCurrent
+    //                 with GetForMainThread. We only need to yield on the main
+    //                 thread.
+    if (callback_type() != PP_BLOCKING) {
+      pp::Module::Get()->core()->CallOnMainThread(10, callback);
+      callback.WaitForResult();
+    }
   }
 
   // The loader should now have the data and have finished successfully.
   std::string body;
   std::string error = ReadEntireResponseBody(&loader, &body);
   if (!error.empty())
     return error;
   if (body != "hello\n")
     return ReportError("Couldn't read data", callback.result());
 
@@ skipping 27 matching lines @@
   if (rv != PP_ERROR_FAILED) {
     return ReportError("The lower buffer value was higher than the upper but "
                        "the URLLoader did not fail.", rv);
   }
 
   PASS();
 }
 
 // TODO(viettrungluu): Add tests for  Get{Upload,Download}Progress, Close
 // (including abort tests if applicable).