1 // Copyright 2015 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_EDK_SYSTEM_MESSAGE_PIPE_DISPATCHER_H_ 6 #define MOJO_EDK_SYSTEM_MESSAGE_PIPE_DISPATCHER_H_ 7 8 #include <stdint.h> 9 10 #include <memory> 11 #include <queue> 12 13 #include "base/macros.h" 14 #include "mojo/edk/system/atomic_flag.h" 15 #include "mojo/edk/system/awakable_list.h" 16 #include "mojo/edk/system/dispatcher.h" 17 #include "mojo/edk/system/message_for_transit.h" 18 #include "mojo/edk/system/ports/port_ref.h" 19 20 namespace mojo { 21 namespace edk { 22 23 class NodeController; 24 class PortsMessage; 25 26 class MessagePipeDispatcher : public Dispatcher { 27 public: 28 // Constructs a MessagePipeDispatcher permanently tied to a specific port. 29 // |connected| must indicate the state of the port at construction time; if 30 // the port is initialized with a peer, |connected| must be true. Otherwise it 31 // must be false. 32 // 33 // A MessagePipeDispatcher may not be transferred while in a disconnected 34 // state, and one can never return to a disconnected once connected. 35 // 36 // |pipe_id| is a unique identifier which can be used to track pipe endpoints 37 // as they're passed around. |endpoint| is either 0 or 1 and again is only 38 // used for tracking pipes (one side is always 0, the other is always 1.) 39 MessagePipeDispatcher(NodeController* node_controller, 40 const ports::PortRef& port, 41 uint64_t pipe_id, 42 int endpoint); 43 44 // Fuses this pipe with |other|. Returns |true| on success or |false| on 45 // failure. Regardless of the return value, both dispatchers are closed by 46 // this call. 47 bool Fuse(MessagePipeDispatcher* other); 48 49 // Dispatcher: 50 Type GetType() const override; 51 MojoResult Close() override; 52 MojoResult Watch(MojoHandleSignals signals, 53 const Watcher::WatchCallback& callback, 54 uintptr_t context) override; 55 MojoResult CancelWatch(uintptr_t context) override; 56 MojoResult WriteMessage(std::unique_ptr<MessageForTransit> message, 57 MojoWriteMessageFlags flags) override; 58 MojoResult ReadMessage(std::unique_ptr<MessageForTransit>* message, 59 uint32_t* num_bytes, 60 MojoHandle* handles, 61 uint32_t* num_handles, 62 MojoReadMessageFlags flags, 63 bool read_any_size) override; 64 HandleSignalsState GetHandleSignalsState() const override; 65 MojoResult AddAwakable(Awakable* awakable, 66 MojoHandleSignals signals, 67 uintptr_t context, 68 HandleSignalsState* signals_state) override; 69 void RemoveAwakable(Awakable* awakable, 70 HandleSignalsState* signals_state) override; 71 void StartSerialize(uint32_t* num_bytes, 72 uint32_t* num_ports, 73 uint32_t* num_handles) override; 74 bool EndSerialize(void* destination, 75 ports::PortName* ports, 76 PlatformHandle* handles) override; 77 bool BeginTransit() override; 78 void CompleteTransitAndClose() override; 79 void CancelTransit() override; 80 81 static scoped_refptr<Dispatcher> Deserialize( 82 const void* data, 83 size_t num_bytes, 84 const ports::PortName* ports, 85 size_t num_ports, 86 PlatformHandle* handles, 87 size_t num_handles); 88 89 private: 90 class PortObserverThunk; 91 friend class PortObserverThunk; 92 93 ~MessagePipeDispatcher() override; 94 95 MojoResult CloseNoLock(); 96 HandleSignalsState GetHandleSignalsStateNoLock() const; 97 void OnPortStatusChanged(); 98 99 // These are safe to access from any thread without locking. 100 NodeController* const node_controller_; 101 const ports::PortRef port_; 102 const uint64_t pipe_id_; 103 const int endpoint_; 104 105 // Guards access to all the fields below. 106 mutable base::Lock signal_lock_; 107 108 // This is not the same is |port_transferred_|. It's only held true between 109 // BeginTransit() and Complete/CancelTransit(). 110 AtomicFlag in_transit_; 111 112 bool port_transferred_ = false; 113 AtomicFlag port_closed_; 114 AwakableList awakables_; 115 116 DISALLOW_COPY_AND_ASSIGN(MessagePipeDispatcher); 117 }; 118 119 } // namespace edk 120 } // namespace mojo 121 122 #endif // MOJO_EDK_SYSTEM_MESSAGE_PIPE_DISPATCHER_H_ 123