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 MOJO_SYSTEM_MESSAGE_PIPE_DISPATCHER_H_ 6 #define MOJO_SYSTEM_MESSAGE_PIPE_DISPATCHER_H_ 7 8 #include "base/macros.h" 9 #include "base/memory/ref_counted.h" 10 #include "mojo/system/dispatcher.h" 11 #include "mojo/system/memory.h" 12 #include "mojo/system/system_impl_export.h" 13 14 namespace mojo { 15 namespace system { 16 17 class ChannelEndpoint; 18 class MessagePipe; 19 class MessagePipeDispatcherTransport; 20 21 // This is the |Dispatcher| implementation for message pipes (created by the 22 // Mojo primitive |MojoCreateMessagePipe()|). This class is thread-safe. 23 class MOJO_SYSTEM_IMPL_EXPORT MessagePipeDispatcher : public Dispatcher { 24 public: 25 // The default options to use for |MojoCreateMessagePipe()|. (Real uses 26 // should obtain this via |ValidateCreateOptions()| with a null |in_options|; 27 // this is exposed directly for testing convenience.) 28 static const MojoCreateMessagePipeOptions kDefaultCreateOptions; 29 30 MessagePipeDispatcher( 31 const MojoCreateMessagePipeOptions& /*validated_options*/); 32 33 // Validates and/or sets default options for |MojoCreateMessagePipeOptions|. 34 // If non-null, |in_options| must point to a struct of at least 35 // |in_options->struct_size| bytes. |out_options| must point to a (current) 36 // |MojoCreateMessagePipeOptions| and will be entirely overwritten on success 37 // (it may be partly overwritten on failure). 38 static MojoResult ValidateCreateOptions( 39 UserPointer<const MojoCreateMessagePipeOptions> in_options, 40 MojoCreateMessagePipeOptions* out_options); 41 42 // Must be called before any other methods. (This method is not thread-safe.) 43 void Init(scoped_refptr<MessagePipe> message_pipe, unsigned port); 44 45 // |Dispatcher| public methods: 46 virtual Type GetType() const OVERRIDE; 47 48 // Creates a |MessagePipe| with a local endpoint (at port 0) and a proxy 49 // endpoint, and creates/initializes a |MessagePipeDispatcher| (attached to 50 // the message pipe, port 0). 51 // TODO(vtl): This currently uses |kDefaultCreateOptions|, which is okay since 52 // there aren't any options, but eventually options should be plumbed through. 53 static scoped_refptr<MessagePipeDispatcher> CreateRemoteMessagePipe( 54 scoped_refptr<ChannelEndpoint>* channel_endpoint); 55 56 // The "opposite" of |SerializeAndClose()|. (Typically this is called by 57 // |Dispatcher::Deserialize()|.) 58 static scoped_refptr<MessagePipeDispatcher> Deserialize(Channel* channel, 59 const void* source, 60 size_t size); 61 62 private: 63 friend class MessagePipeDispatcherTransport; 64 65 virtual ~MessagePipeDispatcher(); 66 67 // Gets a dumb pointer to |message_pipe_|. This must be called under the 68 // |Dispatcher| lock (that it's a dumb pointer is okay since it's under lock). 69 // This is needed when sending handles across processes, where nontrivial, 70 // invasive work needs to be done. 71 MessagePipe* GetMessagePipeNoLock() const; 72 // Similarly for the port. 73 unsigned GetPortNoLock() const; 74 75 // |Dispatcher| protected methods: 76 virtual void CancelAllWaitersNoLock() OVERRIDE; 77 virtual void CloseImplNoLock() OVERRIDE; 78 virtual scoped_refptr<Dispatcher> 79 CreateEquivalentDispatcherAndCloseImplNoLock() OVERRIDE; 80 virtual MojoResult WriteMessageImplNoLock( 81 UserPointer<const void> bytes, 82 uint32_t num_bytes, 83 std::vector<DispatcherTransport>* transports, 84 MojoWriteMessageFlags flags) OVERRIDE; 85 virtual MojoResult ReadMessageImplNoLock(UserPointer<void> bytes, 86 UserPointer<uint32_t> num_bytes, 87 DispatcherVector* dispatchers, 88 uint32_t* num_dispatchers, 89 MojoReadMessageFlags flags) OVERRIDE; 90 virtual HandleSignalsState GetHandleSignalsStateImplNoLock() const OVERRIDE; 91 virtual MojoResult AddWaiterImplNoLock( 92 Waiter* waiter, 93 MojoHandleSignals signals, 94 uint32_t context, 95 HandleSignalsState* signals_state) OVERRIDE; 96 virtual void RemoveWaiterImplNoLock( 97 Waiter* waiter, 98 HandleSignalsState* signals_state) OVERRIDE; 99 virtual void StartSerializeImplNoLock(Channel* channel, 100 size_t* max_size, 101 size_t* max_platform_handles) OVERRIDE; 102 virtual bool EndSerializeAndCloseImplNoLock( 103 Channel* channel, 104 void* destination, 105 size_t* actual_size, 106 embedder::PlatformHandleVector* platform_handles) OVERRIDE; 107 108 // Protected by |lock()|: 109 scoped_refptr<MessagePipe> message_pipe_; // This will be null if closed. 110 unsigned port_; 111 112 DISALLOW_COPY_AND_ASSIGN(MessagePipeDispatcher); 113 }; 114 115 class MessagePipeDispatcherTransport : public DispatcherTransport { 116 public: 117 explicit MessagePipeDispatcherTransport(DispatcherTransport transport); 118 119 MessagePipe* GetMessagePipe() { 120 return message_pipe_dispatcher()->GetMessagePipeNoLock(); 121 } 122 unsigned GetPort() { return message_pipe_dispatcher()->GetPortNoLock(); } 123 124 private: 125 MessagePipeDispatcher* message_pipe_dispatcher() { 126 return static_cast<MessagePipeDispatcher*>(dispatcher()); 127 } 128 129 // Copy and assign allowed. 130 }; 131 132 } // namespace system 133 } // namespace mojo 134 135 #endif // MOJO_SYSTEM_MESSAGE_PIPE_DISPATCHER_H_ 136