Pepper: Allow plugins to call PPB_UDP_Socket::SendTo multiple times.

ppapi/tests/test_udp_socket.cc

 // Copyright 2013 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_udp_socket.h"
 
 #include <vector>
 
 #include "ppapi/cpp/pass_ref.h"
 #include "ppapi/cpp/tcp_socket.h"
@@ skipping 65 matching lines @@
       net_address_is_available &&
       init_address &&
       CheckTestingInterface() &&
       EnsureRunningOverHTTP();
 }
 
 void TestUDPSocket::RunTests(const std::string& filter) {
   RUN_CALLBACK_TEST(TestUDPSocket, ReadWrite, filter);
   RUN_CALLBACK_TEST(TestUDPSocket, Broadcast, filter);
   RUN_CALLBACK_TEST(TestUDPSocket, SetOption, filter);
+  RUN_CALLBACK_TEST(TestUDPSocket, ParallelSend, filter);
 }
 
 std::string TestUDPSocket::GetLocalAddress(pp::NetAddress* address) {
   pp::TCPSocket socket(instance_);
   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
   callback.WaitForResult(socket.Connect(address_, callback.GetCallback()));
   CHECK_CALLBACK_BEHAVIOR(callback);
   ASSERT_EQ(PP_OK, callback.result());
   *address = socket.GetLocalAddress();
   ASSERT_NE(0, address->pp_resource());
@@ skipping 213 matching lines @@
   ASSERT_EQ(PP_OK, callback.result());
 
   callback.WaitForResult(socket.SetOption(
       PP_UDPSOCKET_OPTION_RECV_BUFFER_SIZE, pp::Var(1024),
       callback.GetCallback()));
   CHECK_CALLBACK_BEHAVIOR(callback);
   ASSERT_EQ(PP_OK, callback.result());
 
   PASS();
 }
+
+std::string TestUDPSocket::TestParallelSend() {
+  // This test only makes sense when callbacks are optional.
+  if (callback_type() == PP_OPTIONAL) {

[dmichael (off chromium), 2014/10/08 17:20:46]

Maybe it would be cleaner to do:
if (callback_type() != PP_OPTIONAL)
  PASS();

[bbudge, 2014/10/08 21:44:35]

Done.

+    pp::UDPSocket server_socket(instance_), client_socket(instance_);
+    pp::NetAddress server_address, client_address;
+
+    ASSERT_SUBTEST_SUCCESS(
+        LookupPortAndBindUDPSocket(&server_socket, &server_address));
+    ASSERT_SUBTEST_SUCCESS(
+        LookupPortAndBindUDPSocket(&client_socket, &client_address));
+    const std::string message = "Simple message that will be sent via UDP";
+    pp::NetAddress recvfrom_address;
+
+    const size_t kParallelSends = 10;
+    std::vector<TestCompletionCallback*> sendto_callbacks(kParallelSends);
+    std::vector<int32_t> sendto_results(kParallelSends);
+    size_t pending = 0;
+    for (size_t i = 0; i < kParallelSends; i++) {
+      sendto_callbacks[i] =
+          new TestCompletionCallback(instance_->pp_instance(), callback_type());
+      sendto_results[i] =
+          client_socket.SendTo(message.c_str(),
+                               message.size(),
+                               server_address,
+                               sendto_callbacks[i]->GetCallback());
+
+      while (sendto_results[i] == PP_ERROR_INPROGRESS) {
+        // Run pending sends to completion until we can send successfully.
+        ASSERT_GT(i, pending);
+        sendto_callbacks[pending]->WaitForResult(sendto_results[pending]);
+        CHECK_CALLBACK_BEHAVIOR(*sendto_callbacks[pending]);
+        ASSERT_EQ(message.size(),
+                  static_cast<size_t>(sendto_callbacks[pending]->result()));
+        pending++;
+        // Try to send the message again.
+        sendto_results[i] =
+            client_socket.SendTo(message.c_str(),
+                                 message.size(),
+                                 server_address,
+                                 sendto_callbacks[i]->GetCallback());

[dmichael (off chromium), 2014/10/08 17:20:46]

At this point, I don't think sendto_results[i] should ever be
PP_ERROR_INPROGRESS, right?

Maybe it would make sense to tighten the test slightly by making the while an
if, and asserting that sendto_results != PP_ERROR_INPROGRESS?

[bbudge, 2014/10/08 21:44:35]

OK, I think it's probably good to constrain this behavior since we're making
plugin code to rate limit more complex. We will explicitly guarantee that a slot
opens up when another SendTo completes. Perhaps I should update the IDL too.

+      }
+    }
+
+    // Finish all pending sends.
+    for (size_t i = pending; i < kParallelSends; i++) {
+      sendto_callbacks[i]->WaitForResult(sendto_results[i]);
+      CHECK_CALLBACK_BEHAVIOR(*sendto_callbacks[i]);
+      ASSERT_EQ(message.size(),
+                static_cast<size_t>(sendto_callbacks[i]->result()));
+    }
+
+    for (size_t i = 0; i < kParallelSends; ++i)
+      delete sendto_callbacks[i];
+
+    for (size_t i = 0; i < kParallelSends; i++) {
+      std::string str;
+      ASSERT_SUBTEST_SUCCESS(
+          ReadSocket(&server_socket, &recvfrom_address, message.size(), &str));
+      ASSERT_EQ(message, str);
+    }
+
+    server_socket.Close();
+    client_socket.Close();
+  }
+
+  PASS();
+}