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"
 #include "content/browser/renderer_host/pepper/browser_ppapi_host_impl.h"
 #include "content/browser/renderer_host/pepper/pepper_socket_utils.h"
 #include "content/public/browser/browser_thread.h"
+#include "content/public/browser/content_browser_client.h"
 #include "content/public/common/process_type.h"
 #include "content/public/common/socket_permission_request.h"
 #include "ipc/ipc_message_macros.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/base/rand_callback.h"
 #include "net/udp/udp_socket.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/private/ppb_net_address_private.h"
 #include "ppapi/host/dispatch_host_message.h"
@@ skipping 29 matching lines @@
 PepperUDPSocketMessageFilter::PendingSend::~PendingSend() {
 }
 
 PepperUDPSocketMessageFilter::PepperUDPSocketMessageFilter(
     BrowserPpapiHostImpl* host,
     PP_Instance instance,
     bool private_api)
     : socket_options_(0),
       rcvbuf_size_(0),
       sndbuf_size_(0),
+      multicast_ttl_(0),
+      can_use_multicast_(PP_ERROR_FAILED),
       closed_(false),
       remaining_recv_slots_(UDPSocketResourceBase::kPluginReceiveBufferSlots),
       external_plugin_(host->external_plugin()),
       private_api_(private_api),
       render_process_id_(0),
       render_frame_id_(0) {
   ++g_num_instances;
   DCHECK(host);
 
   if (!host->GetRenderFrameIDsForInstance(
@@ skipping 15 matching lines @@
 scoped_refptr<base::TaskRunner>
 PepperUDPSocketMessageFilter::OverrideTaskRunnerForMessage(
     const IPC::Message& message) {
   switch (message.type()) {
     case PpapiHostMsg_UDPSocket_SetOption::ID:
     case PpapiHostMsg_UDPSocket_Close::ID:
     case PpapiHostMsg_UDPSocket_RecvSlotAvailable::ID:
       return BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO);
     case PpapiHostMsg_UDPSocket_Bind::ID:
     case PpapiHostMsg_UDPSocket_SendTo::ID:
+    case PpapiHostMsg_UDPSocket_JoinGroup::ID:
+    case PpapiHostMsg_UDPSocket_LeaveGroup::ID:
       return BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI);
   }
   return NULL;
 }
 
 int32_t PepperUDPSocketMessageFilter::OnResourceMessageReceived(
     const IPC::Message& msg,
     ppapi::host::HostMessageContext* context) {
   PPAPI_BEGIN_MESSAGE_MAP(PepperUDPSocketMessageFilter, msg)
     PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_UDPSocket_SetOption,
                                       OnMsgSetOption)
     PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_UDPSocket_Bind, OnMsgBind)
     PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_UDPSocket_SendTo,
                                       OnMsgSendTo)
     PPAPI_DISPATCH_HOST_RESOURCE_CALL_0(PpapiHostMsg_UDPSocket_Close,
                                         OnMsgClose)
     PPAPI_DISPATCH_HOST_RESOURCE_CALL_0(
         PpapiHostMsg_UDPSocket_RecvSlotAvailable, OnMsgRecvSlotAvailable)
+    PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_UDPSocket_JoinGroup,
+                                      OnMsgJoinGroup)
+    PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_UDPSocket_LeaveGroup,
+                                      OnMsgLeaveGroup)
   PPAPI_END_MESSAGE_MAP()
   return PP_ERROR_FAILED;
 }
 
 int32_t PepperUDPSocketMessageFilter::OnMsgSetOption(
     const ppapi::host::HostMessageContext* context,
     PP_UDPSocket_Option name,
     const ppapi::SocketOptionData& value) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
