Pepper: Add support for multicast in PPB_UDPSocket API

ppapi/tests/test_udp_socket.cc

Index: ppapi/tests/test_udp_socket.cc
diff --git a/ppapi/tests/test_udp_socket.cc b/ppapi/tests/test_udp_socket.cc
index 2b0568244e30001b37e5670f41a4799e733e7af6..395abe0c5d1b5b97668c5f1a365adfd51f53de0b 100644
--- a/ppapi/tests/test_udp_socket.cc
+++ b/ppapi/tests/test_udp_socket.cc
@@ -47,7 +47,10 @@ pp::NetAddress ReplacePort(const pp::InstanceHandle& instance,
 
 }  // namespace
 
-TestUDPSocket::TestUDPSocket(TestingInstance* instance) : TestCase(instance) {
+TestUDPSocket::TestUDPSocket(TestingInstance* instance)
+    : TestCase(instance),
+      socket_interface_1_0_(NULL),
+      socket_interface_1_1_(NULL) {
 }
 
 bool TestUDPSocket::Init() {
@@ -71,19 +74,36 @@ bool TestUDPSocket::Init() {
   if (!init_address)
     instance_->AppendError("Can't init address");
 
+  socket_interface_1_0_ =
+      static_cast<const PPB_UDPSocket_1_0*>(
+          pp::Module::Get()->GetBrowserInterface(PPB_UDPSOCKET_INTERFACE_1_0));
+  if (!socket_interface_1_0_)
+    instance_->AppendError("PPB_UDPSocket_1_0 interface not available");
+
+  socket_interface_1_1_ =
+      static_cast<const PPB_UDPSocket_1_1*>(
+          pp::Module::Get()->GetBrowserInterface(PPB_UDPSOCKET_INTERFACE_1_1));
+  if (!socket_interface_1_1_)
+    instance_->AppendError("PPB_UDPSocket_1_1 interface not available");
+
   return tcp_socket_is_available &&
       udp_socket_is_available &&
       net_address_is_available &&
       init_address &&
       CheckTestingInterface() &&
-      EnsureRunningOverHTTP();
+      EnsureRunningOverHTTP() &&
+      socket_interface_1_0_ != NULL &&
+      socket_interface_1_1_ != NULL;
 }
 
 void TestUDPSocket::RunTests(const std::string& filter) {
   RUN_CALLBACK_TEST(TestUDPSocket, ReadWrite, filter);
   RUN_CALLBACK_TEST(TestUDPSocket, Broadcast, filter);
+  RUN_CALLBACK_TEST(TestUDPSocket, SetOption_1_0, filter);
+  RUN_CALLBACK_TEST(TestUDPSocket, SetOption_1_1, 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) {
@@ -186,6 +206,23 @@ std::string TestUDPSocket::PassMessage(pp::UDPSocket* target,
   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());
+
+  PASS();
+}
+
 std::string TestUDPSocket::TestReadWrite() {
   pp::UDPSocket server_socket(instance_), client_socket(instance_);
   pp::NetAddress server_address, client_address;
@@ -256,10 +293,43 @@ std::string TestUDPSocket::TestBroadcast() {
   PASS();
 }
 
+std::string TestUDPSocket::TestSetOption_1_0() {
+  PP_Resource socket = socket_interface_1_0_->Create(instance_->pp_instance());
+  ASSERT_NE(0, socket);
+
+  // Multicast options are not supported in interface 1.0.
+  struct PP_Var value = PP_MakeBool(true);
+  TestCompletionCallback cb(instance_->pp_instance(), callback_type());
+  cb.WaitForResult(socket_interface_1_0_->SetOption(socket,
+      PP_UDPSOCKET_OPTION_MULTICAST_LOOP, value,
+      cb.GetCallback().pp_completion_callback()));
+  CHECK_CALLBACK_BEHAVIOR(cb);
+  ASSERT_EQ(PP_ERROR_BADARGUMENT, cb.result());
+
+  PASS();
+}
+
+std::string TestUDPSocket::TestSetOption_1_1() {
+  PP_Resource socket = socket_interface_1_1_->Create(instance_->pp_instance());
+  ASSERT_NE(0, socket);
+
+  // Multicast options are not supported in interface 1.1.
+  struct PP_Var value = PP_MakeBool(true);
+  TestCompletionCallback cb(instance_->pp_instance(), callback_type());
+  cb.WaitForResult(socket_interface_1_1_->SetOption(socket,
+      PP_UDPSOCKET_OPTION_MULTICAST_LOOP, value,
+      cb.GetCallback().pp_completion_callback()));
+  CHECK_CALLBACK_BEHAVIOR(cb);
+  ASSERT_EQ(PP_ERROR_BADARGUMENT, cb.result());
+
+  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());
@@ -268,6 +338,17 @@ std::string TestUDPSocket::TestSetOption() {
   CHECK_CALLBACK_BEHAVIOR(callback);
   ASSERT_EQ(PP_ERROR_BADARGUMENT, callback.result());
 
+  // Invalid multicast TTL values (less than 0 and greater than 255).
+  callback.WaitForResult(socket->SetOption(
+      PP_UDPSOCKET_OPTION_MULTICAST_TTL, pp::Var(-1), callback.GetCallback()));
+  CHECK_CALLBACK_BEHAVIOR(callback);
+  ASSERT_EQ(PP_ERROR_BADARGUMENT, callback.result());
+
+  callback.WaitForResult(socket->SetOption(
+      PP_UDPSOCKET_OPTION_MULTICAST_TTL, pp::Var(256), 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()));
   CHECK_CALLBACK_BEHAVIOR(callback);
@@ -383,6 +464,12 @@ std::string TestUDPSocket::TestParallelSend() {
 
   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();
 }