| // Copyright 2015 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. |
| |
| #ifndef PPAPI_PROXY_UDP_SOCKET_FILTER_H_ |
| #define PPAPI_PROXY_UDP_SOCKET_FILTER_H_ |
| |
| #include <stddef.h> |
| #include <stdint.h> |
| |
| #include <memory> |
| #include <queue> |
| #include <string> |
| #include <unordered_map> |
| |
| #include "base/compiler_specific.h" |
| #include "base/memory/ref_counted.h" |
| #include "ppapi/c/ppb_udp_socket.h" |
| #include "ppapi/c/private/ppb_net_address_private.h" |
| #include "ppapi/proxy/plugin_resource.h" |
| #include "ppapi/proxy/ppapi_proxy_export.h" |
| #include "ppapi/proxy/resource_message_filter.h" |
| #include "ppapi/shared_impl/tracked_callback.h" |
| |
| namespace ppapi { |
| namespace proxy { |
| |
| class ResourceMessageReplyParams; |
| |
| // Handles receiving UDP packets on the IO thread so that when the recipient is |
| // not on the main thread, we can post directly to the appropriate thread. |
| class PPAPI_PROXY_EXPORT UDPSocketFilter : public ResourceMessageFilter { |
| public: |
| UDPSocketFilter(); |
| |
| // All these are called on whatever thread the plugin wants, while already |
| // holding the ppapi::ProxyLock. The "slot_available_callback" will be invoked |
| // whenever we detect that a slot is now available, so that the client can |
| // take appropriate action (like informing the host we can receive another |
| // buffer). It will always be run with the ProxyLock. |
| void AddUDPResource(PP_Instance instance, |
| PP_Resource resource, |
| bool private_api, |
| const base::Closure& slot_available_callback); |
| void RemoveUDPResource(PP_Resource resource); |
| // Note, the slot_available_callback that was provided to AddUDPResource may |
| // be invoked during the RequestData call; this gives the client the |
| // opportunity to post a message to the host immediately. |
| int32_t RequestData(PP_Resource resource, |
| int32_t num_bytes, |
| char* buffer, |
| PP_Resource* addr, |
| const scoped_refptr<TrackedCallback>& callback); |
| |
| // ResourceMessageFilter implementation. |
| bool OnResourceReplyReceived(const ResourceMessageReplyParams& reply_params, |
| const IPC::Message& nested_msg) override; |
| |
| PP_NetAddress_Private GetLastAddrPrivate(PP_Resource resource) const; |
| |
| // The maximum number of bytes that each |
| // PpapiPluginMsg_PPBUDPSocket_PushRecvResult message is allowed to carry. |
| static const int32_t kMaxReadSize; |
| // The maximum number that we allow for setting |
| // PP_UDPSOCKET_OPTION_RECV_BUFFER_SIZE. This number is only for input |
| // argument sanity check, it doesn't mean the browser guarantees to support |
| // such a buffer size. |
| static const int32_t kMaxReceiveBufferSize; |
| // The maximum number of received packets that we allow instances of this |
| // class to buffer. |
| static const size_t kPluginReceiveBufferSlots; |
| |
| private: |
| // The queue of received data intended for 1 UDPSocketResourceBase. All usage |
| // must be protected by UDPSocketFilter::lock_. |
| class RecvQueue { |
| public: |
| explicit RecvQueue(PP_Instance instance, |
| bool private_api, |
| const base::Closure& slot_available_callback); |
| ~RecvQueue(); |
| |
| // Called on the IO thread when data is received. It will post |callback_| |
| // if it's valid, otherwise push the data on buffers_. |
| // The ppapi::ProxyLock should *not* be held, and won't be acquired. |
| void DataReceivedOnIOThread(int32_t result, |
| const std::string& d, |
| const PP_NetAddress_Private& addr); |
| // Called on whatever thread the plugin chooses. Must already hold the |
| // PpapiProxyLock. Returns a code from pp_errors.h, or a positive number. |
| // |
| // Note, the out-params are owned by the plugin, and if the request can't be |
| // handled immediately, they will be written later just before the callback |
| // is invoked. |
| int32_t RequestData(int32_t num_bytes, |
| char* buffer_out, |
| PP_Resource* addr_out, |
| const scoped_refptr<TrackedCallback>& callback); |
| PP_NetAddress_Private GetLastAddrPrivate() const; |
| |
| private: |
| struct RecvBuffer { |
| int32_t result; |
| std::string data; |
| PP_NetAddress_Private addr; |
| }; |
| std::queue<RecvBuffer> recv_buffers_; |
| |
| PP_Instance pp_instance_; |
| scoped_refptr<ppapi::TrackedCallback> recvfrom_callback_; |
| char* read_buffer_; |
| int32_t bytes_to_read_; |
| PP_Resource* recvfrom_addr_resource_; |
| PP_NetAddress_Private last_recvfrom_addr_; |
| bool private_api_; |
| // Callback to invoke when a UDP receive slot is available. |
| base::Closure slot_available_callback_; |
| }; |
| |
| private: |
| // This is deleted via RefCountedThreadSafe (see ResourceMessageFilter). |
| ~UDPSocketFilter(); |
| void OnPluginMsgPushRecvResult(const ResourceMessageReplyParams& params, |
| int32_t result, |
| const std::string& data, |
| const PP_NetAddress_Private& addr); |
| |
| // lock_ protects queues_. |
| // |
| // Lock order (if >1 acquired): |
| // 1 ppapi::ProxyLock |
| // \-->2 Filter lock_ |
| mutable base::Lock lock_; |
| std::unordered_map<PP_Resource, std::unique_ptr<RecvQueue>> queues_; |
| }; |
| |
| } // namespace proxy |
| } // namespace ppapi |
| |
| #endif // PPAPI_PROXY_UDP_SOCKET_FILTER_H_ |