Pepper: Add support for multicast in PPB_UDPSocket API

ppapi/proxy/udp_socket_resource_base.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 "ppapi/proxy/udp_socket_resource_base.h"
 
 #include <algorithm>
 #include <cstring>
 
 #include "base/logging.h"
@@ skipping 50 matching lines @@
 }
 
 int32_t UDPSocketResourceBase::SetOptionImpl(
     PP_UDPSocket_Option name,
     const PP_Var& value,
     bool check_bind_state,
     scoped_refptr<TrackedCallback> callback) {
   if (closed_)
     return PP_ERROR_FAILED;
 
-  SocketOptionData option_data;
+  // 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: {
-      if ((check_bind_state || name == PP_UDPSOCKET_OPTION_ADDRESS_REUSE) &&
-          bind_called_) {
+      check_bind_state = true; // fallthrough
+    case PP_UDPSOCKET_OPTION_BROADCAST:
+    case PP_UDPSOCKET_OPTION_MULTICAST_LOOP:
+    case PP_UDPSOCKET_OPTION_MULTICAST_TTL: {
+      if (check_bind_state && bind_called_) {
         // SetOption should fail in this case in order to give predictable
         // behavior while binding. Note that we use |bind_called_| rather
         // than |bound_| since the latter is only set on successful completion
         // of Bind().
         return PP_ERROR_FAILED;
       }
+      break;
+    }
+    case PP_UDPSOCKET_OPTION_SEND_BUFFER_SIZE:
+    case PP_UDPSOCKET_OPTION_RECV_BUFFER_SIZE: {
+      if (check_bind_state && !bound_)
+        return PP_ERROR_FAILED;
+      break;
+    }
+  }
+
+  SocketOptionData option_data;
+  switch (name) {
+    case PP_UDPSOCKET_OPTION_ADDRESS_REUSE:
+    case PP_UDPSOCKET_OPTION_BROADCAST:
+    case PP_UDPSOCKET_OPTION_MULTICAST_LOOP: {
       if (value.type != PP_VARTYPE_BOOL)
         return PP_ERROR_BADARGUMENT;
       option_data.SetBool(PP_ToBool(value.value.as_bool));
       break;
     }
     case PP_UDPSOCKET_OPTION_SEND_BUFFER_SIZE:
     case PP_UDPSOCKET_OPTION_RECV_BUFFER_SIZE: {
-      if (check_bind_state && !bound_)
-        return PP_ERROR_FAILED;
       if (value.type != PP_VARTYPE_INT32)
         return PP_ERROR_BADARGUMENT;
       option_data.SetInt32(value.value.as_int);
       break;
     }
+    case PP_UDPSOCKET_OPTION_MULTICAST_TTL: {
+      int32_t ival = value.value.as_int;
+      if (value.type != PP_VARTYPE_INT32 && (ival < 0 || ival > 255))
+        return PP_ERROR_BADARGUMENT;
+      option_data.SetInt32(ival);
+      break;
+    }
     default: {
       NOTREACHED();
       return PP_ERROR_BADARGUMENT;
     }
   }
 
   Call<PpapiPluginMsg_UDPSocket_SetOptionReply>(
       BROWSER,
       PpapiHostMsg_UDPSocket_SetOption(name, option_data),
-      base::Bind(&UDPSocketResourceBase::OnPluginMsgSetOptionReply,
+      base::Bind(&UDPSocketResourceBase::OnPluginMsgGeneralReply,
                  base::Unretained(this),
                  callback),
       callback);
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t UDPSocketResourceBase::BindImpl(
     const PP_NetAddress_Private* addr,
     scoped_refptr<TrackedCallback> callback) {
   if (!addr)
@@ skipping 32 matching lines @@
     scoped_refptr<TrackedCallback> callback) {
   if (!buffer || num_bytes <= 0)
     return PP_ERROR_BADARGUMENT;
   if (!bound_)
     return PP_ERROR_FAILED;
   if (TrackedCallback::IsPending(recvfrom_callback_))
     return PP_ERROR_INPROGRESS;
 
   if (recv_buffers_.empty()) {
     read_buffer_ = buffer;
-    bytes_to_read_ = std::min(num_bytes, kMaxReadSize);
-    recvfrom_addr_resource_ = addr;

[bbudge, 2015/02/17 15:46:57]

Why did these get removed?

[etrunko, 2015/02/19 12:47:55]

For sure it was by mistake, will fix it.

     recvfrom_callback_ = callback;
 
     return PP_OK_COMPLETIONPENDING;
   } else {
     RecvBuffer& front = recv_buffers_.front();
 
     if (num_bytes < static_cast<int32_t>(front.data.size()))
       return PP_ERROR_MESSAGE_TOO_BIG;
 
     int32_t result = SetRecvFromOutput(front.result, front.data, front.addr,
@@ skipping 55 matching lines @@
   while (!sendto_callbacks_.empty()) {
     scoped_refptr<TrackedCallback> callback = sendto_callbacks_.front();
     sendto_callbacks_.pop();
     PostAbortIfNecessary(&callback);
   }
 
   read_buffer_ = NULL;
   bytes_to_read_ = -1;
 }
 
+int32_t UDPSocketResourceBase::JoinGroupImpl(
+    const PP_NetAddress_Private *group,
+    scoped_refptr<TrackedCallback> callback) {
+  DCHECK(group);
+
+  Call<PpapiPluginMsg_UDPSocket_JoinGroupReply>(
+      BROWSER,
+      PpapiHostMsg_UDPSocket_JoinGroup(*group),
+      base::Bind(&UDPSocketResourceBase::OnPluginMsgGeneralReply,
+                 base::Unretained(this),
+                 callback),
+      callback);
+  return PP_OK_COMPLETIONPENDING;
+}
+
+int32_t UDPSocketResourceBase::LeaveGroupImpl(
+    const PP_NetAddress_Private *group,
+    scoped_refptr<TrackedCallback> callback) {
+  DCHECK(group);
+
+  Call<PpapiPluginMsg_UDPSocket_LeaveGroupReply>(
+      BROWSER,
+      PpapiHostMsg_UDPSocket_LeaveGroup(*group),
+      base::Bind(&UDPSocketResourceBase::OnPluginMsgGeneralReply,
+                 base::Unretained(this),
+                 callback),
+      callback);
+  return PP_OK_COMPLETIONPENDING;
+}
+
 void UDPSocketResourceBase::OnReplyReceived(
     const ResourceMessageReplyParams& params,
     const IPC::Message& msg) {
   PPAPI_BEGIN_MESSAGE_MAP(UDPSocketResourceBase, msg)
     PPAPI_DISPATCH_PLUGIN_RESOURCE_CALL(
         PpapiPluginMsg_UDPSocket_PushRecvResult,
         OnPluginMsgPushRecvResult)
     PPAPI_DISPATCH_PLUGIN_RESOURCE_CALL_UNHANDLED(
         PluginResource::OnReplyReceived(params, msg))
   PPAPI_END_MESSAGE_MAP()
 }
 
 void UDPSocketResourceBase::PostAbortIfNecessary(
     scoped_refptr<TrackedCallback>* callback) {
   if (TrackedCallback::IsPending(*callback))
     (*callback)->PostAbort();
 }
 
-void UDPSocketResourceBase::OnPluginMsgSetOptionReply(
+void UDPSocketResourceBase::OnPluginMsgGeneralReply(
     scoped_refptr<TrackedCallback> callback,
     const ResourceMessageReplyParams& params) {
   if (TrackedCallback::IsPending(callback))
     RunCallback(callback, params.result());
 }
 
 void UDPSocketResourceBase::OnPluginMsgBindReply(
     const ResourceMessageReplyParams& params,
     const PP_NetAddress_Private& bound_addr) {
   // It is possible that |bind_callback_| is pending while |closed_| is true:
@@ skipping 100 matching lines @@
   if (result == PP_OK && !data.empty())
     memcpy(output_buffer, data.c_str(), data.size());
 
   recvfrom_addr_ = addr;
 
   return result == PP_OK ? static_cast<int32_t>(data.size()) : result;
 }
 
 }  // namespace proxy
 }  // namespace ppapi