AllowBroadcast() is exposed to NaCl.

ppapi/proxy/ppb_udp_socket_private_proxy.cc

 // Copyright (c) 2012 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/proxy/ppb_udp_socket_private_proxy.h"
 
 #include <map>
 
 #include "base/logging.h"
+#include "ppapi/c/private/ppb_udp_socket_private.h"
 #include "ppapi/proxy/plugin_dispatcher.h"
 #include "ppapi/proxy/plugin_globals.h"
 #include "ppapi/proxy/plugin_proxy_delegate.h"
 #include "ppapi/proxy/plugin_resource_tracker.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/shared_impl/private/udp_socket_private_impl.h"
 #include "ppapi/shared_impl/resource.h"
 #include "ppapi/thunk/thunk.h"
 
 namespace ppapi {
 namespace proxy {
 
 namespace {
 
 typedef std::map<uint32, UDPSocketPrivateImpl*> IDToSocketMap;
 IDToSocketMap* g_id_to_socket = NULL;
 
 class UDPSocket : public UDPSocketPrivateImpl {
  public:
   UDPSocket(const HostResource& resource, uint32 socket_id);
   virtual ~UDPSocket();
 
+  virtual void SendSetSocketFeature(PP_UDPSocketFeature_Private name,
+                                    PP_Var value) OVERRIDE;
   virtual void SendBind(const PP_NetAddress_Private& addr) OVERRIDE;
   virtual void SendRecvFrom(int32_t num_bytes) OVERRIDE;
   virtual void SendSendTo(const std::string& data,
                           const PP_NetAddress_Private& addr) OVERRIDE;
   virtual void SendClose() OVERRIDE;
 
  private:
   void SendToBrowser(IPC::Message* msg);
 
   DISALLOW_COPY_AND_ASSIGN(UDPSocket);
 };
 
 UDPSocket::UDPSocket(const HostResource& resource, uint32 socket_id)
     : UDPSocketPrivateImpl(resource, socket_id) {
   if (!g_id_to_socket)
     g_id_to_socket = new IDToSocketMap();
   DCHECK(g_id_to_socket->find(socket_id) == g_id_to_socket->end());
   (*g_id_to_socket)[socket_id] = this;
 }
 
 UDPSocket::~UDPSocket() {
   Close();
 }
 
+void UDPSocket::SendSetSocketFeature(PP_UDPSocketFeature_Private name,
+                                     PP_Var value) {
+  switch (name) {
+    case PP_UDPSOCKETFEATURE_ADDRESS_REUSE:
+    case PP_UDPSOCKETFEATURE_BROADCAST:
+      DCHECK_EQ(PP_VARTYPE_BOOL, value.type);
+      SendToBrowser(new PpapiHostMsg_PPBUDPSocket_SetBoolSocketFeature(
+          API_ID_PPB_UDPSOCKET_PRIVATE, socket_id_,
+          name, (value.value.as_bool == PP_TRUE)));

[brettw, 2012/08/20 04:34:45]

You can use PP_ToBool. Actually, I'd probably just send a SerializedVar in the
IPC message. You can grep for examples. Then you don't need to do the checking
and extraction here (since you need to do it in the _impl side anyway).

[ygorshenin1, 2012/08/20 12:08:01]

Done.

Yes, I considered this way. It's possible to send SerializedVarSendInput for
out-of-process plugins, but I don't know how to send it from in-process plugins.
And in any case I need checking and extraction code.

On 2012/08/20 04:34:45, brettw wrote:

[brettw, 2012/08/20 17:55:15]

The implementation of in process plugins and the proxy are independent. You
should be able to switch the IPC message to use a serialized var and just change
the functions in this proxy file to use the serialized var stuff, and not change
anything else (unless I'm misunderstanding something).

[ygorshenin1, 2012/08/21 12:00:27]

As was decided in the discussion, PpapiHostMsg_PPBUDPSocket_Set{T}SocketFeature
messages should be used.

On 2012/08/20 17:55:15, brettw wrote:

+      break;
+    default:
+      NOTREACHED();
+  }
+}
+
 void UDPSocket::SendBind(const PP_NetAddress_Private& addr) {
   SendToBrowser(new PpapiHostMsg_PPBUDPSocket_Bind(
       API_ID_PPB_UDPSOCKET_PRIVATE, socket_id_, addr));
 }
 
 void UDPSocket::SendRecvFrom(int32_t num_bytes) {
   SendToBrowser(new PpapiHostMsg_PPBUDPSocket_RecvFrom(socket_id_, num_bytes));
 }
 
 void UDPSocket::SendSendTo(const std::string& data,
@@ skipping 39 matching lines @@
   if (socket_id == 0)
     return 0;
 
   return (new UDPSocket(HostResource::MakeInstanceOnly(instance),
                         socket_id))->GetReference();
 }
 
 bool PPB_UDPSocket_Private_Proxy::OnMessageReceived(const IPC::Message& msg) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(PPB_UDPSocket_Private_Proxy, msg)
+    IPC_MESSAGE_HANDLER(PpapiMsg_PPBUDPSocket_SetSocketFeatureACK,
+                        OnMsgSetSocketFeatureACK)
     IPC_MESSAGE_HANDLER(PpapiMsg_PPBUDPSocket_BindACK,
                         OnMsgBindACK)
     IPC_MESSAGE_HANDLER(PpapiMsg_PPBUDPSocket_RecvFromACK,
                         OnMsgRecvFromACK)
     IPC_MESSAGE_HANDLER(PpapiMsg_PPBUDPSocket_SendToACK,
                         OnMsgSendToACK)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
+void PPB_UDPSocket_Private_Proxy::OnMsgSetSocketFeatureACK(
+    uint32 /* plugin_dispatcher_id */,
+    uint32 socket_id,
+    bool succeeded) {
+  if (!g_id_to_socket) {
+    NOTREACHED();
+    return;
+  }
+  IDToSocketMap::iterator iter = g_id_to_socket->find(socket_id);
+  if (iter == g_id_to_socket->end())
+    return;
+  iter->second->OnSetSocketFeatureCompleted(succeeded);
+}
+
 void PPB_UDPSocket_Private_Proxy::OnMsgBindACK(
     uint32 /* plugin_dispatcher_id */,
     uint32 socket_id,
     bool succeeded,
     const PP_NetAddress_Private& bound_addr) {
   if (!g_id_to_socket) {
     NOTREACHED();
     return;
   }
   IDToSocketMap::iterator iter = g_id_to_socket->find(socket_id);
@@ skipping 28 matching lines @@
     return;
   }
   IDToSocketMap::iterator iter = g_id_to_socket->find(socket_id);
   if (iter == g_id_to_socket->end())
     return;
   iter->second->OnSendToCompleted(succeeded, bytes_written);
 }
 
 }  // namespace proxy
 }  // namespace ppapi