@@ skipping 18 matching lines @@
       } else {
         socket_options_ &= ~SOCKET_OPTION_ADDRESS_REUSE;
       }
       return PP_OK;
     }
     case PP_UDPSOCKET_OPTION_BROADCAST: {
       bool boolean_value = false;
       if (!value.GetBool(&boolean_value))
         return PP_ERROR_BADARGUMENT;
 
-      // If the socket is already connected, proxy the value to TCPSocket.
+      // If the socket is already bound, proxy the value to UDPSocket.
       if (socket_.get())
         return NetErrorToPepperError(socket_->SetBroadcast(boolean_value));
 
       // UDPSocket instance is not yet created, so remember the value here.
       if (boolean_value) {
         socket_options_ |= SOCKET_OPTION_BROADCAST;
       } else {
         socket_options_ &= ~SOCKET_OPTION_BROADCAST;
       }
       return PP_OK;
     }
     case PP_UDPSOCKET_OPTION_SEND_BUFFER_SIZE: {
       int32_t integer_value = 0;
       if (!value.GetInt32(&integer_value) ||
           integer_value <= 0 ||
           integer_value >
               ppapi::proxy::UDPSocketResourceBase::kMaxSendBufferSize)
         return PP_ERROR_BADARGUMENT;
 
-      // If the socket is already connected, proxy the value to UDPSocket.
+      // If the socket is already bound, proxy the value to UDPSocket.
       if (socket_.get()) {
         return NetErrorToPepperError(
             socket_->SetSendBufferSize(integer_value));
       }
 
       // UDPSocket instance is not yet created, so remember the value here.
       socket_options_ |= SOCKET_OPTION_SNDBUF_SIZE;
       sndbuf_size_ = integer_value;
       return PP_OK;
     }
     case PP_UDPSOCKET_OPTION_RECV_BUFFER_SIZE: {
       int32_t integer_value = 0;
       if (!value.GetInt32(&integer_value) ||
           integer_value <= 0 ||
           integer_value >
               ppapi::proxy::UDPSocketResourceBase::kMaxReceiveBufferSize)
         return PP_ERROR_BADARGUMENT;
 
-      // If the socket is already connected, proxy the value to UDPSocket.
+      // If the socket is already bound, proxy the value to UDPSocket.
       if (socket_.get()) {
         return NetErrorToPepperError(
             socket_->SetReceiveBufferSize(integer_value));
       }
 
       // UDPSocket instance is not yet created, so remember the value here.
       socket_options_ |= SOCKET_OPTION_RCVBUF_SIZE;
       rcvbuf_size_ = integer_value;
       return PP_OK;
     }
+    case PP_UDPSOCKET_OPTION_MULTICAST_LOOP: {
+      bool boolean_value = false;
+      if (!value.GetBool(&boolean_value))
+        return PP_ERROR_BADARGUMENT;
+
+      // If the socket is already bound, proxy the value to UDPSocket.
+      if (socket_) {
+        if (can_use_multicast_ != PP_OK)
+          return can_use_multicast_;
+
+        return NetErrorToPepperError(
+            socket_->SetMulticastLoopbackMode(boolean_value));
+      }
+
+      // UDPSocket instance is not yet created, so remember the value here.
+      if (boolean_value) {
+        socket_options_ |= SOCKET_OPTION_MULTICAST_LOOP;
+      } else {
+        socket_options_ &= ~SOCKET_OPTION_MULTICAST_LOOP;
+      }
+      return PP_OK;
+    }
+    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;
+
+      // If the socket is already bound, proxy the value to UDPSocket.
+      if (socket_) {
+        if (can_use_multicast_ != PP_OK)
+          return can_use_multicast_;
+
+        return NetErrorToPepperError(
+            socket_->SetMulticastTimeToLive(integer_value));
+      }
+
+      // UDPSocket instance is not yet created, so remember the value here.
+      socket_options_ |= SOCKET_OPTION_MULTICAST_TTL;
+      multicast_ttl_ = integer_value;
+      return PP_OK;
+    }
     default: {
       NOTREACHED();
       return PP_ERROR_BADARGUMENT;
     }
   }
 }
 
 int32_t PepperUDPSocketMessageFilter::OnMsgBind(
     const ppapi::host::HostMessageContext* context,
     const PP_NetAddress_Private& addr) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(context);
 
+  // Check for permissions to use multicast APIS. This check must be done while
+  // on the UI thread, so we cache the value here to be used later on.
+  PP_NetAddress_Private any_addr;
+  NetAddressPrivateImpl::GetAnyAddress(PP_FALSE, &any_addr);
+  can_use_multicast_ = CanUseMulticastAPI(any_addr);
+
   SocketPermissionRequest request =
       pepper_socket_utils::CreateSocketPermissionRequest(
           SocketPermissionRequest::UDP_BIND, addr);
   if (!pepper_socket_utils::CanUseSocketAPIs(external_plugin_,
                                              private_api_,
                                              &request,
                                              render_process_id_,
                                              render_frame_id_)) {
     return PP_ERROR_NOACCESS;
   }
@@ skipping 52 matching lines @@
   }
 
   if (!recvfrom_buffer_.get() && !closed_ && socket_.get()) {
     DCHECK_EQ(1u, remaining_recv_slots_);
     DoRecvFrom();
   }
 
   return PP_OK;
 }
 
