PPB_TCPSocket_Private/PPB_UDPSocket_Private are exposed to Browser

ppapi/native_client/tests/ppapi_browser/ppb_udp_socket_private/ppapi_ppb_udp_socket_private.cc

Index: ppapi/native_client/tests/ppapi_browser/ppb_udp_socket_private/ppapi_ppb_udp_socket_private.cc
diff --git a/ppapi/native_client/tests/ppapi_browser/ppb_udp_socket_private/ppapi_ppb_udp_socket_private.cc b/ppapi/native_client/tests/ppapi_browser/ppb_udp_socket_private/ppapi_ppb_udp_socket_private.cc
new file mode 100644
index 0000000000000000000000000000000000000000..1fe57cd3867f80d787172ca20b6730bac948a42e
--- /dev/null
+++ b/ppapi/native_client/tests/ppapi_browser/ppb_udp_socket_private/ppapi_ppb_udp_socket_private.cc
@@ -0,0 +1,119 @@
+// 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 <string>
+
+#include "native_client/src/include/nacl_macros.h"
+#include "native_client/src/shared/platform/nacl_check.h"
+#include "native_client/tests/ppapi_test_lib/get_browser_interface.h"
+#include "native_client/tests/ppapi_test_lib/test_interface.h"
+#include "native_client/tests/ppapi_test_lib/testable_callback.h"
+#include "ppapi/c/pp_errors.h"
+#include "ppapi/c/private/ppb_tcp_socket_private.h"
+#include "ppapi/c/private/ppb_udp_socket_private.h"
+
+namespace {
+
+void GenerateNetAddress(PP_NetAddress_Private *address) {

[Dmitry Polukhin, 2011/11/24 13:05:45]

Please add comment why it works and don't close socket until you generate both
UDP sockets.

[ygorshenin, 2011/11/24 13:40:34]

Done.

+  static const char* const kServerHost = "www.google.com";
+  static const int kServerPort = 80;
+
+  PP_Resource tcp_socket = PPBTCPSocketPrivate()->Create(pp_instance());
+  EXPECT(tcp_socket != kInvalidResource);
+
+  TestableCallback callback(pp_instance(), true);
+  callback.Reset();
+  EXPECT(PP_OK_COMPLETIONPENDING ==
+         PPBTCPSocketPrivate()->Connect(tcp_socket, kServerHost, kServerPort,
+                                        callback.GetCallback()));
+  EXPECT(PP_OK == callback.WaitForResult());
+  EXPECT(PP_TRUE ==
+         PPBTCPSocketPrivate()->GetLocalAddress(tcp_socket, address));
+  PPBTCPSocketPrivate()->Disconnect(tcp_socket);
+}
+
+void CreateAndBindUDPSocket(const PP_NetAddress_Private *address,
+                            PP_Resource *socket) {
+  *socket = PPBUDPSocketPrivate()->Create(pp_instance());
+  EXPECT(*socket != kInvalidResource);
+  EXPECT(PPBUDPSocketPrivate()->IsUDPSocket(*socket));
+
+  TestableCallback callback(pp_instance(), true);
+  callback.Reset();
+  EXPECT(PP_OK_COMPLETIONPENDING ==
+         PPBUDPSocketPrivate()->Bind(*socket, address, callback.GetCallback()));
+  EXPECT(PP_OK == callback.WaitForResult());
+}
+
+void TestCreate() {
+  PP_Resource udp_socket;
+
+  udp_socket = PPBUDPSocketPrivate()->Create(kInvalidInstance);
+  EXPECT(udp_socket == kInvalidResource);
+  udp_socket = PPBUDPSocketPrivate()->Create(pp_instance());
+  EXPECT(udp_socket != kInvalidResource);
+  EXPECT(PPBUDPSocketPrivate()->IsUDPSocket(udp_socket));
+
+  TEST_PASSED;
+}
+
+void TestConnect() {
+  PP_NetAddress_Private server_address, client_address;
+  GenerateNetAddress(&server_address);
+  GenerateNetAddress(&client_address);
+
+  PP_Resource socket_server, socket_client;
+  CreateAndBindUDPSocket(&server_address, &socket_server);
+  CreateAndBindUDPSocket(&client_address, &socket_client);
+
+  static const char* const kMessage =
+      "Simple message that will be sent via UDP";
+  static const size_t kMessageBufferSize = 1024;
+  char message_buffer[kMessageBufferSize];
+
+  TestableCallback write_callback(pp_instance(), true);
+  write_callback.Reset();
+  int32_t write_rv = PPBUDPSocketPrivate()->SendTo(
+      socket_client,
+      kMessage,
+      strlen(kMessage),
+      &server_address,
+      write_callback.GetCallback());
+  EXPECT(PP_OK_COMPLETIONPENDING == write_rv);
+
+  TestableCallback read_callback(pp_instance(), true);
+  read_callback.Reset();
+  int32_t read_rv = PPBUDPSocketPrivate()->RecvFrom(
+      socket_server,
+      message_buffer,
+      strlen(kMessage),
+      read_callback.GetCallback());
+  EXPECT(PP_OK_COMPLETIONPENDING == read_rv);
+
+  read_rv = read_callback.WaitForResult();
+  EXPECT(0 <= read_rv);
+  EXPECT(strlen(kMessage) == static_cast<size_t>(read_rv));
+  write_rv = write_callback.WaitForResult();
+  EXPECT(0 <= write_rv);
+  EXPECT(strlen(kMessage) == static_cast<size_t>(write_rv));
+
+  EXPECT(0 == strncmp(kMessage, message_buffer, strlen(kMessage)));
+
+  PPBUDPSocketPrivate()->Close(socket_server);
+  PPBUDPSocketPrivate()->Close(socket_client);
+
+  TEST_PASSED;
+}
+
+}  // namespace
+
+void SetupTests() {
+  RegisterTest("TestCreate", TestCreate);
+  RegisterTest("TestConnect", TestConnect);
+}
+
+void SetupPluginInterfaces() {
+  // none
+}