Landing 8688002: PPB_TCPSocket_Private/PPB_UDPSocket_Private are exposed to Browser

Review URL: http://codereview.chromium.org/8688002
Patch from Yuri Gorshenin <ygorshenin@chromium.org>.

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

4 files changed, 544 insertions, 0 deletions

diff --git a/ppapi/tests/test_tcp_socket_private_shared.cc b/ppapi/tests/test_tcp_socket_private_shared.cc
new file mode 100644
index 0000000..7ca3666
--- /dev/null
+++ b/ppapi/tests/test_tcp_socket_private_shared.cc
@@ -0,0 +1,271 @@
+// Copyright (c) 2011 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_tcp_socket_private_shared.h"
+
+#include <string.h>
+#include <new>
+#include <string>
+#include <vector>
+
+#include "ppapi/cpp/module.h"
+#include "ppapi/tests/test_utils.h"
+#include "ppapi/tests/testing_instance.h"
+
+REGISTER_TEST_CASE(TCPSocketPrivateShared);
+
+// TODO(ygorshenin): get rid of using external server in tests,
+// http://crbug.com/105863
+const char* const TestTCPSocketPrivateShared::kHost = "www.google.com";
+
+TestTCPSocketPrivateShared::TestTCPSocketPrivateShared(
+    TestingInstance* instance)
+    : TestCase(instance), tcp_socket_private_interface_(NULL) {
+}
+
+bool TestTCPSocketPrivateShared::Init() {
+  tcp_socket_private_interface_ =
+      reinterpret_cast<PPB_TCPSocket_Private const*>(
+          pp::Module::Get()->GetBrowserInterface(
+              PPB_TCPSOCKET_PRIVATE_INTERFACE));
+  if (!tcp_socket_private_interface_)
+    instance_->AppendError("TCPSocketPrivate interface not available");
+  return tcp_socket_private_interface_ && InitTestingInterface();
+}
+
+void TestTCPSocketPrivateShared::RunTests(const std::string& filter) {
+  RUN_TEST(Create, filter);
+  RUN_TEST_FORCEASYNC_AND_NOT(GetAddress, filter);
+  RUN_TEST_FORCEASYNC_AND_NOT(Connect, filter);
+  RUN_TEST_FORCEASYNC_AND_NOT(Reconnect, filter);
+}
+
+void TestTCPSocketPrivateShared::QuitMessageLoop() {
+  testing_interface_->QuitMessageLoop(instance_->pp_instance());
+}
+
+std::string TestTCPSocketPrivateShared::CreateSocket(PP_Resource* socket) {
+  *socket = tcp_socket_private_interface_->Create(instance_->pp_instance());
+  if (0 == *socket)
+    return "PPB_TCPSocket_Private::Create failed";
+  if (!tcp_socket_private_interface_->IsTCPSocket(*socket))
+    return "PPB_TCPSocket_Private::IsTCPSocket failed";
+  PASS();
+}
+
+std::string TestTCPSocketPrivateShared::SyncConnect(PP_Resource socket,
+                                                    const char* host,
+                                                    int port) {
+  TestCompletionCallback callback(instance_->pp_instance(), force_async_);
+
+  int32_t rv = tcp_socket_private_interface_->Connect(
+      socket, host, 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);
+  PASS();
+}
+
+std::string TestTCPSocketPrivateShared::SyncConnectWithNetAddress(
+    PP_Resource socket, const PP_NetAddress_Private& addr) {
+  TestCompletionCallback callback(instance_->pp_instance(), force_async_);
+
+  int32_t rv = tcp_socket_private_interface_->ConnectWithNetAddress(
+      socket, &addr,
+      static_cast<pp::CompletionCallback>(callback).pp_completion_callback());
+
+  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+    return ReportError(
+        "PPB_TCPSocket_Private::ConnectWithNetAddress force_async", rv);
+  if (rv == PP_OK_COMPLETIONPENDING)
+    rv = callback.WaitForResult();
+  if (rv != PP_OK)
+    return ReportError("PPB_TCPSocket_Private::ConnectWithNetAddress", rv);
+  PASS();
+}
+
+std::string TestTCPSocketPrivateShared::SyncSSLHandshake(PP_Resource socket,
+                                                         const char* host,
+                                                         int port) {
+  TestCompletionCallback callback(instance_->pp_instance(), force_async_);
+
+  int32_t rv = tcp_socket_private_interface_->SSLHandshake(
+      socket, host, port,
+      static_cast<pp::CompletionCallback>(callback).pp_completion_callback());
+
+  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+    return ReportError("PPB_TCPSocket_Private::SSLHandshake force_async", rv);
+  if (rv == PP_OK_COMPLETIONPENDING)
+    rv = callback.WaitForResult();
+  if (rv != PP_OK)
+    return ReportError("PPB_TCPSocket_Private::SSLHandshake", rv);
+  PASS();
+}
+
+std::string TestTCPSocketPrivateShared::SyncRead(PP_Resource socket,
+                                                 char* buffer,
+                                                 int32_t num_bytes,
+                                                 int32_t* bytes_read) {
+  TestCompletionCallback callback(instance_->pp_instance(), force_async_);
+
+  int32_t rv = tcp_socket_private_interface_->Read(
+      socket, buffer, num_bytes,
+      static_cast<pp::CompletionCallback>(callback).pp_completion_callback());
+
+  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;
+  PASS();
+}
+
+std::string TestTCPSocketPrivateShared::SyncWrite(PP_Resource socket,
+                                                  const char* buffer,
+                                                  int32_t num_bytes,
+                                                  int32_t* bytes_wrote) {
+  TestCompletionCallback callback(instance_->pp_instance(), force_async_);
+  int32_t rv = tcp_socket_private_interface_->Write(
+      socket, buffer, num_bytes,
+      static_cast<pp::CompletionCallback>(callback).pp_completion_callback());
+
+  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_wrote = rv;
+  PASS();
+}
+
+std::string TestTCPSocketPrivateShared::CheckHTTPResponse(
+    PP_Resource socket,
+    const std::string& request,
+    const std::string& response) {
+  int32_t rv;
+  std::string error_message;
+
+  error_message = SyncWrite(socket, request.c_str(), request.size(), &rv);
+  if (!error_message.empty())
+    return error_message;
+
+  std::vector<char> response_buffer(response.size());
+  error_message = SyncRead(socket, &response_buffer[0], response.size(), &rv);
+  if (!error_message.empty())
+    return error_message;
+
+  std::string actual_response(&response_buffer[0], rv);
+
+  if (response != actual_response)
+    return "CheckHTTPResponse failed, expected: " + response +
+        ", actual: " + actual_response;
+  PASS();
+}
+
+std::string TestTCPSocketPrivateShared::TestCreate() {
+  PP_Resource socket = tcp_socket_private_interface_->Create(0);
+  if (0 != socket)
+    return "PPB_TCPSocket_Private::Create returns valid socket " \
+        "for invalid instance";
+
+  return CreateSocket(&socket);
+}
+
+std::string TestTCPSocketPrivateShared::TestGetAddress() {
+  PP_Resource socket;
+  std::string error_message;
+
+  error_message = CreateSocket(&socket);
+  if (!error_message.empty())
+    return error_message;
+
+  error_message = SyncConnect(socket, kHost, kPort);
+  if (!error_message.empty())
+    return error_message;
+
+  PP_NetAddress_Private local_address, remote_address;
+
+  if (PP_TRUE != tcp_socket_private_interface_->GetLocalAddress(
+          socket, &local_address))
+    return "PPB_TCPSocketPrivate::GetLocalAddress failed";
+  if (PP_TRUE != tcp_socket_private_interface_->GetRemoteAddress(
+          socket, &remote_address))
+    return "PPB_TCPSocketPrivate::GetRemoteAddress failed";
+
+  tcp_socket_private_interface_->Disconnect(socket);
+
+  PASS();
+}
+
+std::string TestTCPSocketPrivateShared::TestConnect() {
+  PP_Resource socket;
+  std::string error_message;
+
+  error_message = CreateSocket(&socket);
+  if (!error_message.empty())
+    return error_message;
+  error_message = SyncConnect(socket, kHost, kPort);
+  if (!error_message.empty())
+    return error_message;
+  error_message = SyncSSLHandshake(socket, kHost, kPort);
+  if (!error_message.empty())
+    return error_message;
+  error_message =
+      CheckHTTPResponse(socket, "GET /robots.txt\r\n", "HTTP/1.0 200 OK");
+  if (!error_message.empty())
+    return error_message;
+  tcp_socket_private_interface_->Disconnect(socket);
+
+  PASS();
+}
+
+std::string TestTCPSocketPrivateShared::TestReconnect() {
+  PP_Resource socket;
+  std::string error_message;
+
+  error_message = CreateSocket(&socket);
+  if (!error_message.empty())
+    return error_message;
+  error_message = SyncConnect(socket, kHost, kPort);
+  if (!error_message.empty())
+    return error_message;
+  error_message = SyncSSLHandshake(socket, kHost, kPort);
+  if (!error_message.empty())
+    return error_message;
+
+  PP_NetAddress_Private remote_address;
+  if (PP_TRUE !=
+      tcp_socket_private_interface_->GetRemoteAddress(socket,
+                                                      &remote_address))
+    return "PPB_TCPSocketPrivate::GetRemoteAddress failed";
+  tcp_socket_private_interface_->Disconnect(socket);
+
+  error_message = CreateSocket(&socket);
+  if (!error_message.empty())
+    return error_message;
+  error_message = SyncConnectWithNetAddress(socket, remote_address);
+  if (!error_message.empty())
+    return error_message;
+  error_message = SyncSSLHandshake(socket, kHost, kPort);
+  if (!error_message.empty())
+    return error_message;
+  error_message =
+      CheckHTTPResponse(socket, "GET /robots.txt\r\n", "HTTP/1.0 200 OK");
+  if (!error_message.empty())
+    return error_message;
+  tcp_socket_private_interface_->Disconnect(socket);
+
+  PASS();
+}
diff --git a/ppapi/tests/test_tcp_socket_private_shared.h b/ppapi/tests/test_tcp_socket_private_shared.h
new file mode 100644
index 0000000..72b43b8
--- /dev/null
+++ b/ppapi/tests/test_tcp_socket_private_shared.h
@@ -0,0 +1,49 @@
+// Copyright (c) 2011 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.
+
+#ifndef PPAPI_TESTS_TEST_TCP_SOCKET_PRIVATE_SHARED_H_
+#define PPAPI_TESTS_TEST_TCP_SOCKET_PRIVATE_SHARED_H_
+
+#include <string>
+
+#include "ppapi/c/pp_stdint.h"
+#include "ppapi/cpp/private/tcp_socket_private.h"
+#include "ppapi/tests/test_case.h"
+
+class TestTCPSocketPrivateShared : public TestCase {
+ public:
+  explicit TestTCPSocketPrivateShared(TestingInstance* instance);
+
+  // TestCase implementation.
+  virtual bool Init();
+  virtual void RunTests(const std::string& filter);
+
+  void QuitMessageLoop();
+
+ private:
+  static const char* const kHost;
+  static const int kPort = 443;
+
+  std::string CreateSocket(PP_Resource* socket);
+  std::string SyncConnect(PP_Resource socket, const char* host, int port);
+  std::string SyncConnectWithNetAddress(PP_Resource socket,
+                                        const PP_NetAddress_Private& addr);
+  std::string SyncSSLHandshake(PP_Resource socket, const char* host, int port);
+  std::string SyncRead(PP_Resource socket, char* buffer, int32_t num_bytes,
+                       int32_t* bytes_read);
+  std::string SyncWrite(PP_Resource socket, const char* buffer,
+                        int32_t num_bytes, int32_t* bytes_wrote);
+  std::string CheckHTTPResponse(PP_Resource socket,
+                                const std::string& request,
+                                const std::string& response);
+
+  std::string TestCreate();
+  std::string TestGetAddress();
+  std::string TestConnect();
+  std::string TestReconnect();
+
+  const PPB_TCPSocket_Private* tcp_socket_private_interface_;
+};
+
+#endif  // PPAPI_TESTS_TEST_TCP_SOCKET_PRIVATE_SHARED_H_
diff --git a/ppapi/tests/test_udp_socket_private_shared.cc b/ppapi/tests/test_udp_socket_private_shared.cc
new file mode 100644
index 0000000..73c7523
--- /dev/null
+++ b/ppapi/tests/test_udp_socket_private_shared.cc
@@ -0,0 +1,182 @@
+// Copyright (c) 2011 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_utils.h"
+#include "ppapi/tests/testing_instance.h"
+
+REGISTER_TEST_CASE(UDPSocketPrivateShared);
+
+// TODO(ygorshenin): get rid of using external server in tests,
+// http://crbug.com/105863
+const char* const TestUDPSocketPrivateShared::kHost = "www.google.com";
+
+TestUDPSocketPrivateShared::TestUDPSocketPrivateShared(
+    TestingInstance* instance)
+    : TestCase(instance),
+      tcp_socket_private_interface_(NULL),
+      udp_socket_private_interface_(NULL) {
+}
+
+bool TestUDPSocketPrivateShared::Init() {
+  tcp_socket_private_interface_ =
+      reinterpret_cast<PPB_TCPSocket_Private const*>(
+          pp::Module::Get()->GetBrowserInterface(
+              PPB_TCPSOCKET_PRIVATE_INTERFACE));
+  if (!tcp_socket_private_interface_)
+    instance_->AppendError("TCPSocketPrivate interface not available");
+
+  udp_socket_private_interface_ =
+      reinterpret_cast<PPB_UDPSocket_Private const*>(
+          pp::Module::Get()->GetBrowserInterface(
+              PPB_UDPSOCKET_PRIVATE_INTERFACE));
+  if (!udp_socket_private_interface_)
+    instance_->AppendError("UDPSocketPrivate interface not available");
+
+  return tcp_socket_private_interface_ && udp_socket_private_interface_ &&
+      InitTestingInterface();
+}
+
+void TestUDPSocketPrivateShared::RunTests(const std::string& filter) {
+  RUN_TEST(Create, filter);
+  RUN_TEST_FORCEASYNC_AND_NOT(Connect, filter);
+}
+
+void TestUDPSocketPrivateShared::QuitMessageLoop() {
+  testing_interface_->QuitMessageLoop(instance_->pp_instance());
+}
+
+std::string TestUDPSocketPrivateShared::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, kHost, kPort,
+      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(
+    const 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);
+
+  PASS();
+}
+
+std::string TestUDPSocketPrivateShared::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() {
+  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;
+
+  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());
+  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());
+  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();
+  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();
+  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);
+
+  PASS();
+}
diff --git a/ppapi/tests/test_udp_socket_private_shared.h b/ppapi/tests/test_udp_socket_private_shared.h
new file mode 100644
index 0000000..8104d01
--- /dev/null
+++ b/ppapi/tests/test_udp_socket_private_shared.h
@@ -0,0 +1,42 @@
+// Copyright (c) 2011 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.
+
+#ifndef PPAPI_TESTS_TEST_UDP_SOCKET_PRIVATE_SHARED_H_
+#define PPAPI_TESTS_TEST_UDP_SOCKET_PRIVATE_SHARED_H_
+
+#include "ppapi/cpp/private/tcp_socket_private.h"
+#include "ppapi/cpp/private/udp_socket_private.h"
+#include "ppapi/tests/test_case.h"
+
+class TestUDPSocketPrivateShared : public TestCase {
+ public:
+  explicit TestUDPSocketPrivateShared(TestingInstance* instance);
+
+  // TestCase implementation.
+  virtual bool Init();
+  virtual void RunTests(const std::string& filter);
+
+  void QuitMessageLoop();
+
+ private:
+  static const char* const kHost;
+  static const int kPort = 80;
+
+  // 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(const PP_NetAddress_Private *address,
+                                     PP_Resource *socket);
+
+  std::string TestCreate();
+  std::string TestConnect();
+
+  const PPB_TCPSocket_Private* tcp_socket_private_interface_;
+  const PPB_UDPSocket_Private* udp_socket_private_interface_;
+};
+
+#endif  // PPAPI_TESTS_TEST_UDP_SOCKET_PRIVATE_SHARED_H_