PPAPI: Refactor ppapi test callbacks to ease testing blocking callbacks.

ppapi/tests/test_websocket.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_websocket.h"
 
 #include <stdio.h>
 #include <string.h>
 #include <algorithm>
 #include <string>
@@ skipping 264 matching lines @@
     return 0;
   PP_Var url_var = CreateVarString(url);
   TestCompletionCallback callback(instance_->pp_instance(), force_async_);
   uint32_t protocol_count = 0U;
   if (protocol.size()) {
     protocols[0] = CreateVarString(protocol);
     protocol_count = 1U;
   }
   *result = websocket_interface_->Connect(
       ws, url_var, protocols, protocol_count,
-      static_cast<pp::CompletionCallback>(callback).pp_completion_callback());
+      callback.GetCallback().pp_completion_callback());
   ReleaseVar(url_var);
   if (protocol.size())
     ReleaseVar(protocols[0]);
   if (*result == PP_OK_COMPLETIONPENDING)
     *result = callback.WaitForResult();
   return ws;
 }
 
 std::string TestWebSocket::TestIsWebSocket() {
   // Test that a NULL resource isn't a websocket.
@@ skipping 53 matching lines @@
 
 std::string TestWebSocket::TestInvalidConnect() {
   PP_Var protocols[] = { PP_MakeUndefined() };
 
   PP_Resource ws = websocket_interface_->Create(instance_->pp_instance());
   ASSERT_TRUE(ws);
 
   TestCompletionCallback callback(instance_->pp_instance(), force_async_);
   int32_t result = websocket_interface_->Connect(
       ws, PP_MakeUndefined(), protocols, 1U,
-      static_cast<pp::CompletionCallback>(callback).pp_completion_callback());
+      callback.GetCallback().pp_completion_callback());
   ASSERT_EQ(PP_ERROR_BADARGUMENT, result);
 
   result = websocket_interface_->Connect(
       ws, PP_MakeUndefined(), protocols, 1U,
-      static_cast<pp::CompletionCallback>(callback).pp_completion_callback());
+      callback.GetCallback().pp_completion_callback());
   ASSERT_EQ(PP_ERROR_INPROGRESS, result);
 
   core_interface_->ReleaseResource(ws);
 
   for (int i = 0; kInvalidURLs[i]; ++i) {
     ws = Connect(kInvalidURLs[i], &result, "");
     ASSERT_TRUE(ws);
     ASSERT_EQ(PP_ERROR_BADARGUMENT, result);
 
     core_interface_->ReleaseResource(ws);
@@ skipping 11 matching lines @@
   PP_Var good_protocols[] = {
     CreateVarString("x-test"),
     CreateVarString("x-yatest")
   };
 
   PP_Resource ws = websocket_interface_->Create(instance_->pp_instance());
   ASSERT_TRUE(ws);
   TestCompletionCallback callback(instance_->pp_instance(), force_async_);
   int32_t result = websocket_interface_->Connect(
       ws, url, bad_protocols, 2U,
-      static_cast<pp::CompletionCallback>(callback).pp_completion_callback());
+      callback.GetCallback().pp_completion_callback());
   if (result == PP_OK_COMPLETIONPENDING)
     result = callback.WaitForResult();
   ASSERT_EQ(PP_ERROR_BADARGUMENT, result);
   core_interface_->ReleaseResource(ws);
 
   ws = websocket_interface_->Create(instance_->pp_instance());
   ASSERT_TRUE(ws);
   result = websocket_interface_->Connect(
       ws, url, good_protocols, 2U, PP_BlockUntilComplete());
   ASSERT_EQ(PP_ERROR_BLOCKS_MAIN_THREAD, result);
