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 29 matching lines @@
     }
     default: {
       PP_NOTREACHED();
     }
   }
   return pp::NetAddress();
 }
 
 }  // namespace
 
-TestUDPSocket::TestUDPSocket(TestingInstance* instance) : TestCase(instance) {
+TestUDPSocket::TestUDPSocket(TestingInstance* instance)
+    : TestCase(instance),
+      socket_interface_1_0_(NULL),
+      socket_interface_1_1_(NULL),
+      has_interface_1_2_(false) {
 }
 
 bool TestUDPSocket::Init() {
   bool tcp_socket_is_available = pp::TCPSocket::IsAvailable();
   if (!tcp_socket_is_available)
     instance_->AppendError("PPB_TCPSocket interface not available");
 
   bool udp_socket_is_available = pp::UDPSocket::IsAvailable();
   if (!udp_socket_is_available)
     instance_->AppendError("PPB_UDPSocket interface not available");
 
   bool net_address_is_available = pp::NetAddress::IsAvailable();
   if (!net_address_is_available)
     instance_->AppendError("PPB_NetAddress interface not available");
 
   std::string host;
   uint16_t port = 0;
   bool init_address =
       GetLocalHostPort(instance_->pp_instance(), &host, &port) &&
       ResolveHost(instance_->pp_instance(), host, port, &address_);
   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");
+
+  const PPB_UDPSocket_1_2* iface_1_2 =
+      static_cast<const PPB_UDPSocket_1_2*>(
+          pp::Module::Get()->GetBrowserInterface(PPB_UDPSOCKET_INTERFACE_1_2));
+  has_interface_1_2_ = iface_1_2 != NULL;
+

[etrunko, 2015/02/23 22:22:15]

I did not find an easier way to check for specific versions of interfaces.

[bbudge, 2015/03/02 16:03:08]

This is fine. You don't need to test for 1.2 though, since this code will never
run against Chrome without the 1.2 api.

   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) {
   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 84 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) {
+  int32_t expected = has_interface_1_2_ ? PP_OK : PP_ERROR_BADARGUMENT;
+
+  TestCompletionCallback callback(instance_->pp_instance(), callback_type());
+  callback.WaitForResult(socket->SetOption(
+      PP_UDPSOCKET_OPTION_MULTICAST_LOOP, pp::Var(true),
+      callback.GetCallback()));
+  CHECK_CALLBACK_BEHAVIOR(callback);
+  ASSERT_EQ(expected, callback.result());
+
+  callback.WaitForResult(socket->SetOption(
+      PP_UDPSOCKET_OPTION_MULTICAST_TTL, pp::Var(1), callback.GetCallback()));
+  CHECK_CALLBACK_BEHAVIOR(callback);
+  ASSERT_EQ(expected, callback.result());
+
+  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 50 matching lines @@
   // |second_message| was also received by |server1|.
   ASSERT_SUBTEST_SUCCESS(ReadSocket(&server1, &recvfrom_address,
                                     second_message.size(), &message));
   ASSERT_EQ(second_message, message);
 
   server1.Close();
   server2.Close();
   PASS();
 }
 
+int32_t TestUDPSocket::SetOptionValue(UDPSocketSetOption func,
+                                      PP_Resource socket,
+                                      PP_UDPSocket_Option option,
+                                      struct PP_Var value) {
+  PP_TimeTicks start_time(NowInTimeTicks());
+  TestCompletionCallback cb(instance_->pp_instance(), callback_type());
+  cb.WaitForResult(func(socket, option, value,
+                        cb.GetCallback().pp_completion_callback()));
+
+  // Expanded from CHECK_CALLBACK_BEHAVIOR macro.
+  if (cb.failed()) {
+    std::string msg = MakeFailureMessage(__FILE__, __LINE__,
+                                         cb.errors().c_str());
+
+    instance_->LogTest("SetOptionValue", msg, start_time);
+    return PP_ERROR_FAILED;
+  }
+  return cb.result();
+}
+
+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.
+  ASSERT_EQ(PP_ERROR_BADARGUMENT,
+            SetOptionValue(socket_interface_1_0_->SetOption,
+                           socket,
+                           PP_UDPSOCKET_OPTION_MULTICAST_LOOP,
+                           PP_MakeBool(PP_FromBool(true))));
+
+  ASSERT_EQ(PP_ERROR_BADARGUMENT,
+            SetOptionValue(socket_interface_1_0_->SetOption,
+                           socket,
+                           PP_UDPSOCKET_OPTION_MULTICAST_TTL,
+                           PP_MakeInt32(1)));
+
+  socket_interface_1_0_->Close(socket);
+  pp::Module::Get()->core()->ReleaseResource(socket);
+
+  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.
+  ASSERT_EQ(PP_ERROR_BADARGUMENT,
+            SetOptionValue(socket_interface_1_1_->SetOption,
+                           socket,
+                           PP_UDPSOCKET_OPTION_MULTICAST_LOOP,
+                           PP_MakeBool(PP_FromBool(true))));
+
+  ASSERT_EQ(PP_ERROR_BADARGUMENT,
+            SetOptionValue(socket_interface_1_1_->SetOption,
+                           socket,
+                           PP_UDPSOCKET_OPTION_MULTICAST_TTL,
+                           PP_MakeInt32(1)));
+
+  socket_interface_1_1_->Close(socket);
+  pp::Module::Get()->core()->ReleaseResource(socket);
+
+  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());
 
+  // 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);
   ASSERT_EQ(PP_OK, callback.result());
 
   callback.WaitForResult(socket.SetOption(
       PP_UDPSOCKET_OPTION_SEND_BUFFER_SIZE, pp::Var(4096),
       callback.GetCallback()));
   CHECK_CALLBACK_BEHAVIOR(callback);
   ASSERT_EQ(PP_OK, callback.result());
@@ skipping 98 matching lines @@
     ASSERT_SUBTEST_SUCCESS(
         ReadSocket(&server_socket, &recvfrom_address, message.size(), &str));
     ASSERT_EQ(message, str);
   }
 
   server_socket.Close();
   client_socket.Close();
 
   PASS();
 }
+
+std::string TestUDPSocket::TestMulticast() {
+  pp::UDPSocket server1(instance_), server2(instance_);
+
+  ASSERT_SUBTEST_SUCCESS(SetMulticastOptions(&server1));
+  ASSERT_SUBTEST_SUCCESS(SetMulticastOptions(&server2));
+
+  server1.Close();
+  server2.Close();
+
+  if (!has_interface_1_2_)
+    PASS();

[etrunko, 2015/02/23 22:22:15]

Again, if there is a better way to check for interface versions, please advise.
All other tests are OK, this is the only one left. I'm working on it right now.

[bbudge, 2015/03/02 16:03:08]

You don't have to check for 1.2 (see comment above.)

+  PASS();
+}