Pepper: Add support for multicast in PPB_UDPSocket API

content/browser/renderer_host/pepper/pepper_udp_socket_message_filter.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 "content/browser/renderer_host/pepper/pepper_udp_socket_message_filter.h"
 
 #include <cstring>
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
@@ skipping 10 matching lines @@
 #include "ppapi/c/private/ppb_net_address_private.h"
 #include "ppapi/host/dispatch_host_message.h"
 #include "ppapi/host/error_conversion.h"
 #include "ppapi/host/host_message_context.h"
 #include "ppapi/host/ppapi_host.h"
 #include "ppapi/host/resource_host.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/proxy/udp_socket_resource_base.h"
 #include "ppapi/shared_impl/private/net_address_private_impl.h"
 #include "ppapi/shared_impl/socket_option_data.h"
+#include "ppapi/thunk/enter.h"
+#include "ppapi/thunk/ppb_net_address_api.h"
 
 using ppapi::NetAddressPrivateImpl;
 using ppapi::host::NetErrorToPepperError;
+using ppapi::thunk::EnterResource;
+using ppapi::thunk::PPB_NetAddress_API;
 
 namespace {
 
 size_t g_num_instances = 0;
 
 }  // namespace
 
 namespace content {
 
 PepperUDPSocketMessageFilter::PepperUDPSocketMessageFilter(
     BrowserPpapiHostImpl* host,
     PP_Instance instance,
     bool private_api)
     : allow_address_reuse_(false),
       allow_broadcast_(false),
+      multicast_loop_(false),
+      multicast_interface_(0),
+      multicast_time_to_live_(0),
       closed_(false),
       remaining_recv_slots_(
           ppapi::proxy::UDPSocketResourceBase::kPluginReceiveBufferSlots),
       external_plugin_(host->external_plugin()),
       private_api_(private_api),
       render_process_id_(0),
       render_frame_id_(0) {
   ++g_num_instances;
   DCHECK(host);
 
@@ skipping 47 matching lines @@
 
 int32_t PepperUDPSocketMessageFilter::OnMsgSetOption(
     const ppapi::host::HostMessageContext* context,
     PP_UDPSocket_Option name,
     const ppapi::SocketOptionData& value) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (closed_)
     return PP_ERROR_FAILED;
 
+  // Check if socket is expected to be bound or not according to the option
   switch (name) {
     case PP_UDPSOCKET_OPTION_ADDRESS_REUSE:
-    case PP_UDPSOCKET_OPTION_BROADCAST: {
+    case PP_UDPSOCKET_OPTION_BROADCAST:
+    case PP_UDPSOCKET_OPTION_MULTICAST_LOOP:
+    case PP_UDPSOCKET_OPTION_MULTICAST_TTL:
+    case PP_UDPSOCKET_OPTION_MULTICAST_IF: {
       if (socket_.get()) {
         // They only take effect before the socket is bound.
         return PP_ERROR_FAILED;
       }
+      break;
+    }
+    case PP_UDPSOCKET_OPTION_SEND_BUFFER_SIZE:
+    case PP_UDPSOCKET_OPTION_RECV_BUFFER_SIZE:
+    case PP_UDPSOCKET_OPTION_MULTICAST_JOIN:
+    case PP_UDPSOCKET_OPTION_MULTICAST_LEAVE: {
+      if (!socket_.get()) {
+        // They only take effect after the socket is bound.
+        return PP_ERROR_FAILED;
+      }
+      break;
+    }
+  }
 
+  switch (name) {
+    case PP_UDPSOCKET_OPTION_ADDRESS_REUSE:
+    case PP_UDPSOCKET_OPTION_BROADCAST:
+    case PP_UDPSOCKET_OPTION_MULTICAST_LOOP: {
       bool boolean_value = false;
       if (!value.GetBool(&boolean_value))
         return PP_ERROR_BADARGUMENT;
 
       if (name == PP_UDPSOCKET_OPTION_ADDRESS_REUSE)
         allow_address_reuse_ = boolean_value;
-      else
+      else if (name == PP_UDPSOCKET_OPTION_BROADCAST)
         allow_broadcast_ = boolean_value;
+      else if (name == PP_UDPSOCKET_OPTION_MULTICAST_LOOP)
+        multicast_loop_ = boolean_value;
       return PP_OK;
     }
     case PP_UDPSOCKET_OPTION_SEND_BUFFER_SIZE:
-    case PP_UDPSOCKET_OPTION_RECV_BUFFER_SIZE: {
-      if (!socket_.get()) {
-        // They only take effect after the socket is bound.
-        return PP_ERROR_FAILED;
-      }
+    case PP_UDPSOCKET_OPTION_RECV_BUFFER_SIZE:
+    case PP_UDPSOCKET_OPTION_MULTICAST_IF: {
       int32_t integer_value = 0;
       if (!value.GetInt32(&integer_value) || integer_value <= 0)
         return PP_ERROR_BADARGUMENT;
 
+      if (name == PP_UDPSOCKET_OPTION_MULTICAST_IF) {
+        multicast_interface_ = integer_value;
+        return PP_OK;
+      }
+
       int net_result = net::ERR_UNEXPECTED;
       if (name == PP_UDPSOCKET_OPTION_SEND_BUFFER_SIZE) {
         if (integer_value >
             ppapi::proxy::UDPSocketResourceBase::kMaxSendBufferSize) {
           return PP_ERROR_BADARGUMENT;
         }
         net_result = socket_->SetSendBufferSize(integer_value);
       } else {
         if (integer_value >
             ppapi::proxy::UDPSocketResourceBase::kMaxReceiveBufferSize) {
           return PP_ERROR_BADARGUMENT;
         }
         net_result = socket_->SetReceiveBufferSize(integer_value);
       }
       // TODO(wtc): Add error mapping code.
       return (net_result == net::OK) ? PP_OK : PP_ERROR_FAILED;
     }
+    case PP_UDPSOCKET_OPTION_MULTICAST_TTL: {
+      int32_t integer_value = 0;
+      if (!value.GetInt32(&integer_value) ||
+          integer_value < 0 || integer_value > 255)
+        return PP_ERROR_BADARGUMENT;
+
+      multicast_time_to_live_ = integer_value;
+      return PP_OK;
+    }
+    case PP_UDPSOCKET_OPTION_MULTICAST_JOIN:
+    case PP_UDPSOCKET_OPTION_MULTICAST_LEAVE: {
+      PP_Resource resource = 0;
+      if (!value.GetInt32(&resource))
+        return PP_ERROR_BADARGUMENT;
+
+      EnterResource<PPB_NetAddress_API> net_address_api(resource, true);
+      if (net_address_api.failed())
+        return PP_ERROR_BADRESOURCE;
+
+      PP_NetAddress_Private addr;
+      PP_NetAddress_Family family = net_address_api.object()->GetFamily();
+      if (family == PP_NETADDRESS_FAMILY_IPV6) {
+        PP_NetAddress_IPv4 v4;
+        if (!net_address_api.object()->DescribeAsIPv4Address(&v4))
+          return PP_ERROR_ADDRESS_INVALID;
+        NetAddressPrivateImpl::CreateNetAddressPrivateFromIPv4Address(
+            v4, &addr);
+      }
+      else if (family == PP_NETADDRESS_FAMILY_IPV6) {

[ygorshenin1, 2014/11/14 08:03:43]

nit: joint lines #220 and #221.

[etrunko, 2014/11/17 17:45:10]

Done.

+        PP_NetAddress_IPv6 v6;
+        if (!net_address_api.object()->DescribeAsIPv6Address(&v6))
+          return PP_ERROR_ADDRESS_INVALID;
+        NetAddressPrivateImpl::CreateNetAddressPrivateFromIPv6Address(
+            v6, &addr);
+      }
+      else

[ygorshenin1, 2014/11/14 08:03:43]

nit: join lines #228 and #227 and wrap return statement into curly braces.

[etrunko, 2014/11/17 17:45:09]

Done.

+        return PP_ERROR_BADARGUMENT;
+
+      net::IPAddressNumber group;
+      int port;
+      if (!NetAddressPrivateImpl::NetAddressToIPEndPoint(addr, &group, &port))
+        return PP_ERROR_ADDRESS_INVALID;
+
+      int net_result = net::ERR_UNEXPECTED;
+      if (name == PP_UDPSOCKET_OPTION_MULTICAST_JOIN)
+        net_result = socket_->JoinGroup(group);
+      else if (name == PP_UDPSOCKET_OPTION_MULTICAST_LEAVE)
+        net_result = socket_->LeaveGroup(group);
+      return (net_result == net::OK) ? PP_OK : PP_ERROR_FAILED;
+    }
     default: {
       NOTREACHED();
       return PP_ERROR_BADARGUMENT;
     }
   }
 }
 
 int32_t PepperUDPSocketMessageFilter::OnMsgBind(
     const ppapi::host::HostMessageContext* context,
     const PP_NetAddress_Private& addr) {
@@ skipping 89 matching lines @@
   int port;
   if (!NetAddressPrivateImpl::NetAddressToIPEndPoint(addr, &address, &port)) {
     SendBindError(context, PP_ERROR_ADDRESS_INVALID);
     return;
   }
 
   if (allow_address_reuse_)
     socket->AllowAddressReuse();
   if (allow_broadcast_)
     socket->AllowBroadcast();
+  if (multicast_loop_)
+    socket->SetMulticastLoopbackMode(multicast_loop_);
+  if (multicast_interface_)
+    socket->SetMulticastInterface(multicast_interface_);
+  if (multicast_time_to_live_)
+    socket->SetMulticastTimeToLive(multicast_time_to_live_);
 
   int32_t pp_result =
       NetErrorToPepperError(socket->Listen(net::IPEndPoint(address, port)));
   if (pp_result != PP_OK) {
     SendBindError(context, pp_result);
     return;
   }
 
   net::IPEndPoint bound_address;
   pp_result = NetErrorToPepperError(socket->GetLocalAddress(&bound_address));
   if (pp_result != PP_OK) {
     SendBindError(context, pp_result);
     return;
   }
 
   PP_NetAddress_Private net_address = NetAddressPrivateImpl::kInvalidNetAddress;
   if (!NetAddressPrivateImpl::IPEndPointToNetAddress(
           bound_address.address(), bound_address.port(), &net_address)) {
     SendBindError(context, PP_ERROR_ADDRESS_INVALID);
     return;
   }
 
   allow_address_reuse_ = false;
   allow_broadcast_ = false;
+  multicast_loop_ = false;
+  multicast_interface_ = 0;
+  multicast_time_to_live_ = 0;
   socket_.swap(socket);
   SendBindReply(context, PP_OK, net_address);
 
   DoRecvFrom();
 }
 
 void PepperUDPSocketMessageFilter::DoRecvFrom() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(!closed_);
   DCHECK(socket_.get());
@@ skipping 161 matching lines @@
                      NetAddressPrivateImpl::kInvalidNetAddress);
 }
 
 void PepperUDPSocketMessageFilter::SendSendToError(
     const ppapi::host::ReplyMessageContext& context,
     int32_t result) {
   SendSendToReply(context, result, 0);
 }
 
 }  // namespace content