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),
       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: {
+      PP_NetAddress_Private any_addr;
+      NetAddressPrivateImpl::GetAnyAddress(PP_FALSE, &any_addr);
+      int32_t ret = CanUseMulticastAPI(any_addr);

[etrunko, 2015/03/09 22:33:45]

One last question, there CanUseSocketAPIs
(content/browser/renderer_host/pepper/pepper_socket_utils.cc) checks for UI
thread, but in this case we are in IO thread, do we need to keep this check
here?

[bbudge, 2015/03/09 22:51:03]

Missed that, no, you shouldn't call this on the wrong thread though it probably
works, except in Debug builds where it will assert.

Instead, check CanUseSocketAPIs in Bind, which is run on the UI thread. Cache
the result and then check that before setting the options here (and below) on
socket_. If the socket_ isn't bound, just save the option values for later.

[etrunko, 2015/03/09 23:35:04]

Done.

+      if (ret != PP_OK)
+        return ret;
+
+      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_)
+        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: {
+      PP_NetAddress_Private any_addr;
+      NetAddressPrivateImpl::GetAnyAddress(PP_FALSE, &any_addr);
+      int32_t ret = CanUseMulticastAPI(any_addr);
+      if (ret != PP_OK)
+        return ret;
+
+      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_)
+        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) {
@@ skipping 65 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) {
+    int net_result = socket->SetMulticastLoopbackMode(true);
+    if (net_result != net::OK) {
+      SendBindError(context, NetErrorToPepperError(net_result));
+      return;
+    }
+  }
+  if (socket_options_ & SOCKET_OPTION_MULTICAST_TTL) {
+    int net_result = socket->SetMulticastInterface(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(NULL,

[dcheng, 2015/03/09 21:14:33]

nullptr

[etrunko, 2015/03/09 22:18:10]

Done.

+                                                                  GURL())) {
+    return PP_ERROR_FAILED;
+  }
+
+  // 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