Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(562)

Side by Side Diff: ppapi/tests/test_udp_socket_private_shared.cc

Issue 8804006: Reland 8688002: PPB_TCPSocket_Private/PPB_UDPSocket_Private are exposed to Browser (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: fix destruction issue Created 9 years ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
« no previous file with comments | « ppapi/tests/test_udp_socket_private_shared.h ('k') | ppapi/thunk/ppb_tcp_socket_private_api.h » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
(Empty)
1 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include <string.h>
6
7 #include "ppapi/cpp/module.h"
8 #include "ppapi/tests/test_udp_socket_private_shared.h"
9 #include "ppapi/tests/test_utils.h"
10 #include "ppapi/tests/testing_instance.h"
11
12 REGISTER_TEST_CASE(UDPSocketPrivateShared);
13
14 // TODO(ygorshenin): get rid of using external server in tests,
15 // http://crbug.com/105863
16 const char* const TestUDPSocketPrivateShared::kHost = "www.google.com";
17
18 TestUDPSocketPrivateShared::TestUDPSocketPrivateShared(
19 TestingInstance* instance)
20 : TestCase(instance),
21 tcp_socket_private_interface_(NULL),
22 udp_socket_private_interface_(NULL) {
23 }
24
25 bool TestUDPSocketPrivateShared::Init() {
26 tcp_socket_private_interface_ =
27 reinterpret_cast<PPB_TCPSocket_Private const*>(
28 pp::Module::Get()->GetBrowserInterface(
29 PPB_TCPSOCKET_PRIVATE_INTERFACE));
30 if (!tcp_socket_private_interface_)
31 instance_->AppendError("TCPSocketPrivate interface not available");
32
33 udp_socket_private_interface_ =
34 reinterpret_cast<PPB_UDPSocket_Private const*>(
35 pp::Module::Get()->GetBrowserInterface(
36 PPB_UDPSOCKET_PRIVATE_INTERFACE));
37 if (!udp_socket_private_interface_)
38 instance_->AppendError("UDPSocketPrivate interface not available");
39
40 return tcp_socket_private_interface_ && udp_socket_private_interface_ &&
41 InitTestingInterface();
42 }
43
44 void TestUDPSocketPrivateShared::RunTests(const std::string& filter) {
45 RUN_TEST(Create, filter);
46 RUN_TEST_FORCEASYNC_AND_NOT(Connect, filter);
47 }
48
49 void TestUDPSocketPrivateShared::QuitMessageLoop() {
50 testing_interface_->QuitMessageLoop(instance_->pp_instance());
51 }
52
53 std::string TestUDPSocketPrivateShared::GenerateNetAddress(
54 PP_Resource* socket, PP_NetAddress_Private* address) {
55 *socket = tcp_socket_private_interface_->Create(instance_->pp_instance());
56 if (0 == *socket)
57 return "PPB_TCPSocket_Private::Create failed";
58
59 TestCompletionCallback callback(instance_->pp_instance(), force_async_);
60 int32_t rv = tcp_socket_private_interface_->Connect(
61 *socket, kHost, kPort,
62 static_cast<pp::CompletionCallback>(callback).pp_completion_callback());
63 if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
64 return ReportError("PPB_TCPSocket_Private::Connect force_async", rv);
65 if (rv == PP_OK_COMPLETIONPENDING)
66 rv = callback.WaitForResult();
67 if (rv != PP_OK)
68 return ReportError("PPB_TCPSocket_Private::Connect", rv);
69
70 rv = tcp_socket_private_interface_->GetLocalAddress(*socket, address);
71 if (rv != PP_TRUE)
72 return ReportError("PPB_TCPSocket_Private::GetLocalAddress", rv);
73
74 PASS();
75 }
76
77 std::string TestUDPSocketPrivateShared::CreateAndBindUDPSocket(
78 const PP_NetAddress_Private *address,
79 PP_Resource *socket) {
80 *socket = udp_socket_private_interface_->Create(instance_->pp_instance());
81 if (0 == *socket)
82 return "PPB_UDPSocket_Private::Create failed";
83 if (!udp_socket_private_interface_->IsUDPSocket(*socket))
84 return "PPB_UDPSocket_Private::IsUDPSocket failed";
85
86 TestCompletionCallback callback(instance_->pp_instance(), force_async_);
87 int32_t rv = udp_socket_private_interface_->Bind(
88 *socket, address,
89 static_cast<pp::CompletionCallback>(callback).pp_completion_callback());
90
91 if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
92 return ReportError("PPB_UDPSocket_Private::Bind force_async", rv);
93 if (rv == PP_OK_COMPLETIONPENDING)
94 rv = callback.WaitForResult();
95 if (rv != PP_OK)
96 return ReportError("PPB_UDPSocket_Private::Bind", rv);
97
98 PASS();
99 }
100
101 std::string TestUDPSocketPrivateShared::TestCreate() {
102 PP_Resource udp_socket;
103 std::string error_message;
104
105 udp_socket = udp_socket_private_interface_->Create(0);
106 if (0 != udp_socket)
107 return "PPB_UDPSocket_Private::Create returns valid socket " \
108 "for invalid instance";
109
110 udp_socket = udp_socket_private_interface_->Create(instance_->pp_instance());
111 if (0 == udp_socket)
112 return "PPB_UDPSocket_Private::Create failed";
113 if (!udp_socket_private_interface_->IsUDPSocket(udp_socket))
114 return "PPB_UDPSocket_Private::IsUDPSocket failed";
115
116 PASS();
117 }
118
119 std::string TestUDPSocketPrivateShared::TestConnect() {
120 PP_NetAddress_Private server_address, client_address;
121 PP_Resource tcp_socket_server, tcp_socket_client;
122 std::string error_message;
123
124 error_message = GenerateNetAddress(&tcp_socket_server, &server_address);
125 if (!error_message.empty())
126 return error_message;
127 error_message = GenerateNetAddress(&tcp_socket_client, &client_address);
128 if (error_message.empty())
129 return error_message;
130
131 PP_Resource socket_server, socket_client;
132 error_message = CreateAndBindUDPSocket(&server_address, &socket_server);
133 if (error_message.empty())
134 return error_message;
135 error_message = CreateAndBindUDPSocket(&client_address, &socket_client);
136 if (error_message.empty())
137 return error_message;
138
139 static const char* const kMessage =
140 "Simple message that will be sent via UDP";
141 static const size_t kMessageBufferSize = 1024;
142 char message_buffer[kMessageBufferSize];
143
144 TestCompletionCallback write_cb(instance_->pp_instance(), force_async_);
145 int32_t write_rv = udp_socket_private_interface_->SendTo(
146 socket_client,
147 kMessage,
148 strlen(kMessage),
149 &server_address,
150 static_cast<pp::CompletionCallback>(write_cb).pp_completion_callback());
151 if (force_async_ && write_rv != PP_OK_COMPLETIONPENDING)
152 return ReportError("PPB_UDPSocket_Private::SendTo force_async", write_rv);
153
154 TestCompletionCallback read_cb(instance_->pp_instance(), force_async_);
155 int32_t read_rv = udp_socket_private_interface_->RecvFrom(
156 socket_server,
157 message_buffer,
158 strlen(kMessage),
159 static_cast<pp::CompletionCallback>(read_cb).pp_completion_callback());
160 if (force_async_ && read_rv != PP_OK_COMPLETIONPENDING)
161 return ReportError("PPB_UDPSocket_Private::RecvFrom force_async", read_rv);
162
163 if (read_rv == PP_OK_COMPLETIONPENDING)
164 read_rv = read_cb.WaitForResult();
165 if (read_rv < 0 || strlen(kMessage) != static_cast<size_t>(read_rv))
166 return ReportError("PPB_UDPSocket_Private::RecvFrom", read_rv);
167
168 if (write_rv == PP_OK_COMPLETIONPENDING)
169 write_rv = write_cb.WaitForResult();
170 if (write_rv < 0 || strlen(kMessage) != static_cast<size_t>(write_rv))
171 return ReportError("PPB_UDPSocket_Private::SendTo", write_rv);
172
173 ASSERT_EQ(0, strncmp(kMessage, message_buffer, strlen(kMessage)));
174
175 udp_socket_private_interface_->Close(socket_server);
176 udp_socket_private_interface_->Close(socket_client);
177
178 tcp_socket_private_interface_->Disconnect(tcp_socket_server);
179 tcp_socket_private_interface_->Disconnect(tcp_socket_client);
180
181 PASS();
182 }
OLDNEW
« no previous file with comments | « ppapi/tests/test_udp_socket_private_shared.h ('k') | ppapi/thunk/ppb_tcp_socket_private_api.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698