+int32_t PepperUDPSocketMessageFilter::OnMsgJoinGroup(
+    const ppapi::host::HostMessageContext* context,
+    const PP_NetAddress_Private& addr) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
+  int32_t ret = CanUseMulticastAPI(addr);
+  if (ret != PP_OK)
+    return ret;
+
+  if (!socket_)
+    return PP_ERROR_FAILED;
+
+  net::IPAddressNumber group;
+  uint16 port;
+
+  if (!NetAddressPrivateImpl::NetAddressToIPEndPoint(addr, &group, &port))
+    return PP_ERROR_ADDRESS_INVALID;
+
+  return NetErrorToPepperError(socket_->JoinGroup(group));
+}
+
+int32_t PepperUDPSocketMessageFilter::OnMsgLeaveGroup(
+    const ppapi::host::HostMessageContext* context,
+    const PP_NetAddress_Private& addr) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
+  int32_t ret = CanUseMulticastAPI(addr);
+  if (ret != PP_OK)
+    return ret;
+
+  if (!socket_)
+    return PP_ERROR_FAILED;
+
+  net::IPAddressNumber group;
+  uint16 port;
+
+  if (!NetAddressPrivateImpl::NetAddressToIPEndPoint(addr, &group, &port))
+    return PP_ERROR_ADDRESS_INVALID;
+
+  return NetErrorToPepperError(socket_->LeaveGroup(group));
+}
+
 void PepperUDPSocketMessageFilter::DoBind(
     const ppapi::host::ReplyMessageContext& context,
     const PP_NetAddress_Private& addr) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (closed_ || socket_.get()) {
     SendBindError(context, PP_ERROR_FAILED);
     return;
   }
 
@@ skipping 37 matching lines @@
       return;
     }
   }
   if (socket_options_ & SOCKET_OPTION_RCVBUF_SIZE) {
     int net_result = socket->SetReceiveBufferSize(rcvbuf_size_);
     if (net_result != net::OK) {
       SendBindError(context, NetErrorToPepperError(net_result));
       return;
     }
   }
+  if (socket_options_ & SOCKET_OPTION_MULTICAST_LOOP) {
+    if (can_use_multicast_ != PP_OK) {
+      SendBindError(context, NetErrorToPepperError(can_use_multicast_));
+      return;
+    }
+
+    int net_result = socket->SetMulticastLoopbackMode(true);
+    if (net_result != net::OK) {
+      SendBindError(context, NetErrorToPepperError(net_result));
+      return;
+    }
+  }
+  if (socket_options_ & SOCKET_OPTION_MULTICAST_TTL) {
+    if (can_use_multicast_ != PP_OK) {
+      SendBindError(context, NetErrorToPepperError(can_use_multicast_));
+      return;
+    }
+
+    int net_result = socket->SetMulticastTimeToLive(multicast_ttl_);
+    if (net_result != net::OK) {
+      SendBindError(context, NetErrorToPepperError(net_result));
+      return;
+    }
+  }
 
   {
     int net_result = socket->Bind(end_point);
     if (net_result != net::OK) {
       SendBindError(context, NetErrorToPepperError(net_result));
       return;
     }
   }
 
   net::IPEndPoint bound_address;
@@ skipping 207 matching lines @@
   SendRecvFromResult(result, std::string(),
                      NetAddressPrivateImpl::kInvalidNetAddress);
 }
 
 void PepperUDPSocketMessageFilter::SendSendToError(
     const ppapi::host::ReplyMessageContext& context,
     int32_t result) {
   SendSendToReply(context, result, 0);
 }
 
+int32_t PepperUDPSocketMessageFilter::CanUseMulticastAPI(
+    const PP_NetAddress_Private& addr) {
+  // Check for Dev API.
+  // TODO(etrunko): remove check when Multicast API reaches beta/stable.
+  // https://crbug.com/464452
+  ContentBrowserClient* content_browser_client = GetContentClient()->browser();
+  if (!content_browser_client->IsPluginAllowedToUseDevChannelAPIs(nullptr,
+                                                                  GURL())) {
+    return PP_ERROR_NOTSUPPORTED;
+  }
+
+  // Check for plugin permissions.
+  SocketPermissionRequest request =
+      pepper_socket_utils::CreateSocketPermissionRequest(
+          SocketPermissionRequest::UDP_MULTICAST_MEMBERSHIP, addr);
+  if (!pepper_socket_utils::CanUseSocketAPIs(external_plugin_,
+                                             private_api_,
+                                             &request,
+                                             render_process_id_,
+                                             render_frame_id_)) {
+    return PP_ERROR_NOACCESS;
+  }
+
+  return PP_OK;
+}
+
 }  // namespace content