PPAPI: More test cleanup

ppapi/tests/test_host_resolver_private.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_host_resolver_private.h"
 
 #include "ppapi/c/private/ppb_net_address_private.h"
 #include "ppapi/cpp/module_impl.h"
 #include "ppapi/cpp/private/host_resolver_private.h"
 #include "ppapi/cpp/private/tcp_socket_private.h"
@@ skipping 24 matching lines @@
 
   return host_resolver_private_is_available &&
       tcp_socket_private_is_available &&
       init_host_port &&
       CheckTestingInterface() &&
       EnsureRunningOverHTTP();
 }
 
 void TestHostResolverPrivate::RunTests(const std::string& filter) {
   RUN_TEST(Empty, filter);
-  RUN_TEST_FORCEASYNC_AND_NOT(Resolve, filter);
-  RUN_TEST_FORCEASYNC_AND_NOT(ResolveIPv4, filter);
+  RUN_CALLBACK_TEST(TestHostResolverPrivate, Resolve, filter);
+  RUN_CALLBACK_TEST(TestHostResolverPrivate, ResolveIPv4, filter);
 }
 
 std::string TestHostResolverPrivate::SyncConnect(pp::TCPSocketPrivate* socket,
                                                  const std::string& host,
                                                  uint16_t port) {
-  TestCompletionCallback callback(instance_->pp_instance(), force_async_);
-  int32_t rv = socket->Connect(host.c_str(), port, callback.GetCallback());
-  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
-    return ReportError("PPB_TCPSocket_Private::Connect force_async", rv);
-  if (rv == PP_OK_COMPLETIONPENDING)
-    rv = callback.WaitForResult();
-  ASSERT_EQ(PP_OK, rv);
+  TestCompletionCallback callback(instance_->pp_instance(), callback_type());
+  callback.WaitForResult(
+     socket->Connect(host.c_str(), port, callback.GetCallback()));
+  CHECK_CALLBACK_BEHAVIOR(callback);
+  ASSERT_EQ(PP_OK, callback.result());
   PASS();
 }
 
 std::string TestHostResolverPrivate::SyncConnect(
     pp::TCPSocketPrivate* socket,
     const PP_NetAddress_Private& address) {
-  TestCompletionCallback callback(instance_->pp_instance(), force_async_);
-  int32_t rv = socket->ConnectWithNetAddress(&address, callback.GetCallback());
-  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
-    return ReportError("PPB_TCPSocket_Private::Connect force_async", rv);
-  if (rv == PP_OK_COMPLETIONPENDING)
-    rv = callback.WaitForResult();
-  ASSERT_EQ(PP_OK, rv);
+  TestCompletionCallback callback(instance_->pp_instance(), callback_type());
+  callback.WaitForResult(
+      socket->ConnectWithNetAddress(&address, callback.GetCallback()));
+  CHECK_CALLBACK_BEHAVIOR(callback);
+  ASSERT_EQ(PP_OK, callback.result());
   PASS();
 }
 
 std::string TestHostResolverPrivate::SyncRead(pp::TCPSocketPrivate* socket,
                                               char* buffer,
                                               int32_t num_bytes,
                                               int32_t* bytes_read) {
-  TestCompletionCallback callback(instance_->pp_instance(), force_async_);
-  int32_t rv = socket->Read(buffer, num_bytes, callback.GetCallback());
-  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
-    return ReportError("PPB_TCPSocket_Private::Read force_async", rv);
-  if (rv == PP_OK_COMPLETIONPENDING)
-    rv = callback.WaitForResult();
-  if (num_bytes != rv)
-    return ReportError("PPB_TCPSocket_Private::Read", rv);
-  *bytes_read = rv;
+  TestCompletionCallback callback(instance_->pp_instance(), callback_type());
+  callback.WaitForResult(
+      socket->Read(buffer, num_bytes, callback.GetCallback()));
+  CHECK_CALLBACK_BEHAVIOR(callback);
+  ASSERT_EQ(num_bytes, callback.result());
+  *bytes_read = callback.result();
   PASS();
 }
 
 std::string TestHostResolverPrivate::SyncWrite(pp::TCPSocketPrivate* socket,
                                                const char* buffer,
                                                int32_t num_bytes,
                                                int32_t* bytes_written) {
-  TestCompletionCallback callback(instance_->pp_instance(), force_async_);
-  int32_t rv = socket->Write(buffer, num_bytes, callback.GetCallback());
-  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
-    return ReportError("PPB_TCPSocket_Private::Write force_async", rv);
-  if (rv == PP_OK_COMPLETIONPENDING)
-    rv = callback.WaitForResult();
-  if (num_bytes != rv)
-    return ReportError("PPB_TCPSocket_Private::Write", rv);
-  *bytes_written = rv;
+  TestCompletionCallback callback(instance_->pp_instance(), callback_type());
+  callback.WaitForResult(
+      socket->Write(buffer, num_bytes, callback.GetCallback()));
+  CHECK_CALLBACK_BEHAVIOR(callback);
+  ASSERT_EQ(num_bytes, callback.result());
+  *bytes_written = callback.result();
   PASS();
 }
 
 std::string TestHostResolverPrivate::CheckHTTPResponse(
     pp::TCPSocketPrivate* socket,
     const std::string& request,
     const std::string& response) {
   int32_t rv = 0;
   ASSERT_SUBTEST_SUCCESS(
       SyncWrite(socket, request.c_str(), request.size(), &rv));
   std::vector<char> response_buffer(response.size());
   ASSERT_SUBTEST_SUCCESS(
       SyncRead(socket, &response_buffer[0], response.size(), &rv));
   std::string actual_response(&response_buffer[0], rv);
   if (response != actual_response) {
     return "CheckHTTPResponse failed, expected: " + response +
         ", actual: " + actual_response;
   }
   PASS();
 }
 
 std::string TestHostResolverPrivate::SyncResolve(
     pp::HostResolverPrivate* host_resolver,
     const std::string& host,
     uint16_t port,
     const PP_HostResolver_Private_Hint& hint) {
-  TestCompletionCallback callback(instance_->pp_instance(), force_async_);
-  int32_t rv = host_resolver->Resolve(host, port, hint, callback.GetCallback());
-  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
-    return ReportError("PPB_HostResolver_Private::Resolve force_async", rv);
-  if (rv == PP_OK_COMPLETIONPENDING)
-    rv = callback.WaitForResult();
-  if (rv != PP_OK)
-    return ReportError("PPB_HostResolver_Private::Resolve", rv);
+  TestCompletionCallback callback(instance_->pp_instance(), callback_type());
+  callback.WaitForResult(
+      host_resolver->Resolve(host, port, hint, callback.GetCallback()));
+  CHECK_CALLBACK_BEHAVIOR(callback);
   PASS();
 }
 
 std::string TestHostResolverPrivate::TestEmpty() {
   pp::HostResolverPrivate host_resolver(instance_);
   ASSERT_EQ(0, host_resolver.GetSize());
   PP_NetAddress_Private address;
   ASSERT_FALSE(host_resolver.GetNetAddress(0, &address));
 
   PASS();
@@ skipping 41 matching lines @@
   hint.flags = PP_HOST_RESOLVER_FLAGS_CANONNAME;
   return ParametrizedTestResolve(hint);
 }
 
 std::string TestHostResolverPrivate::TestResolveIPv4() {
   PP_HostResolver_Private_Hint hint;
   hint.family = PP_NETADDRESSFAMILY_IPV4;
   hint.flags = PP_HOST_RESOLVER_FLAGS_CANONNAME;
   return ParametrizedTestResolve(hint);
 }