[email protected] | f0ecb55 | 2012-05-11 22:09:11 | [diff] [blame] | 1 | // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
[email protected] | e2614c6 | 2011-04-16 22:12:45 | [diff] [blame] | 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_PROXY_CHANNEL_H_ |
| 6 | #define PPAPI_PROXY_PROXY_CHANNEL_H_ |
| 7 | |
dcheng | ced9224 | 2016-04-07 00:00:12 | [diff] [blame] | 8 | #include <memory> |
| 9 | |
morrita | a409ccc | 2014-10-20 23:53:25 | [diff] [blame] | 10 | #include "base/files/scoped_file.h" |
Alexandr Ilin | c7d975f | 2018-06-01 09:25:41 | [diff] [blame] | 11 | #include "base/memory/read_only_shared_memory_region.h" |
Alexandr Ilin | c7d975f | 2018-06-01 09:25:41 | [diff] [blame] | 12 | #include "base/memory/unsafe_shared_memory_region.h" |
[email protected] | 1575659 | 2013-07-25 14:17:53 | [diff] [blame] | 13 | #include "base/process/process.h" |
avi | e029c413 | 2015-12-23 06:45:22 | [diff] [blame] | 14 | #include "build/build_config.h" |
[email protected] | c47317e | 2012-06-20 22:35:31 | [diff] [blame] | 15 | #include "ipc/ipc_listener.h" |
[email protected] | e2614c6 | 2011-04-16 22:12:45 | [diff] [blame] | 16 | #include "ipc/ipc_platform_file.h" |
[email protected] | c47317e | 2012-06-20 22:35:31 | [diff] [blame] | 17 | #include "ipc/ipc_sender.h" |
[email protected] | e2614c6 | 2011-04-16 22:12:45 | [diff] [blame] | 18 | #include "ipc/ipc_sync_channel.h" |
[email protected] | f0a04c4 | 2011-08-26 22:43:20 | [diff] [blame] | 19 | #include "ppapi/proxy/ppapi_proxy_export.h" |
[email protected] | e2614c6 | 2011-04-16 22:12:45 | [diff] [blame] | 20 | |
[email protected] | e2614c6 | 2011-04-16 22:12:45 | [diff] [blame] | 21 | namespace base { |
skyostil | 12262cf | 2015-05-21 14:49:31 | [diff] [blame] | 22 | class SingleThreadTaskRunner; |
[email protected] | e2614c6 | 2011-04-16 22:12:45 | [diff] [blame] | 23 | class WaitableEvent; |
| 24 | } |
| 25 | |
[email protected] | 4d2efd2 | 2011-08-18 21:58:02 | [diff] [blame] | 26 | namespace ppapi { |
[email protected] | e2614c6 | 2011-04-16 22:12:45 | [diff] [blame] | 27 | namespace proxy { |
| 28 | |
[email protected] | f0a04c4 | 2011-08-26 22:43:20 | [diff] [blame] | 29 | class PPAPI_PROXY_EXPORT ProxyChannel |
[email protected] | c47317e | 2012-06-20 22:35:31 | [diff] [blame] | 30 | : public IPC::Listener, |
| 31 | public IPC::Sender { |
[email protected] | e2614c6 | 2011-04-16 22:12:45 | [diff] [blame] | 32 | public: |
[email protected] | 59bea13 | 2011-09-15 16:46:53 | [diff] [blame] | 33 | class PPAPI_PROXY_EXPORT Delegate { |
[email protected] | e2614c6 | 2011-04-16 22:12:45 | [diff] [blame] | 34 | public: |
[email protected] | 59bea13 | 2011-09-15 16:46:53 | [diff] [blame] | 35 | virtual ~Delegate() {} |
| 36 | |
skyostil | 12262cf | 2015-05-21 14:49:31 | [diff] [blame] | 37 | // Returns the task runner for processing IPC requests. |
| 38 | virtual base::SingleThreadTaskRunner* GetIPCTaskRunner() = 0; |
[email protected] | e2614c6 | 2011-04-16 22:12:45 | [diff] [blame] | 39 | |
| 40 | // Returns the event object that becomes signalled when the main thread's |
| 41 | // message loop exits. |
| 42 | virtual base::WaitableEvent* GetShutdownEvent() = 0; |
[email protected] | f0ecb55 | 2012-05-11 22:09:11 | [diff] [blame] | 43 | |
| 44 | // Duplicates a handle to the provided object, returning one that is valid |
| 45 | // on the other side of the channel. This is part of the delegate interface |
| 46 | // because both sides of the channel may not have sufficient permission to |
| 47 | // duplicate handles directly. The implementation must provide the same |
| 48 | // guarantees as ProxyChannel::ShareHandleWithRemote below. |
| 49 | virtual IPC::PlatformFileForTransit ShareHandleWithRemote( |
| 50 | base::PlatformFile handle, |
[email protected] | 108fd34 | 2013-01-04 20:46:54 | [diff] [blame] | 51 | base::ProcessId remote_pid, |
[email protected] | f0ecb55 | 2012-05-11 22:09:11 | [diff] [blame] | 52 | bool should_close_source) = 0; |
erikchen | 4fc32d5 | 2015-06-02 02:16:38 | [diff] [blame] | 53 | |
| 54 | // Duplicates a shared memory handle, returning one that is valid on the |
| 55 | // other side of the channel. This is part of the delegate interface |
| 56 | // because both sides of the channel may not have sufficient permission to |
| 57 | // duplicate handles directly. The implementation must provide the same |
| 58 | // guarantees as ProxyChannel::ShareSharedMemoryHandleWithRemote below. |
Alexandr Ilin | c7d975f | 2018-06-01 09:25:41 | [diff] [blame] | 59 | virtual base::UnsafeSharedMemoryRegion |
| 60 | ShareUnsafeSharedMemoryRegionWithRemote( |
| 61 | const base::UnsafeSharedMemoryRegion& region, |
| 62 | base::ProcessId remote_pid) = 0; |
| 63 | virtual base::ReadOnlySharedMemoryRegion |
| 64 | ShareReadOnlySharedMemoryRegionWithRemote( |
| 65 | const base::ReadOnlySharedMemoryRegion& region, |
| 66 | base::ProcessId remote_pid) = 0; |
[email protected] | e2614c6 | 2011-04-16 22:12:45 | [diff] [blame] | 67 | }; |
| 68 | |
Peter Boström | 3d5b3cb | 2021-09-23 21:35:45 | [diff] [blame] | 69 | ProxyChannel(const ProxyChannel&) = delete; |
| 70 | ProxyChannel& operator=(const ProxyChannel&) = delete; |
| 71 | |
nick | e478443 | 2015-04-23 14:01:48 | [diff] [blame] | 72 | ~ProxyChannel() override; |
[email protected] | e2614c6 | 2011-04-16 22:12:45 | [diff] [blame] | 73 | |
[email protected] | f7b7eb7c | 2014-02-27 23:54:15 | [diff] [blame] | 74 | // Alternative to InitWithChannel() for unit tests that want to send all |
| 75 | // messages sent via this channel to the given test sink. The test sink |
| 76 | // must outlive this class. In this case, the peer PID will be the current |
| 77 | // process ID. |
cfredric | 455bf84 | 2021-07-09 21:02:18 | [diff] [blame] | 78 | void InitWithTestSink(IPC::Sender* sender); |
[email protected] | e2614c6 | 2011-04-16 22:12:45 | [diff] [blame] | 79 | |
| 80 | // Shares a file handle (HANDLE / file descriptor) with the remote side. It |
| 81 | // returns a handle that should be sent in exactly one IPC message. Upon |
| 82 | // receipt, the remote side then owns that handle. Note: if sending the |
| 83 | // message fails, the returned handle is properly closed by the IPC system. If |
| 84 | // should_close_source is set to true, the original handle is closed by this |
| 85 | // operation and should not be used again. |
| 86 | IPC::PlatformFileForTransit ShareHandleWithRemote( |
| 87 | base::PlatformFile handle, |
| 88 | bool should_close_source); |
| 89 | |
erikchen | 4fc32d5 | 2015-06-02 02:16:38 | [diff] [blame] | 90 | // Shares a shared memory handle with the remote side. It returns a handle |
| 91 | // that should be sent in exactly one IPC message. Upon receipt, the remote |
| 92 | // side then owns that handle. Note: if sending the message fails, the |
| 93 | // returned handle is properly closed by the IPC system. The original handle |
| 94 | // is not closed by this operation. |
Alexandr Ilin | c7d975f | 2018-06-01 09:25:41 | [diff] [blame] | 95 | base::UnsafeSharedMemoryRegion ShareUnsafeSharedMemoryRegionWithRemote( |
| 96 | const base::UnsafeSharedMemoryRegion& region); |
| 97 | base::ReadOnlySharedMemoryRegion ShareReadOnlySharedMemoryRegionWithRemote( |
| 98 | const base::ReadOnlySharedMemoryRegion& region); |
erikchen | 4fc32d5 | 2015-06-02 02:16:38 | [diff] [blame] | 99 | |
[email protected] | c47317e | 2012-06-20 22:35:31 | [diff] [blame] | 100 | // IPC::Sender implementation. |
nick | e478443 | 2015-04-23 14:01:48 | [diff] [blame] | 101 | bool Send(IPC::Message* msg) override; |
[email protected] | e2614c6 | 2011-04-16 22:12:45 | [diff] [blame] | 102 | |
[email protected] | c47317e | 2012-06-20 22:35:31 | [diff] [blame] | 103 | // IPC::Listener implementation. |
nick | e478443 | 2015-04-23 14:01:48 | [diff] [blame] | 104 | void OnChannelError() override; |
[email protected] | e2614c6 | 2011-04-16 22:12:45 | [diff] [blame] | 105 | |
| 106 | // Will be NULL in some unit tests and if the remote side has crashed. |
| 107 | IPC::SyncChannel* channel() const { |
| 108 | return channel_.get(); |
| 109 | } |
| 110 | |
sammc | f810f07f | 2016-11-10 22:34:07 | [diff] [blame] | 111 | base::ProcessId peer_pid() { return peer_pid_; } |
| 112 | |
[email protected] | e2614c6 | 2011-04-16 22:12:45 | [diff] [blame] | 113 | protected: |
[email protected] | f0ecb55 | 2012-05-11 22:09:11 | [diff] [blame] | 114 | explicit ProxyChannel(); |
[email protected] | e2614c6 | 2011-04-16 22:12:45 | [diff] [blame] | 115 | |
[email protected] | f7b7eb7c | 2014-02-27 23:54:15 | [diff] [blame] | 116 | // You must call this function before anything else. Returns true on success. |
[email protected] | e2614c6 | 2011-04-16 22:12:45 | [diff] [blame] | 117 | // The delegate pointer must outlive this class, ownership is not |
| 118 | // transferred. |
Hajime Hoshi | 5959c54f | 2019-01-09 01:42:12 | [diff] [blame] | 119 | virtual bool InitWithChannel( |
| 120 | Delegate* delegate, |
| 121 | base::ProcessId peer_pid, |
| 122 | const IPC::ChannelHandle& channel_handle, |
| 123 | bool is_client, |
| 124 | scoped_refptr<base::SingleThreadTaskRunner> task_runner); |
[email protected] | e2614c6 | 2011-04-16 22:12:45 | [diff] [blame] | 125 | |
| 126 | ProxyChannel::Delegate* delegate() const { |
| 127 | return delegate_; |
| 128 | } |
| 129 | |
| 130 | private: |
| 131 | // Non-owning pointer. Guaranteed non-NULL after init is called. |
| 132 | ProxyChannel::Delegate* delegate_; |
| 133 | |
[email protected] | 108fd34 | 2013-01-04 20:46:54 | [diff] [blame] | 134 | // PID of the remote process. Use this instead of the Channel::peer_pid since |
| 135 | // this is set synchronously on construction rather than waiting on the |
| 136 | // "hello" message from the peer (which introduces a race condition). |
| 137 | base::ProcessId peer_pid_; |
| 138 | |
[email protected] | e2614c6 | 2011-04-16 22:12:45 | [diff] [blame] | 139 | // When we're unit testing, this will indicate the sink for the messages to |
| 140 | // be deposited so they can be inspected by the test. When non-NULL, this |
| 141 | // indicates that the channel should not be used. |
cfredric | 455bf84 | 2021-07-09 21:02:18 | [diff] [blame] | 142 | IPC::Sender* test_sink_; |
[email protected] | e2614c6 | 2011-04-16 22:12:45 | [diff] [blame] | 143 | |
| 144 | // Will be null for some tests when there is a test_sink_, and if the |
| 145 | // remote side has crashed. |
dcheng | ced9224 | 2016-04-07 00:00:12 | [diff] [blame] | 146 | std::unique_ptr<IPC::SyncChannel> channel_; |
[email protected] | e2614c6 | 2011-04-16 22:12:45 | [diff] [blame] | 147 | }; |
| 148 | |
| 149 | } // namespace proxy |
[email protected] | 4d2efd2 | 2011-08-18 21:58:02 | [diff] [blame] | 150 | } // namespace ppapi |
[email protected] | e2614c6 | 2011-04-16 22:12:45 | [diff] [blame] | 151 | |
| 152 | #endif // PPAPI_PROXY_PROXY_CHANNEL_H_ |