1 // Copyright (c) 2012 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_PROXY_CHANNEL_H_ 6 #define PPAPI_PROXY_PROXY_CHANNEL_H_ 7 8 #include "base/memory/scoped_ptr.h" 9 #include "base/process/process.h" 10 #include "ipc/ipc_listener.h" 11 #include "ipc/ipc_platform_file.h" 12 #include "ipc/ipc_sender.h" 13 #include "ipc/ipc_sync_channel.h" 14 #include "ppapi/proxy/ppapi_proxy_export.h" 15 16 namespace base { 17 class MessageLoopProxy; 18 class WaitableEvent; 19 } 20 21 namespace IPC { 22 class TestSink; 23 } 24 25 namespace ppapi { 26 namespace proxy { 27 28 class PPAPI_PROXY_EXPORT ProxyChannel 29 : public IPC::Listener, 30 public IPC::Sender { 31 public: 32 class PPAPI_PROXY_EXPORT Delegate { 33 public: 34 virtual ~Delegate() {} 35 36 // Returns the dedicated message loop for processing IPC requests. 37 virtual base::MessageLoopProxy* GetIPCMessageLoop() = 0; 38 39 // Returns the event object that becomes signalled when the main thread's 40 // message loop exits. 41 virtual base::WaitableEvent* GetShutdownEvent() = 0; 42 43 // Duplicates a handle to the provided object, returning one that is valid 44 // on the other side of the channel. This is part of the delegate interface 45 // because both sides of the channel may not have sufficient permission to 46 // duplicate handles directly. The implementation must provide the same 47 // guarantees as ProxyChannel::ShareHandleWithRemote below. 48 virtual IPC::PlatformFileForTransit ShareHandleWithRemote( 49 base::PlatformFile handle, 50 base::ProcessId remote_pid, 51 bool should_close_source) = 0; 52 }; 53 54 virtual ~ProxyChannel(); 55 56 // Alternative to InitWithChannel() for unit tests that want to send all 57 // messages sent via this channel to the given test sink. The test sink 58 // must outlive this class. In this case, the peer PID will be the current 59 // process ID. 60 void InitWithTestSink(IPC::TestSink* test_sink); 61 62 // Shares a file handle (HANDLE / file descriptor) with the remote side. It 63 // returns a handle that should be sent in exactly one IPC message. Upon 64 // receipt, the remote side then owns that handle. Note: if sending the 65 // message fails, the returned handle is properly closed by the IPC system. If 66 // should_close_source is set to true, the original handle is closed by this 67 // operation and should not be used again. 68 IPC::PlatformFileForTransit ShareHandleWithRemote( 69 base::PlatformFile handle, 70 bool should_close_source); 71 72 // IPC::Sender implementation. 73 virtual bool Send(IPC::Message* msg) OVERRIDE; 74 75 // IPC::Listener implementation. 76 virtual void OnChannelError() OVERRIDE; 77 78 // Will be NULL in some unit tests and if the remote side has crashed. 79 IPC::SyncChannel* channel() const { 80 return channel_.get(); 81 } 82 83 #if defined(OS_POSIX) && !defined(OS_NACL) 84 int TakeRendererFD(); 85 #endif 86 87 protected: 88 explicit ProxyChannel(); 89 90 // You must call this function before anything else. Returns true on success. 91 // The delegate pointer must outlive this class, ownership is not 92 // transferred. 93 virtual bool InitWithChannel(Delegate* delegate, 94 base::ProcessId peer_pid, 95 const IPC::ChannelHandle& channel_handle, 96 bool is_client); 97 98 ProxyChannel::Delegate* delegate() const { 99 return delegate_; 100 } 101 102 private: 103 // Non-owning pointer. Guaranteed non-NULL after init is called. 104 ProxyChannel::Delegate* delegate_; 105 106 // PID of the remote process. Use this instead of the Channel::peer_pid since 107 // this is set synchronously on construction rather than waiting on the 108 // "hello" message from the peer (which introduces a race condition). 109 base::ProcessId peer_pid_; 110 111 // When we're unit testing, this will indicate the sink for the messages to 112 // be deposited so they can be inspected by the test. When non-NULL, this 113 // indicates that the channel should not be used. 114 IPC::TestSink* test_sink_; 115 116 // Will be null for some tests when there is a test_sink_, and if the 117 // remote side has crashed. 118 scoped_ptr<IPC::SyncChannel> channel_; 119 120 DISALLOW_COPY_AND_ASSIGN(ProxyChannel); 121 }; 122 123 } // namespace proxy 124 } // namespace ppapi 125 126 #endif // PPAPI_PROXY_PROXY_CHANNEL_H_ 127