| // 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. |
| |
| #ifndef PPAPI_PROXY_RESOURCE_MESSAGE_PARAMS_H_ |
| #define PPAPI_PROXY_RESOURCE_MESSAGE_PARAMS_H_ |
| |
| #include <stddef.h> |
| #include <stdint.h> |
| |
| #include <vector> |
| |
| #include "base/memory/ref_counted.h" |
| #include "ipc/ipc_message_utils.h" |
| #include "ppapi/c/pp_resource.h" |
| #include "ppapi/proxy/ppapi_proxy_export.h" |
| #include "ppapi/proxy/serialized_handle.h" |
| |
| namespace base { |
| class ReadOnlySharedMemoryRegion; |
| } |
| |
| namespace ppapi { |
| namespace proxy { |
| |
| // Common parameters for resource call and reply params structures below. |
| class PPAPI_PROXY_EXPORT ResourceMessageParams { |
| public: |
| virtual ~ResourceMessageParams(); |
| |
| PP_Resource pp_resource() const { return pp_resource_; } |
| int32_t sequence() const { return sequence_; } |
| |
| // Note that the caller doesn't take ownership of the returned handles. |
| const std::vector<SerializedHandle>& handles() const { |
| return handles_->data(); |
| } |
| |
| // Makes ResourceMessageParams leave its handles open, even if they weren't |
| // taken using a Take.* function. After this call, no Take.* calls are |
| // allowed. |
| void ConsumeHandles() const; |
| |
| // Returns the handle at the given index if it exists and is of the given |
| // type. The corresponding slot in the list is set to an invalid handle. |
| // If the index doesn't exist or the handle isn't of the given type, returns |
| // an invalid handle. |
| // Note that the caller is responsible for closing the returned handle, if it |
| // is valid. |
| SerializedHandle TakeHandleOfTypeAtIndex(size_t index, |
| SerializedHandle::Type type) const; |
| |
| // Helper functions to return shared memory, socket or file handles passed in |
| // the params struct. |
| // If the index has a valid handle of the given type, it will be placed in the |
| // output parameter, the corresponding slot in the list will be set to an |
| // invalid handle, and the function will return true. If the handle doesn't |
| // exist or is a different type, the functions will return false and the |
| // output parameter will be untouched. |
| // |
| // Note: 1) the handle could still be a "null" or invalid handle of the right |
| // type and the functions will succeed. |
| // 2) the caller is responsible for closing the returned handle, if it |
| // is valid. |
| bool TakeSharedMemoryHandleAtIndex(size_t index, |
| base::SharedMemoryHandle* handle) const; |
| bool TakeReadOnlySharedMemoryRegionAtIndex( |
| size_t index, |
| base::ReadOnlySharedMemoryRegion* region) const; |
| bool TakeSocketHandleAtIndex(size_t index, |
| IPC::PlatformFileForTransit* handle) const; |
| bool TakeFileHandleAtIndex(size_t index, |
| IPC::PlatformFileForTransit* handle) const; |
| void TakeAllSharedMemoryHandles( |
| std::vector<base::SharedMemoryHandle>* handles) const; |
| void TakeAllHandles(std::vector<SerializedHandle>* handles) const; |
| |
| // Appends the given handle to the list of handles sent with the call or |
| // reply. |
| void AppendHandle(SerializedHandle handle) const; |
| |
| protected: |
| ResourceMessageParams(); |
| ResourceMessageParams(PP_Resource resource, int32_t sequence); |
| |
| virtual void Serialize(base::Pickle* msg) const; |
| virtual bool Deserialize(const base::Pickle* msg, base::PickleIterator* iter); |
| |
| // Writes everything except the handles to |msg|. |
| void WriteHeader(base::Pickle* msg) const; |
| // Writes the handles to |msg|. |
| void WriteHandles(base::Pickle* msg) const; |
| // Matching deserialize helpers. |
| bool ReadHeader(const base::Pickle* msg, base::PickleIterator* iter); |
| bool ReadHandles(const base::Pickle* msg, base::PickleIterator* iter); |
| |
| private: |
| class PPAPI_PROXY_EXPORT SerializedHandles |
| : public base::RefCountedThreadSafe<SerializedHandles> { |
| public: |
| SerializedHandles(); |
| ~SerializedHandles(); |
| |
| void set_should_close(bool value) { should_close_ = value; } |
| std::vector<SerializedHandle>& data() { return data_; } |
| |
| private: |
| friend class base::RefCountedThreadSafe<SerializedHandles>; |
| |
| // Whether the handles stored in |data_| should be closed when this object |
| // goes away. |
| // |
| // It is set to true by ResourceMessageParams::Deserialize(), so that the |
| // receiving side of the params (the host side for |
| // ResourceMessageCallParams; the plugin side for |
| // ResourceMessageReplyParams) will close those handles which haven't been |
| // taken using any of the Take*() methods. |
| bool should_close_; |
| std::vector<SerializedHandle> data_; |
| }; |
| |
| PP_Resource pp_resource_; |
| |
| // Identifier for this message. Sequence numbers are quasi-unique within a |
| // resource, but will overlap between different resource objects. |
| // |
| // If you send a lot of messages, the ID may wrap around. This is OK. All IDs |
| // are valid and 0 and -1 aren't special, so those cases won't confuse us. |
| // In practice, if you send more than 4 billion messages for a resource, the |
| // old ones will be long gone and there will be no collisions. |
| // |
| // If there is a malicious plugin (or exceptionally bad luck) that causes a |
| // wraparound and collision the worst that will happen is that we can get |
| // confused between different callbacks. But since these can only cause |
| // confusion within the plugin and within callbacks on the same resource, |
| // there shouldn't be a security problem. |
| int32_t sequence_; |
| |
| // A list of all handles transferred in the message. Handles go here so that |
| // the NaCl adapter can extract them generally when it rewrites them to |
| // go between Windows and NaCl (Posix) apps. |
| // TODO(yzshen): Mark it as mutable so that we can take/append handles using a |
| // const reference. We need to change all the callers and make it not mutable. |
| mutable scoped_refptr<SerializedHandles> handles_; |
| }; |
| |
| // Parameters common to all ResourceMessage "Call" requests. |
| class PPAPI_PROXY_EXPORT ResourceMessageCallParams |
| : public ResourceMessageParams { |
| public: |
| ResourceMessageCallParams(); |
| ResourceMessageCallParams(PP_Resource resource, int32_t sequence); |
| ~ResourceMessageCallParams() override; |
| |
| void set_has_callback() { has_callback_ = true; } |
| bool has_callback() const { return has_callback_; } |
| |
| void Serialize(base::Pickle* msg) const override; |
| bool Deserialize(const base::Pickle* msg, |
| base::PickleIterator* iter) override; |
| |
| private: |
| bool has_callback_; |
| }; |
| |
| // Parameters common to all ResourceMessage "Reply" requests. |
| class PPAPI_PROXY_EXPORT ResourceMessageReplyParams |
| : public ResourceMessageParams { |
| public: |
| ResourceMessageReplyParams(); |
| ResourceMessageReplyParams(PP_Resource resource, int32_t sequence); |
| ~ResourceMessageReplyParams() override; |
| |
| void set_result(int32_t r) { result_ = r; } |
| int32_t result() const { return result_; } |
| |
| void Serialize(base::Pickle* msg) const override; |
| bool Deserialize(const base::Pickle* msg, |
| base::PickleIterator* iter) override; |
| |
| // Writes everything except the handles to |msg|. |
| void WriteReplyHeader(base::Pickle* msg) const; |
| |
| private: |
| // Pepper "result code" for the callback. |
| int32_t result_; |
| }; |
| |
| } // namespace proxy |
| } // namespace ppapi |
| |
| namespace IPC { |
| |
| template <> struct PPAPI_PROXY_EXPORT |
| ParamTraits<ppapi::proxy::ResourceMessageCallParams> { |
| typedef ppapi::proxy::ResourceMessageCallParams param_type; |
| static void Write(base::Pickle* m, const param_type& p) { p.Serialize(m); } |
| static bool Read(const base::Pickle* m, |
| base::PickleIterator* iter, |
| param_type* r) { |
| return r->Deserialize(m, iter); |
| } |
| static void Log(const param_type& p, std::string* l) { |
| } |
| }; |
| |
| template <> struct PPAPI_PROXY_EXPORT |
| ParamTraits<ppapi::proxy::ResourceMessageReplyParams> { |
| typedef ppapi::proxy::ResourceMessageReplyParams param_type; |
| static void Write(base::Pickle* m, const param_type& p) { p.Serialize(m); } |
| static bool Read(const base::Pickle* m, |
| base::PickleIterator* iter, |
| param_type* r) { |
| return r->Deserialize(m, iter); |
| } |
| static void Log(const param_type& p, std::string* l) { |
| } |
| }; |
| |
| } // namespace IPC |
| |
| #endif // PPAPI_PROXY_RESOURCE_MESSAGE_PARAMS_H_ |