ppapi/proxy/udp_socket_resource_base.h

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef PPAPI_PROXY_UDP_SOCKET_RESOURCE_BASE_H_
   6 #define PPAPI_PROXY_UDP_SOCKET_RESOURCE_BASE_H_
   7
   8 #include <queue>
   9 #include <string>
  10
  11 #include "base/basictypes.h"
  12 #include "base/compiler_specific.h"
  13 #include "base/memory/ref_counted.h"
  14 #include "ppapi/c/ppb_udp_socket.h"
  15 #include "ppapi/c/private/ppb_net_address_private.h"
  16 #include "ppapi/proxy/plugin_resource.h"
  17 #include "ppapi/proxy/ppapi_proxy_export.h"
  18 #include "ppapi/shared_impl/tracked_callback.h"
  19
  20 namespace ppapi {
  21 namespace proxy {
  22
  23 class ResourceMessageReplyParams;
  24
  25 class PPAPI_PROXY_EXPORT UDPSocketResourceBase: public PluginResource {
  26  public:
  27   // The maximum number of bytes that each
  28   // PpapiPluginMsg_PPBUDPSocket_PushRecvResult message is allowed to carry.
  29   static const int32_t kMaxReadSize;
  30   // The maximum number of bytes that each PpapiHostMsg_PPBUDPSocket_SendTo
  31   // message is allowed to carry.
  32   static const int32_t kMaxWriteSize;
  33
  34   // The maximum number that we allow for setting
  35   // PP_UDPSOCKET_OPTION_SEND_BUFFER_SIZE. This number is only for input
  36   // argument sanity check, it doesn't mean the browser guarantees to support
  37   // such a buffer size.
  38   static const int32_t kMaxSendBufferSize;
  39   // The maximum number that we allow for setting
  40   // PP_UDPSOCKET_OPTION_RECV_BUFFER_SIZE. This number is only for input
  41   // argument sanity check, it doesn't mean the browser guarantees to support
  42   // such a buffer size.
  43   static const int32_t kMaxReceiveBufferSize;
  44
  45   // The maximum number of received packets that we allow instances of this
  46   // class to buffer.
  47   static const size_t kPluginReceiveBufferSlots;
  48   // The maximum number of buffers that we allow instances of this class to be
  49   // sending before we block the plugin.
  50   static const size_t kPluginSendBufferSlots;
  51
  52  protected:
  53   UDPSocketResourceBase(Connection connection,
  54                         PP_Instance instance,
  55                         bool private_api);
  56   virtual ~UDPSocketResourceBase();
  57
  58   int32_t SetOptionImpl(PP_UDPSocket_Option name,
  59                         const PP_Var& value,
  60                         bool check_bind_state,
  61                         scoped_refptr<TrackedCallback> callback);
  62   int32_t BindImpl(const PP_NetAddress_Private* addr,
  63                    scoped_refptr<TrackedCallback> callback);
  64   PP_Bool GetBoundAddressImpl(PP_NetAddress_Private* addr);
  65   // |addr| could be NULL to indicate that an output value is not needed.
  66   int32_t RecvFromImpl(char* buffer,
  67                        int32_t num_bytes,
  68                        PP_Resource* addr,
  69                        scoped_refptr<TrackedCallback> callback);
  70   PP_Bool GetRecvFromAddressImpl(PP_NetAddress_Private* addr);
  71   int32_t SendToImpl(const char* buffer,
  72                      int32_t num_bytes,
  73                      const PP_NetAddress_Private* addr,
  74                      scoped_refptr<TrackedCallback> callback);
  75   void CloseImpl();
  76   int32_t JoinGroupImpl(const PP_NetAddress_Private *group,
  77                         scoped_refptr<TrackedCallback> callback);
  78   int32_t LeaveGroupImpl(const PP_NetAddress_Private *group,
  79                          scoped_refptr<TrackedCallback> callback);
  80
  81  private:
  82   struct RecvBuffer {
  83     int32_t result;
  84     std::string data;
  85     PP_NetAddress_Private addr;
  86   };
  87
  88   // Resource overrides.
  89   virtual void OnReplyReceived(const ResourceMessageReplyParams& params,
  90                                const IPC::Message& msg) override;
  91
  92   void PostAbortIfNecessary(scoped_refptr<TrackedCallback>* callback);
  93
  94   // IPC message handlers.
  95   void OnPluginMsgGeneralReply(scoped_refptr<TrackedCallback> callback,
  96                                const ResourceMessageReplyParams& params);
  97   void OnPluginMsgBindReply(const ResourceMessageReplyParams& params,
  98                             const PP_NetAddress_Private& bound_addr);
  99   void OnPluginMsgPushRecvResult(const ResourceMessageReplyParams& params,
 100                                  int32_t result,
 101                                  const std::string& data,
 102                                  const PP_NetAddress_Private& addr);
 103   void OnPluginMsgSendToReply(const ResourceMessageReplyParams& params,
 104                               int32_t bytes_written);
 105
 106   void RunCallback(scoped_refptr<TrackedCallback> callback, int32_t pp_result);
 107
 108   // Callers must ensure that |output_buffer| is big enough to store |data|.
 109   int32_t SetRecvFromOutput(int32_t browser_result,
 110                             const std::string& data,
 111                             const PP_NetAddress_Private& addr,
 112                             char* output_buffer,
 113                             int32_t num_bytes,
 114                             PP_Resource* output_addr);
 115
 116   bool private_api_;
 117
 118   // |bind_called_| is true after Bind() is called, while |bound_| is true,
 119   // after Bind() succeeds. Bind() is an asynchronous method, so the timing
 120   // on which of these is set is slightly different.
 121   bool bind_called_;
 122   bool bound_;
 123   bool closed_;
 124
 125   scoped_refptr<TrackedCallback> bind_callback_;
 126   scoped_refptr<TrackedCallback> recvfrom_callback_;
 127
 128   char* read_buffer_;
 129   int32_t bytes_to_read_;
 130   PP_Resource* recvfrom_addr_resource_;
 131
 132   PP_NetAddress_Private recvfrom_addr_;
 133   PP_NetAddress_Private bound_addr_;
 134
 135   std::queue<RecvBuffer> recv_buffers_;
 136
 137   std::queue<scoped_refptr<TrackedCallback>> sendto_callbacks_;
 138
 139   DISALLOW_COPY_AND_ASSIGN(UDPSocketResourceBase);
 140 };
 141
 142 }  // namespace proxy
 143 }  // namespace ppapi
 144
 145 #endif  // PPAPI_PROXY_UDP_SOCKET_RESOURCE_BASE_H_