Pepper: Add support for multicast in PPB_UDPSocket API

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 66 matching lines @@
       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);
+  RUN_CALLBACK_TEST(TestUDPSocket, Multicast, 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 82 matching lines @@
                                     &str));
 
   callback.WaitForResult(rv);
   CHECK_CALLBACK_BEHAVIOR(callback);
   ASSERT_FALSE(callback.result() < 0);
   ASSERT_EQ(message.size(), static_cast<size_t>(callback.result()));
   ASSERT_EQ(message, str);
   PASS();
 }
 
+std::string TestUDPSocket::SetMulticastOptions(pp::UDPSocket* socket) {
+  TestCompletionCallback callback_1(instance_->pp_instance(), callback_type());
+  callback_1.WaitForResult(socket->SetOption(
+      PP_UDPSOCKET_OPTION_MULTICAST_LOOP, pp::Var(true),
+      callback_1.GetCallback()));
+  CHECK_CALLBACK_BEHAVIOR(callback_1);
+  ASSERT_EQ(PP_OK, callback_1.result());
+
+  TestCompletionCallback callback_2(instance_->pp_instance(), callback_type());
+  callback_2.WaitForResult(socket->SetOption(
+      PP_UDPSOCKET_OPTION_MULTICAST_TTL, pp::Var(1), callback_2.GetCallback()));
+  CHECK_CALLBACK_BEHAVIOR(callback_2);
+  ASSERT_EQ(PP_OK, callback_2.result());
+

[bbudge, 2015/02/13 00:03:16]

You should verify invalid types and values fail, e.g. TTL < 0 or > 255.

It might be nice to test that prior versions can't use these. That's harder
though - you'd have to get the C interface for those versions and use that
rather than the nicer C++ wrappers.

[etrunko, 2015/02/13 20:19:58]

Thankfully, TCP_Socket has similar test for different interface versions that I
based on.

Done.

+  PASS();
+}
+
 std::string TestUDPSocket::TestReadWrite() {
   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;
@@ skipping 54 matching lines @@
 
   server1.Close();
   server2.Close();
   PASS();
 }
 
 std::string TestUDPSocket::TestSetOption() {
   pp::UDPSocket socket(instance_);
 
   ASSERT_SUBTEST_SUCCESS(SetBroadcastOptions(&socket));
+  ASSERT_SUBTEST_SUCCESS(SetMulticastOptions(&socket));
 
   // Try to pass incorrect option value's type.
   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
   callback.WaitForResult(socket.SetOption(
       PP_UDPSOCKET_OPTION_ADDRESS_REUSE, pp::Var(1), callback.GetCallback()));
   CHECK_CALLBACK_BEHAVIOR(callback);
   ASSERT_EQ(PP_ERROR_BADARGUMENT, callback.result());
 
   callback.WaitForResult(socket.SetOption(
       PP_UDPSOCKET_OPTION_BROADCAST, pp::Var(false), callback.GetCallback()));
@@ skipping 103 matching lines @@
 
   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();
+}
 
+std::string TestUDPSocket::TestMulticast() {
+  pp::UDPSocket server1(instance_), server2(instance_);
+
+  ASSERT_SUBTEST_SUCCESS(SetMulticastOptions(&server1));
+  ASSERT_SUBTEST_SUCCESS(SetMulticastOptions(&server2));
   PASS();
 }