Added pepper test for SSLHandshake

ppapi/tests/test_udp_socket_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 <string.h>
 
 #include "ppapi/cpp/module.h"
-#include "ppapi/tests/test_udp_socket_private_shared.h"
+#include "ppapi/tests/test_udp_socket_private.h"
 #include "ppapi/tests/test_utils.h"
 #include "ppapi/tests/testing_instance.h"
 
-REGISTER_TEST_CASE(UDPSocketPrivateShared);
+REGISTER_TEST_CASE(UDPSocketPrivate);
 
-TestUDPSocketPrivateShared::TestUDPSocketPrivateShared(
+TestUDPSocketPrivate::TestUDPSocketPrivate(
     TestingInstance* instance)
     : TestCase(instance),
       tcp_socket_private_interface_(NULL),
       udp_socket_private_interface_(NULL) {
 }
 
-bool TestUDPSocketPrivateShared::Init() {
+bool TestUDPSocketPrivate::Init() {
   tcp_socket_private_interface_ = static_cast<const PPB_TCPSocket_Private*>(
       pp::Module::Get()->GetBrowserInterface(PPB_TCPSOCKET_PRIVATE_INTERFACE));
   if (!tcp_socket_private_interface_)
     instance_->AppendError("TCPSocketPrivate interface not available");
 
   udp_socket_private_interface_ = static_cast<const PPB_UDPSocket_Private*>(
       pp::Module::Get()->GetBrowserInterface(PPB_UDPSOCKET_PRIVATE_INTERFACE));
   if (!udp_socket_private_interface_)
     instance_->AppendError("UDPSocketPrivate interface not available");
 
   bool init_host_port = false;
   if (!GetLocalHostPort(instance_->pp_instance(), &host_, &port_))
     instance_->AppendError("Can't init host and port");
   else
     init_host_port = true;
 
   return tcp_socket_private_interface_ &&
       udp_socket_private_interface_ &&
       init_host_port &&
       CheckTestingInterface();
 }
 
-void TestUDPSocketPrivateShared::RunTests(const std::string& filter) {
+void TestUDPSocketPrivate::RunTests(const std::string& filter) {
   RUN_TEST(Create, filter);
   RUN_TEST_FORCEASYNC_AND_NOT(Connect, filter);
   RUN_TEST_FORCEASYNC_AND_NOT(ConnectFailure, filter);
 }
 
-void TestUDPSocketPrivateShared::QuitMessageLoop() {
-  testing_interface_->QuitMessageLoop(instance_->pp_instance());
-}
-
-std::string TestUDPSocketPrivateShared::GenerateNetAddress(
+std::string TestUDPSocketPrivate::GenerateNetAddress(
     PP_Resource* socket, PP_NetAddress_Private* address) {
    *socket = tcp_socket_private_interface_->Create(instance_->pp_instance());
    if (0 == *socket)
      return "PPB_TCPSocket_Private::Create failed";
 
   TestCompletionCallback callback(instance_->pp_instance(), force_async_);
   int32_t rv = tcp_socket_private_interface_->Connect(
       *socket, host_.c_str(), port_,
       static_cast<pp::CompletionCallback>(callback).pp_completion_callback());
   if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
     return ReportError("PPB_TCPSocket_Private::Connect force_async", rv);
   if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return ReportError("PPB_TCPSocket_Private::Connect", rv);
 
   rv = tcp_socket_private_interface_->GetLocalAddress(*socket, address);
   if (rv != PP_TRUE)
     return ReportError("PPB_TCPSocket_Private::GetLocalAddress", rv);
 
   PASS();
 }
 
-std::string TestUDPSocketPrivateShared::CreateAndBindUDPSocket(
+std::string TestUDPSocketPrivate::CreateAndBindUDPSocket(
     PP_NetAddress_Private *address,
     PP_Resource *socket) {
   *socket = udp_socket_private_interface_->Create(instance_->pp_instance());
   if (0 == *socket)
     return "PPB_UDPSocket_Private::Create failed";
   if (!udp_socket_private_interface_->IsUDPSocket(*socket))
     return "PPB_UDPSocket_Private::IsUDPSocket failed";
 
   TestCompletionCallback callback(instance_->pp_instance(), force_async_);
   int32_t rv = udp_socket_private_interface_->Bind(
       *socket, address,
       static_cast<pp::CompletionCallback>(callback).pp_completion_callback());
 
   if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
     return ReportError("PPB_UDPSocket_Private::Bind force_async", rv);
   if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return ReportError("PPB_UDPSocket_Private::Bind", rv);
 
   if (!udp_socket_private_interface_->GetBoundAddress(*socket, address))
       return "PPB_UDPSocket_Private::GetBoundAddress: Failed";
 
   PASS();
 }
 
-std::string TestUDPSocketPrivateShared::BindUDPSocketFailure(
+std::string TestUDPSocketPrivate::BindUDPSocketFailure(
     PP_NetAddress_Private *address,
     PP_Resource *socket) {
   *socket = udp_socket_private_interface_->Create(instance_->pp_instance());
   if (0 == *socket)
     return "PPB_UDPSocket_Private::Create failed";
   if (!udp_socket_private_interface_->IsUDPSocket(*socket))
     return "PPB_UDPSocket_Private::IsUDPSocket failed";
 
   TestCompletionCallback callback(instance_->pp_instance(), force_async_);
   int32_t rv = udp_socket_private_interface_->Bind(
       *socket, address,
       static_cast<pp::CompletionCallback>(callback).pp_completion_callback());
 
   if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
     return ReportError("PPB_UDPSocket_Private::Bind force_async", rv);
   if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv == PP_OK)
     return ReportError("PPB_UDPSocket_Private::Bind", rv);
 
   if (udp_socket_private_interface_->GetBoundAddress(*socket, address))
       return "PPB_UDPSocket_Private::GetBoundAddress: Failed";
 
   PASS();
 }
 
-std::string TestUDPSocketPrivateShared::TestCreate() {
+std::string TestUDPSocketPrivate::TestCreate() {
   PP_Resource udp_socket;
   std::string error_message;
 
   udp_socket = udp_socket_private_interface_->Create(0);
   if (0 != udp_socket)
     return "PPB_UDPSocket_Private::Create returns valid socket " \
         "for invalid instance";
 
   udp_socket = udp_socket_private_interface_->Create(instance_->pp_instance());
   if (0 == udp_socket)
     return "PPB_UDPSocket_Private::Create failed";
   if (!udp_socket_private_interface_->IsUDPSocket(udp_socket))
     return "PPB_UDPSocket_Private::IsUDPSocket failed";
 
   PASS();
 }
 
-std::string TestUDPSocketPrivateShared::TestConnect() {
+std::string TestUDPSocketPrivate::TestConnect() {
   PP_NetAddress_Private server_address, client_address;
   PP_Resource tcp_socket_server, tcp_socket_client;
   std::string error_message;
 
   error_message = GenerateNetAddress(&tcp_socket_server, &server_address);
   if (!error_message.empty())
     return error_message;
   error_message = GenerateNetAddress(&tcp_socket_client, &client_address);
   if (!error_message.empty())
     return error_message;
@@ skipping 48 matching lines @@
   tcp_socket_private_interface_->Disconnect(tcp_socket_server);
   tcp_socket_private_interface_->Disconnect(tcp_socket_client);
 
   if (udp_socket_private_interface_->GetBoundAddress(
       socket_server, &server_address))
     return "PPB_UDPSocket_Private::GetBoundAddress: expected Failure";
 
   PASS();
 }
 
-std::string TestUDPSocketPrivateShared::TestConnectFailure() {
+std::string TestUDPSocketPrivate::TestConnectFailure() {
   std::string error_message;
   PP_NetAddress_Private invalid_address = { 0 };
   PP_Resource socket;
 
   error_message = BindUDPSocketFailure(&invalid_address, &socket);
   if (!error_message.empty())
     return error_message;
 
   PASS();
 }