@@ skipping 38 matching lines @@
 }
 
 std::string TestWebSocket::TestInvalidClose() {
   PP_Var reason = CreateVarString("close for test");
   TestCompletionCallback callback(instance_->pp_instance());
 
   // Close before connect.
   PP_Resource ws = websocket_interface_->Create(instance_->pp_instance());
   int32_t result = websocket_interface_->Close(
       ws, PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, reason,
-      static_cast<pp::CompletionCallback>(callback).pp_completion_callback());
+      callback.GetCallback().pp_completion_callback());
   ASSERT_EQ(PP_ERROR_FAILED, result);
   core_interface_->ReleaseResource(ws);
 
   // Close with bad arguments.
   ws = Connect(GetFullURL(kEchoServerURL), &result, "");
   ASSERT_TRUE(ws);
   ASSERT_EQ(PP_OK, result);
   result = websocket_interface_->Close(ws, 1U, reason,
-      static_cast<pp::CompletionCallback>(callback).pp_completion_callback());
+      callback.GetCallback().pp_completion_callback());
   ASSERT_EQ(PP_ERROR_NOACCESS, result);
   core_interface_->ReleaseResource(ws);
 
   ReleaseVar(reason);
 
   PASS();
 }
 
 std::string TestWebSocket::TestValidClose() {
   PP_Var reason = CreateVarString("close for test");
   PP_Var url = CreateVarString(GetFullURL(kEchoServerURL).c_str());
   PP_Var protocols[] = { PP_MakeUndefined() };
   TestCompletionCallback callback(instance_->pp_instance());
   TestCompletionCallback another_callback(instance_->pp_instance());
 
   // Close.
   int32_t result;
   PP_Resource ws = Connect(GetFullURL(kEchoServerURL), &result, "");
   ASSERT_TRUE(ws);
   ASSERT_EQ(PP_OK, result);
   result = websocket_interface_->Close(ws,
       PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, reason,
-      static_cast<pp::CompletionCallback>(callback).pp_completion_callback());
+      callback.GetCallback().pp_completion_callback());
   ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
   result = callback.WaitForResult();
   ASSERT_EQ(PP_OK, result);
   core_interface_->ReleaseResource(ws);
 
   // Close in connecting.
   // The ongoing connect failed with PP_ERROR_ABORTED, then the close is done
   // successfully.
   ws = websocket_interface_->Create(instance_->pp_instance());
   result = websocket_interface_->Connect(ws, url, protocols, 0U,
-      static_cast<pp::CompletionCallback>(callback).pp_completion_callback());
+      callback.GetCallback().pp_completion_callback());
   ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
   result = websocket_interface_->Close(ws,
       PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, reason,
-      static_cast<pp::CompletionCallback>(
-          another_callback).pp_completion_callback());
+      another_callback.GetCallback().pp_completion_callback());
   ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
   result = callback.WaitForResult();
   ASSERT_EQ(PP_ERROR_ABORTED, result);
   result = another_callback.WaitForResult();
   ASSERT_EQ(PP_OK, result);
   core_interface_->ReleaseResource(ws);
 
   // Close in closing.
   // The first close will be done successfully, then the second one failed with
   // with PP_ERROR_INPROGRESS immediately.
   ws = Connect(GetFullURL(kEchoServerURL), &result, "");
   ASSERT_TRUE(ws);
   ASSERT_EQ(PP_OK, result);
   result = websocket_interface_->Close(ws,
       PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, reason,
-      static_cast<pp::CompletionCallback>(callback).pp_completion_callback());
+      callback.GetCallback().pp_completion_callback());
   ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
   result = websocket_interface_->Close(ws,
       PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, reason,
-      static_cast<pp::CompletionCallback>(
-          another_callback).pp_completion_callback());
+      another_callback.GetCallback().pp_completion_callback());
   ASSERT_EQ(PP_ERROR_INPROGRESS, result);
   result = callback.WaitForResult();
   ASSERT_EQ(PP_OK, result);
   core_interface_->ReleaseResource(ws);
 
   // Close with ongoing receive message.
   ws = Connect(GetFullURL(kEchoServerURL), &result, "");
   ASSERT_TRUE(ws);
   ASSERT_EQ(PP_OK, result);
   PP_Var receive_message_var;
   result = websocket_interface_->ReceiveMessage(ws, &receive_message_var,
-      static_cast<pp::CompletionCallback>(callback).pp_completion_callback());
+      callback.GetCallback().pp_completion_callback());
   ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
   result = websocket_interface_->Close(ws,
       PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, reason,
-      static_cast<pp::CompletionCallback>(
-          another_callback).pp_completion_callback());
+      another_callback.GetCallback().pp_completion_callback());
   ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
   result = callback.WaitForResult();
   ASSERT_EQ(PP_ERROR_ABORTED, result);
   result = another_callback.WaitForResult();
   ASSERT_EQ(PP_OK, result);
   core_interface_->ReleaseResource(ws);
 
   ReleaseVar(reason);
   ReleaseVar(url);
 
