AllowBroadcast() is exposed to NaCl.

content/browser/renderer_host/pepper/pepper_udp_socket.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 "content/browser/renderer_host/pepper/pepper_udp_socket.h"
 
 #include <string.h>
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "content/browser/renderer_host/pepper/pepper_message_filter.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/udp/udp_server_socket.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/shared_impl/private/net_address_private_impl.h"
 
 using content::BrowserThread;
 using ppapi::NetAddressPrivateImpl;
 
 PepperUDPSocket::PepperUDPSocket(
     PepperMessageFilter* manager,
     int32 routing_id,
     uint32 plugin_dispatcher_id,
     uint32 socket_id)
     : manager_(manager),
       routing_id_(routing_id),
       plugin_dispatcher_id_(plugin_dispatcher_id),
-      socket_id_(socket_id) {
+      socket_id_(socket_id),
+      allow_address_reuse_(false),
+      allow_broadcast_(false) {
   DCHECK(manager);
 }
 
 PepperUDPSocket::~PepperUDPSocket() {
   // Make sure there are no further callbacks from socket_.
   if (socket_.get())
     socket_->Close();
 }
 
+void PepperUDPSocket::AllowAddressReuse(bool value) {
+  allow_address_reuse_ = value;
+  SendSetSocketFeatureACK(true);
+}
+
+void PepperUDPSocket::AllowBroadcast(bool value) {
+  allow_broadcast_ = value;
+  SendSetSocketFeatureACK(true);
+}
+
 void PepperUDPSocket::Bind(const PP_NetAddress_Private& addr) {
   socket_.reset(new net::UDPServerSocket(NULL, net::NetLog::Source()));
 
   net::IPEndPoint address;
   if (!socket_.get() ||
       !NetAddressPrivateImpl::NetAddressToIPEndPoint(addr, &address)) {
     SendBindACKError();
     return;
   }
 
+  if (allow_address_reuse_)
+    socket_->AllowAddressReuse();
+  if (allow_broadcast_)
+    socket_->AllowBroadcast();
+
   int result = socket_->Listen(address);
 
   if (result == net::OK &&
       socket_->GetLocalAddress(&bound_address_) != net::OK) {
     SendBindACKError();
     return;
   }
 
   OnBindCompleted(result);
 }
@@ skipping 32 matching lines @@
   sendto_buffer_ = new net::IOBuffer(data_size);
   memcpy(sendto_buffer_->data(), data.data(), data_size);
   int result = socket_->SendTo(
       sendto_buffer_, data_size, address,
       base::Bind(&PepperUDPSocket::OnSendToCompleted, base::Unretained(this)));
 
   if (result != net::ERR_IO_PENDING)
     OnSendToCompleted(result);
 }
 
+void PepperUDPSocket::SendSetSocketFeatureACK(bool succeeded) {
+  manager_->Send(new PpapiMsg_PPBUDPSocket_SetSocketFeatureACK(
+      routing_id_, plugin_dispatcher_id_, socket_id_, succeeded));
+}
+
 void PepperUDPSocket::SendRecvFromACKError() {
   PP_NetAddress_Private addr = NetAddressPrivateImpl::kInvalidNetAddress;
   manager_->Send(new PpapiMsg_PPBUDPSocket_RecvFromACK(
       routing_id_, plugin_dispatcher_id_, socket_id_, false, std::string(),
       addr));
 }
 
 void PepperUDPSocket::SendSendToACKError() {
   manager_->Send(new PpapiMsg_PPBUDPSocket_SendToACK(
       routing_id_, plugin_dispatcher_id_, socket_id_, false, 0));
@@ skipping 41 matching lines @@
 
   if (result < 0) {
     SendSendToACKError();
   } else {
     manager_->Send(new PpapiMsg_PPBUDPSocket_SendToACK(
         routing_id_, plugin_dispatcher_id_, socket_id_, true, result));
   }
 
   sendto_buffer_ = NULL;
 }