Fixed tests for UDP sockets.

BUG=chromium:120470
TEST=browser_tests:*.UDPSocketPrivate


Review URL: http://codereview.chromium.org/10196012

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@134084 0039d316-1c4b-4281-b951-d872f2087c98

4 files changed, 120 insertions, 169 deletions

diff --git a/ppapi/cpp/private/udp_socket_private.cc b/ppapi/cpp/private/udp_socket_private.cc
index 34c3e54..135e87e 100644
--- a/ppapi/cpp/private/udp_socket_private.cc
+++ b/ppapi/cpp/private/udp_socket_private.cc
@@ -15,32 +15,37 @@ namespace pp {
 
 namespace {
 
-template <> const char* interface_name<PPB_UDPSocket_Private>() {
-  return PPB_UDPSOCKET_PRIVATE_INTERFACE;
+template <> const char* interface_name<PPB_UDPSocket_Private_0_3>() {
+  return PPB_UDPSOCKET_PRIVATE_INTERFACE_0_3;
 }
 
 }  // namespace
 
 UDPSocketPrivate::UDPSocketPrivate(const InstanceHandle& instance) {
-  if (has_interface<PPB_UDPSocket_Private>()) {
-    PassRefFromConstructor(get_interface<PPB_UDPSocket_Private>()->Create(
+  if (has_interface<PPB_UDPSocket_Private_0_3>()) {
+    PassRefFromConstructor(get_interface<PPB_UDPSocket_Private_0_3>()->Create(
                                instance.pp_instance()));
   }
 }
 
+// static
+bool UDPSocketPrivate::IsAvailable() {
+  return has_interface<PPB_UDPSocket_Private_0_3>();
+}
+
 int32_t UDPSocketPrivate::Bind(const PP_NetAddress_Private* addr,
                                const CompletionCallback& callback) {
-  if (!has_interface<PPB_UDPSocket_Private>())
+  if (!has_interface<PPB_UDPSocket_Private_0_3>())
     return PP_ERROR_NOINTERFACE;
-  return get_interface<PPB_UDPSocket_Private>()->Bind(
+  return get_interface<PPB_UDPSocket_Private_0_3>()->Bind(
       pp_resource(), addr, callback.pp_completion_callback());
 }
 
 bool UDPSocketPrivate::GetBoundAddress(PP_NetAddress_Private* addr) {
-  if (!has_interface<PPB_UDPSocket_Private>())
+  if (!has_interface<PPB_UDPSocket_Private_0_3>())
     return false;
 
-  PP_Bool result = get_interface<PPB_UDPSocket_Private>()->GetBoundAddress(
+  PP_Bool result = get_interface<PPB_UDPSocket_Private_0_3>()->GetBoundAddress(
       pp_resource(), addr);
   return PP_ToBool(result);
 }
@@ -48,18 +53,19 @@ bool UDPSocketPrivate::GetBoundAddress(PP_NetAddress_Private* addr) {
 int32_t UDPSocketPrivate::RecvFrom(char* buffer,
                                    int32_t num_bytes,
                                    const CompletionCallback& callback) {
-  if (!has_interface<PPB_UDPSocket_Private>())
+  if (!has_interface<PPB_UDPSocket_Private_0_3>())
     return PP_ERROR_NOINTERFACE;
-  return get_interface<PPB_UDPSocket_Private>()->RecvFrom(
+  return get_interface<PPB_UDPSocket_Private_0_3>()->RecvFrom(
       pp_resource(), buffer, num_bytes, callback.pp_completion_callback());
 }
 
 bool UDPSocketPrivate::GetRecvFromAddress(PP_NetAddress_Private* addr) {
-  if (!has_interface<PPB_UDPSocket_Private>())
+  if (!has_interface<PPB_UDPSocket_Private_0_3>())
     return false;
 
-  PP_Bool result = get_interface<PPB_UDPSocket_Private>()->GetRecvFromAddress(
-      pp_resource(), addr);
+  PP_Bool result =
+      get_interface<PPB_UDPSocket_Private_0_3>()->GetRecvFromAddress(
+          pp_resource(), addr);
   return PP_ToBool(result);
 }
 
@@ -67,17 +73,16 @@ int32_t UDPSocketPrivate::SendTo(const char* buffer,
                                  int32_t num_bytes,
                                  const PP_NetAddress_Private* addr,
                                  const CompletionCallback& callback) {
-  if (!has_interface<PPB_UDPSocket_Private>())
+  if (!has_interface<PPB_UDPSocket_Private_0_3>())
     return PP_ERROR_NOINTERFACE;
-  return get_interface<PPB_UDPSocket_Private>()->SendTo(
+  return get_interface<PPB_UDPSocket_Private_0_3>()->SendTo(
       pp_resource(), buffer, num_bytes, addr,
       callback.pp_completion_callback());
 }
 
 void UDPSocketPrivate::Close() {
-  if (!has_interface<PPB_UDPSocket_Private>())
+  if (!has_interface<PPB_UDPSocket_Private_0_3>())
     return;
-  return get_interface<PPB_UDPSocket_Private>()->Close(pp_resource());
+  return get_interface<PPB_UDPSocket_Private_0_3>()->Close(pp_resource());
 }
 }  // namespace pp
-
diff --git a/ppapi/cpp/private/udp_socket_private.h b/ppapi/cpp/private/udp_socket_private.h
index e80091c..5179e72 100644
--- a/ppapi/cpp/private/udp_socket_private.h
+++ b/ppapi/cpp/private/udp_socket_private.h
@@ -18,6 +18,9 @@ class UDPSocketPrivate : public Resource {
  public:
   explicit UDPSocketPrivate(const InstanceHandle& instance);
 
+  // Returns true if the required interface is available.
+  static bool IsAvailable();
+
   int32_t Bind(const PP_NetAddress_Private* addr,
                const CompletionCallback& callback);
   bool GetBoundAddress(PP_NetAddress_Private* addr);
@@ -35,4 +38,3 @@ class UDPSocketPrivate : public Resource {
 }  // namespace pp
 
 #endif  // PPAPI_CPP_PRIVATE_UDP_SOCKET_PRIVATE_H_
-
diff --git a/ppapi/tests/test_udp_socket_private.cc b/ppapi/tests/test_udp_socket_private.cc
index 182e683..e3c3566 100644
--- a/ppapi/tests/test_udp_socket_private.cc
+++ b/ppapi/tests/test_udp_socket_private.cc
@@ -2,222 +2,172 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include <string.h>
+#include <cstring>
 
 #include "ppapi/cpp/module.h"
+#include "ppapi/cpp/private/net_address_private.h"
+#include "ppapi/cpp/private/tcp_socket_private.h"
 #include "ppapi/tests/test_udp_socket_private.h"
 #include "ppapi/tests/test_utils.h"
 #include "ppapi/tests/testing_instance.h"
 
 REGISTER_TEST_CASE(UDPSocketPrivate);
 
+namespace {
+
+const uint16_t kPortScanFrom = 1024;
+const uint16_t kPortScanTo = 4096;
+
+}  // namespace
+
 TestUDPSocketPrivate::TestUDPSocketPrivate(
     TestingInstance* instance)
-    : TestCase(instance),
-      tcp_socket_private_interface_(NULL),
-      udp_socket_private_interface_(NULL) {
+    : TestCase(instance) {
 }
 
 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_))
+  bool tcp_socket_private_is_available = pp::TCPSocketPrivate::IsAvailable();
+  if (!tcp_socket_private_is_available)
+    instance_->AppendError("PPB_TCPSocket_Private interface not available");
+
+  bool udp_socket_private_is_available = pp::UDPSocketPrivate::IsAvailable();
+  if (!udp_socket_private_is_available)
+    instance_->AppendError("PPB_UDPSocket_Private interface not available");
+
+  bool net_address_private_is_available = pp::NetAddressPrivate::IsAvailable();
+  if (!net_address_private_is_available)
+    instance_->AppendError("PPB_NetAddress_Private interface not available");
+
+  bool init_host_port = GetLocalHostPort(instance_->pp_instance(),
+                                         &host_, &port_);
+  if (!init_host_port)
     instance_->AppendError("Can't init host and port");
-  else
-    init_host_port = true;
 
-  return tcp_socket_private_interface_ &&
-      udp_socket_private_interface_ &&
+  return tcp_socket_private_is_available &&
+      udp_socket_private_is_available &&
+      net_address_private_is_available &&
       init_host_port &&
-      CheckTestingInterface();
+      CheckTestingInterface() &&
+      EnsureRunningOverHTTP();
 }
 
 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);
 }
 
-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";
-
+std::string TestUDPSocketPrivate::GetLocalAddress(
+    PP_NetAddress_Private* address) {
+  pp::TCPSocketPrivate socket(instance_);
   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());
+  int32_t rv = socket.Connect(host_.c_str(), port_, 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);
-
+  if (!socket.GetLocalAddress(address))
+    return "PPB_TCPSocket_Private::GetLocalAddress: Failed";
+  socket.Disconnect();
   PASS();
 }
 
-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";
-
+std::string TestUDPSocketPrivate::BindUDPSocket(
+    pp::UDPSocketPrivate* socket,
+    PP_NetAddress_Private *address) {
+  PP_NetAddress_Private base_address;
+  ASSERT_SUBTEST_SUCCESS(GetLocalAddress(&base_address));
+
+  bool is_free_port_found = false;
+  for (uint16_t port = kPortScanFrom; port < kPortScanTo; ++port) {
+    if (!pp::NetAddressPrivate::ReplacePort(base_address, port, address))
+      return "PPB_NetAddress_Private::ReplacePort: Failed";
+    TestCompletionCallback callback(instance_->pp_instance(), force_async_);
+    int32_t rv = socket->Bind(address, 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) {
+      is_free_port_found = true;
+      break;
+    }
+  }
+  if (!is_free_port_found)
+    return "Can't find available port";
+  if (!socket->GetBoundAddress(address))
+    return "PPB_UDPSocket_Private::GetBoundAddress: Failed";
   PASS();
 }
 
 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";
-
+    pp::UDPSocketPrivate* socket,
+    PP_NetAddress_Private *address) {
   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());
-
+  int32_t rv = socket->Bind(address, 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))
+  if (socket->GetBoundAddress(address))
       return "PPB_UDPSocket_Private::GetBoundAddress: Failed";
-
-  PASS();
-}
-
-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 TestUDPSocketPrivate::TestConnect() {
+  pp::UDPSocketPrivate server_socket(instance_), client_socket(instance_);
   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;
-
-  PP_Resource socket_server, socket_client;
-  error_message = CreateAndBindUDPSocket(&server_address, &socket_server);
-  if (!error_message.empty())
-    return error_message;
-  error_message = CreateAndBindUDPSocket(&client_address, &socket_client);
-  if (!error_message.empty())
-    return error_message;
+  ASSERT_SUBTEST_SUCCESS(BindUDPSocket(&server_socket, &server_address));
+  ASSERT_SUBTEST_SUCCESS(BindUDPSocket(&client_socket, &client_address));
 
   static const char* const kMessage =
       "Simple message that will be sent via UDP";
   static const size_t kMessageBufferSize = 1024;
   char message_buffer[kMessageBufferSize];
 
-  TestCompletionCallback write_cb(instance_->pp_instance(), force_async_);
-  int32_t write_rv = udp_socket_private_interface_->SendTo(
-      socket_client,
-      kMessage,
-      strlen(kMessage),
-      &server_address,
-      static_cast<pp::CompletionCallback>(write_cb).pp_completion_callback());
+  TestCompletionCallback write_callback(instance_->pp_instance(), force_async_);
+  int32_t write_rv = client_socket.SendTo(kMessage, strlen(kMessage),
+                                          &server_address,
+                                          write_callback);
   if (force_async_ && write_rv != PP_OK_COMPLETIONPENDING)
     return ReportError("PPB_UDPSocket_Private::SendTo force_async", write_rv);
 
-  TestCompletionCallback read_cb(instance_->pp_instance(), force_async_);
-  int32_t read_rv = udp_socket_private_interface_->RecvFrom(
-      socket_server,
-      message_buffer,
-      strlen(kMessage),
-      static_cast<pp::CompletionCallback>(read_cb).pp_completion_callback());
+  TestCompletionCallback read_callback(instance_->pp_instance(), force_async_);
+  int32_t read_rv = server_socket.RecvFrom(message_buffer, strlen(kMessage),
+                                           read_callback);
   if (force_async_ && read_rv != PP_OK_COMPLETIONPENDING)
     return ReportError("PPB_UDPSocket_Private::RecvFrom force_async", read_rv);
 
   if (read_rv == PP_OK_COMPLETIONPENDING)
-    read_rv = read_cb.WaitForResult();
+    read_rv = read_callback.WaitForResult();
   if (read_rv < 0 || strlen(kMessage) != static_cast<size_t>(read_rv))
     return ReportError("PPB_UDPSocket_Private::RecvFrom", read_rv);
 
   if (write_rv == PP_OK_COMPLETIONPENDING)
-    write_rv = write_cb.WaitForResult();
+    write_rv = write_callback.WaitForResult();
   if (write_rv < 0 || strlen(kMessage) != static_cast<size_t>(write_rv))
     return ReportError("PPB_UDPSocket_Private::SendTo", write_rv);
 
   ASSERT_EQ(0, strncmp(kMessage, message_buffer, strlen(kMessage)));
 
-  udp_socket_private_interface_->Close(socket_server);
-  udp_socket_private_interface_->Close(socket_client);
-
-  tcp_socket_private_interface_->Disconnect(tcp_socket_server);
-  tcp_socket_private_interface_->Disconnect(tcp_socket_client);
+  server_socket.Close();
+  client_socket.Close();
 
-  if (udp_socket_private_interface_->GetBoundAddress(
-      socket_server, &server_address))
+  if (server_socket.GetBoundAddress(&server_address))
     return "PPB_UDPSocket_Private::GetBoundAddress: expected Failure";
 
   PASS();
 }
 
 std::string TestUDPSocketPrivate::TestConnectFailure() {
-  std::string error_message;
-  PP_NetAddress_Private invalid_address = { 0 };
-  PP_Resource socket;
+  pp::UDPSocketPrivate socket(instance_);
+  PP_NetAddress_Private invalid_address = {};
 
-  error_message = BindUDPSocketFailure(&invalid_address, &socket);
+  std::string error_message = BindUDPSocketFailure(&socket, &invalid_address);
   if (!error_message.empty())
     return error_message;
 
diff --git a/ppapi/tests/test_udp_socket_private.h b/ppapi/tests/test_udp_socket_private.h
index 45cd642..a164842 100644
--- a/ppapi/tests/test_udp_socket_private.h
+++ b/ppapi/tests/test_udp_socket_private.h
@@ -5,7 +5,9 @@
 #ifndef PPAPI_TESTS_TEST_UDP_SOCKET_PRIVATE_H_
 #define PPAPI_TESTS_TEST_UDP_SOCKET_PRIVATE_H_
 
-#include "ppapi/cpp/private/tcp_socket_private.h"
+#include <string>
+
+#include "ppapi/c/pp_stdint.h"
 #include "ppapi/cpp/private/udp_socket_private.h"
 #include "ppapi/tests/test_case.h"
 
@@ -18,23 +20,15 @@ class TestUDPSocketPrivate : public TestCase {
   virtual void RunTests(const std::string& filter);
 
  private:
-  // Creates tcp_socket and connects to www.google.com:80. After that,
-  // stores into |address| local address and returns created
-  // tcp_socket. This is a way to create |PP_NetAddress_Private|
-  // structure filled with local IP and some free port.
-  std::string GenerateNetAddress(PP_Resource* socket,
-                                 PP_NetAddress_Private* address);
-  std::string CreateAndBindUDPSocket(PP_NetAddress_Private *address,
-                                     PP_Resource *socket);
-  std::string BindUDPSocketFailure(PP_NetAddress_Private *address,
-                                   PP_Resource *socket);
-
-  std::string TestCreate();
+  std::string GetLocalAddress(PP_NetAddress_Private* address);
+  std::string BindUDPSocket(pp::UDPSocketPrivate* socket,
+                            PP_NetAddress_Private *address);
+  std::string BindUDPSocketFailure(pp::UDPSocketPrivate* socket,
+                                   PP_NetAddress_Private *address);
+
   std::string TestConnect();
   std::string TestConnectFailure();
 
-  const PPB_TCPSocket_Private* tcp_socket_private_interface_;
-  const PPB_UDPSocket_Private* udp_socket_private_interface_;
   std::string host_;
   uint16_t port_;
 };