PPAPI: Make blocking completion callbacks work.

ppapi/tests/test_broker.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_broker.h"
 
 #if defined(_MSC_VER)
 #define OS_WIN 1
 #include <windows.h>
 #else
@@ skipping 194 matching lines @@
 bool TestBroker::Init() {
   broker_interface_ = static_cast<const PPB_BrokerTrusted*>(
       pp::Module::Get()->GetBrowserInterface(PPB_BROKER_TRUSTED_INTERFACE));
   return !!broker_interface_;
 }
 
 void TestBroker::RunTests(const std::string& filter) {
   RUN_TEST(Create, filter);
   RUN_TEST(Create, filter);
   RUN_TEST(GetHandleFailure, filter);
-  RUN_TEST(ConnectFailure, filter);
-  RUN_TEST(ConnectAndPipe, filter);
+  RUN_TEST_FORCEASYNC_AND_NOT(ConnectFailure, filter);
+  RUN_TEST_FORCEASYNC_AND_NOT(ConnectAndPipe, filter);
 }
 
 std::string TestBroker::TestCreate() {
   // Very simplistic test to make sure we can create a broker interface.
   PP_Resource broker = broker_interface_->CreateTrusted(
       instance_->pp_instance());
   ASSERT_TRUE(broker);
 
   ASSERT_FALSE(broker_interface_->IsBrokerTrusted(0));
   ASSERT_TRUE(broker_interface_->IsBrokerTrusted(broker));
 
   PASS();
 }
 
 // Test connection on invalid resource.
 std::string TestBroker::TestConnectFailure() {
-  // Callback NOT force async. Connect should fail.  The callback will not be
-  // posted so there's no need to wait for the callback to complete.
-  TestCompletionCallback cb_1(instance_->pp_instance(), false);
-  ASSERT_EQ(PP_ERROR_BADRESOURCE,
-            broker_interface_->Connect(
-                0, pp::CompletionCallback(cb_1).pp_completion_callback()));
-
-  // Callback force async. Connect will return PP_OK_COMPLETIONPENDING and the
-  // callback will be posted.  However, the callback should fail.
-  TestCompletionCallback cb_2(instance_->pp_instance(), true);
-  ASSERT_EQ(PP_OK_COMPLETIONPENDING,
-            broker_interface_->Connect(
-                0, pp::CompletionCallback(cb_2).pp_completion_callback()));
-  ASSERT_EQ(PP_ERROR_BADRESOURCE, cb_2.WaitForResult());
+  TestCompletionCallback callback(instance_->pp_instance(), callback_type());
+  callback.WaitForResult(broker_interface_->Connect(0,
+      callback.GetCallback().pp_completion_callback()));
+  CHECK_CALLBACK_BEHAVIOR(callback);
+  ASSERT_EQ(PP_ERROR_BADRESOURCE, callback.result());
 
   PASS();
 }
 
 std::string TestBroker::TestGetHandleFailure() {
   int32_t handle = kInvalidHandle;
 
   // Test getting the handle for an invalid resource.
   ASSERT_EQ(PP_ERROR_BADRESOURCE, broker_interface_->GetHandle(0, &handle));
 
   // Connect hasn't been called so this should fail.
   PP_Resource broker = broker_interface_->CreateTrusted(
       instance_->pp_instance());
   ASSERT_TRUE(broker);
   ASSERT_EQ(PP_ERROR_FAILED, broker_interface_->GetHandle(broker, &handle));
 
   PASS();
 }
 
 std::string TestBroker::TestConnectAndPipe() {
   PP_Resource broker = broker_interface_->CreateTrusted(
       instance_->pp_instance());
   ASSERT_TRUE(broker);
 
-  TestCompletionCallback cb_3(instance_->pp_instance());
-  ASSERT_EQ(PP_OK_COMPLETIONPENDING,
-            broker_interface_->Connect(
-                broker, pp::CompletionCallback(cb_3).pp_completion_callback()));
-  ASSERT_EQ(PP_OK, cb_3.WaitForResult());
+  TestCompletionCallback callback(instance_->pp_instance(), callback_type());
+  callback.WaitForResult(broker_interface_->Connect(broker,
+      callback.GetCallback().pp_completion_callback()));
+  CHECK_CALLBACK_BEHAVIOR(callback);
+  ASSERT_EQ(PP_OK, callback.result());
 
   int32_t handle = kInvalidHandle;
   ASSERT_EQ(PP_OK, broker_interface_->GetHandle(broker, &handle));
   ASSERT_NE(kInvalidHandle, handle);
 
   PlatformFile file = IntToPlatformFile(handle);
   ASSERT_TRUE(VerifyMessage(file, sizeof(kHelloMessage), kHelloMessage));
   ASSERT_TRUE(VerifyMessage(file, sizeof(kBrokerUnsandboxed),
                             kBrokerUnsandboxed));
 
   ASSERT_TRUE(ClosePlatformFile(file));
 
   PASS();
 }