@@ skipping 35 matching lines @@
   const char* message = "hello pepper";
   PP_Var message_var = CreateVarString(message);
   int32_t result = websocket_interface_->SendMessage(ws, message_var);
   ReleaseVar(message_var);
   ASSERT_EQ(PP_OK, result);
 
   // Receive echoed 'hello pepper'.
   TestCompletionCallback callback(instance_->pp_instance(), force_async_);
   PP_Var received_message;
   result = websocket_interface_->ReceiveMessage(ws, &received_message,
-      static_cast<pp::CompletionCallback>(callback).pp_completion_callback());
+      callback.GetCallback().pp_completion_callback());
   ASSERT_FALSE(result != PP_OK && result != PP_OK_COMPLETIONPENDING);
   if (result == PP_OK_COMPLETIONPENDING)
     result = callback.WaitForResult();
   ASSERT_EQ(PP_OK, result);
   ASSERT_TRUE(AreEqualWithString(received_message, message));
   ReleaseVar(received_message);
   core_interface_->ReleaseResource(ws);
 
   PASS();
 }
@@ skipping 11 matching lines @@
     binary[i] = i;
   PP_Var message_var = CreateVarBinary(binary);
   int32_t result = websocket_interface_->SendMessage(ws, message_var);
   ReleaseVar(message_var);
   ASSERT_EQ(PP_OK, result);
 
   // Receive echoed binary.
   TestCompletionCallback callback(instance_->pp_instance(), force_async_);
   PP_Var received_message;
   result = websocket_interface_->ReceiveMessage(ws, &received_message,
-      static_cast<pp::CompletionCallback>(callback).pp_completion_callback());
+      callback.GetCallback().pp_completion_callback());
   ASSERT_TRUE(result == PP_OK || result == PP_OK_COMPLETIONPENDING);
   if (result == PP_OK_COMPLETIONPENDING)
     result = callback.WaitForResult();
   ASSERT_EQ(PP_OK, result);
   ASSERT_TRUE(AreEqualWithBinary(received_message, binary));
   ReleaseVar(received_message);
   core_interface_->ReleaseResource(ws);
 
   PASS();
 }
@@ skipping 21 matching lines @@
     ASSERT_EQ(PP_OK, result);
   }
   ReleaseVar(text_var);
   ReleaseVar(binary_var);
 
   // Receive echoed data.
   for (int i = 0; i < 512; ++i) {
     TestCompletionCallback callback(instance_->pp_instance(), force_async_);
     PP_Var received_message;
     int32_t result = websocket_interface_->ReceiveMessage(
-        ws, &received_message, static_cast<pp::CompletionCallback>(
-            callback).pp_completion_callback());
+        ws, &received_message, callback.GetCallback().pp_completion_callback());
     ASSERT_TRUE(result == PP_OK || result == PP_OK_COMPLETIONPENDING);
     if (result == PP_OK_COMPLETIONPENDING)
       result = callback.WaitForResult();
     ASSERT_EQ(PP_OK, result);
     if (i & 1) {
       ASSERT_TRUE(AreEqualWithBinary(received_message, binary));
     } else {
       ASSERT_TRUE(AreEqualWithString(received_message, text));
     }
     ReleaseVar(received_message);
@@ skipping 25 matching lines @@
     if (buffered_amount > 262144)
       break;
   }
 
   // Close connection.
   std::string reason_str = "close while busy";
   PP_Var reason = CreateVarString(reason_str.c_str());
   TestCompletionCallback callback(instance_->pp_instance());
   result = websocket_interface_->Close(ws,
       PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE, reason,
-      static_cast<pp::CompletionCallback>(callback).pp_completion_callback());
+      callback.GetCallback().pp_completion_callback());
   ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
   ASSERT_EQ(PP_WEBSOCKETREADYSTATE_CLOSING,
       websocket_interface_->GetReadyState(ws));
 
   result = callback.WaitForResult();
   ASSERT_EQ(PP_OK, result);
   ASSERT_EQ(PP_WEBSOCKETREADYSTATE_CLOSED,
       websocket_interface_->GetReadyState(ws));
 
   uint64_t base_buffered_amount = websocket_interface_->GetBufferedAmount(ws);
@@ skipping 420 matching lines @@
   size_t last_event = events_on_closed - 1;
   for (uint32_t i = 1; i < last_event; ++i) {
     ASSERT_EQ(WebSocketEvent::EVENT_MESSAGE, events[i].event_type);
     ASSERT_TRUE(AreEqualWithString(events[i].var.pp_var(), message));
   }
   ASSERT_EQ(WebSocketEvent::EVENT_CLOSE, events[last_event].event_type);
   ASSERT_TRUE(events[last_event].was_clean);
 
   PASS();
 }