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 #include "mojo/edk/system/dispatcher.h"
6
7 #include "base/logging.h"
8 #include "mojo/edk/system/configuration.h"
9 #include "mojo/edk/system/data_pipe_consumer_dispatcher.h"
10 #include "mojo/edk/system/data_pipe_producer_dispatcher.h"
11 #include "mojo/edk/system/message_pipe_dispatcher.h"
12 #include "mojo/edk/system/platform_handle_dispatcher.h"
13 #include "mojo/edk/system/shared_buffer_dispatcher.h"
14
15 namespace mojo {
16 namespace edk {
17
DispatcherInTransit()18 Dispatcher::DispatcherInTransit::DispatcherInTransit() {}
19
20 Dispatcher::DispatcherInTransit::DispatcherInTransit(
21 const DispatcherInTransit& other) = default;
22
~DispatcherInTransit()23 Dispatcher::DispatcherInTransit::~DispatcherInTransit() {}
24
Watch(MojoHandleSignals signals,const Watcher::WatchCallback & callback,uintptr_t context)25 MojoResult Dispatcher::Watch(MojoHandleSignals signals,
26 const Watcher::WatchCallback& callback,
27 uintptr_t context) {
28 return MOJO_RESULT_INVALID_ARGUMENT;
29 }
30
CancelWatch(uintptr_t context)31 MojoResult Dispatcher::CancelWatch(uintptr_t context) {
32 return MOJO_RESULT_INVALID_ARGUMENT;
33 }
34
WriteMessage(std::unique_ptr<MessageForTransit> message,MojoWriteMessageFlags flags)35 MojoResult Dispatcher::WriteMessage(std::unique_ptr<MessageForTransit> message,
36 MojoWriteMessageFlags flags) {
37 return MOJO_RESULT_INVALID_ARGUMENT;
38 }
39
ReadMessage(std::unique_ptr<MessageForTransit> * message,uint32_t * num_bytes,MojoHandle * handles,uint32_t * num_handles,MojoReadMessageFlags flags,bool read_any_size)40 MojoResult Dispatcher::ReadMessage(std::unique_ptr<MessageForTransit>* message,
41 uint32_t* num_bytes,
42 MojoHandle* handles,
43 uint32_t* num_handles,
44 MojoReadMessageFlags flags,
45 bool read_any_size) {
46 return MOJO_RESULT_INVALID_ARGUMENT;
47 }
48
DuplicateBufferHandle(const MojoDuplicateBufferHandleOptions * options,scoped_refptr<Dispatcher> * new_dispatcher)49 MojoResult Dispatcher::DuplicateBufferHandle(
50 const MojoDuplicateBufferHandleOptions* options,
51 scoped_refptr<Dispatcher>* new_dispatcher) {
52 return MOJO_RESULT_INVALID_ARGUMENT;
53 }
54
MapBuffer(uint64_t offset,uint64_t num_bytes,MojoMapBufferFlags flags,std::unique_ptr<PlatformSharedBufferMapping> * mapping)55 MojoResult Dispatcher::MapBuffer(
56 uint64_t offset,
57 uint64_t num_bytes,
58 MojoMapBufferFlags flags,
59 std::unique_ptr<PlatformSharedBufferMapping>* mapping) {
60 return MOJO_RESULT_INVALID_ARGUMENT;
61 }
62
ReadData(void * elements,uint32_t * num_bytes,MojoReadDataFlags flags)63 MojoResult Dispatcher::ReadData(void* elements,
64 uint32_t* num_bytes,
65 MojoReadDataFlags flags) {
66 return MOJO_RESULT_INVALID_ARGUMENT;
67 }
68
BeginReadData(const void ** buffer,uint32_t * buffer_num_bytes,MojoReadDataFlags flags)69 MojoResult Dispatcher::BeginReadData(const void** buffer,
70 uint32_t* buffer_num_bytes,
71 MojoReadDataFlags flags) {
72 return MOJO_RESULT_INVALID_ARGUMENT;
73 }
74
EndReadData(uint32_t num_bytes_read)75 MojoResult Dispatcher::EndReadData(uint32_t num_bytes_read) {
76 return MOJO_RESULT_INVALID_ARGUMENT;
77 }
78
WriteData(const void * elements,uint32_t * num_bytes,MojoWriteDataFlags flags)79 MojoResult Dispatcher::WriteData(const void* elements,
80 uint32_t* num_bytes,
81 MojoWriteDataFlags flags) {
82 return MOJO_RESULT_INVALID_ARGUMENT;
83 }
84
BeginWriteData(void ** buffer,uint32_t * buffer_num_bytes,MojoWriteDataFlags flags)85 MojoResult Dispatcher::BeginWriteData(void** buffer,
86 uint32_t* buffer_num_bytes,
87 MojoWriteDataFlags flags) {
88 return MOJO_RESULT_INVALID_ARGUMENT;
89 }
90
EndWriteData(uint32_t num_bytes_written)91 MojoResult Dispatcher::EndWriteData(uint32_t num_bytes_written) {
92 return MOJO_RESULT_INVALID_ARGUMENT;
93 }
94
AddWaitingDispatcher(const scoped_refptr<Dispatcher> & dispatcher,MojoHandleSignals signals,uintptr_t context)95 MojoResult Dispatcher::AddWaitingDispatcher(
96 const scoped_refptr<Dispatcher>& dispatcher,
97 MojoHandleSignals signals,
98 uintptr_t context) {
99 return MOJO_RESULT_INVALID_ARGUMENT;
100 }
101
RemoveWaitingDispatcher(const scoped_refptr<Dispatcher> & dispatcher)102 MojoResult Dispatcher::RemoveWaitingDispatcher(
103 const scoped_refptr<Dispatcher>& dispatcher) {
104 return MOJO_RESULT_INVALID_ARGUMENT;
105 }
106
GetReadyDispatchers(uint32_t * count,DispatcherVector * dispatchers,MojoResult * results,uintptr_t * contexts)107 MojoResult Dispatcher::GetReadyDispatchers(uint32_t* count,
108 DispatcherVector* dispatchers,
109 MojoResult* results,
110 uintptr_t* contexts) {
111 return MOJO_RESULT_INVALID_ARGUMENT;
112 }
113
GetHandleSignalsState() const114 HandleSignalsState Dispatcher::GetHandleSignalsState() const {
115 return HandleSignalsState();
116 }
117
AddAwakable(Awakable * awakable,MojoHandleSignals signals,uintptr_t context,HandleSignalsState * signals_state)118 MojoResult Dispatcher::AddAwakable(Awakable* awakable,
119 MojoHandleSignals signals,
120 uintptr_t context,
121 HandleSignalsState* signals_state) {
122 return MOJO_RESULT_INVALID_ARGUMENT;
123 }
124
RemoveAwakable(Awakable * awakable,HandleSignalsState * handle_signals_state)125 void Dispatcher::RemoveAwakable(Awakable* awakable,
126 HandleSignalsState* handle_signals_state) {
127 NOTREACHED();
128 }
129
StartSerialize(uint32_t * num_bytes,uint32_t * num_ports,uint32_t * num_platform_handles)130 void Dispatcher::StartSerialize(uint32_t* num_bytes,
131 uint32_t* num_ports,
132 uint32_t* num_platform_handles) {
133 *num_bytes = 0;
134 *num_ports = 0;
135 *num_platform_handles = 0;
136 }
137
EndSerialize(void * destination,ports::PortName * ports,PlatformHandle * handles)138 bool Dispatcher::EndSerialize(void* destination,
139 ports::PortName* ports,
140 PlatformHandle* handles) {
141 LOG(ERROR) << "Attempting to serialize a non-transferrable dispatcher.";
142 return true;
143 }
144
BeginTransit()145 bool Dispatcher::BeginTransit() { return true; }
146
CompleteTransitAndClose()147 void Dispatcher::CompleteTransitAndClose() {}
148
CancelTransit()149 void Dispatcher::CancelTransit() {}
150
151 // static
Deserialize(Type type,const void * bytes,size_t num_bytes,const ports::PortName * ports,size_t num_ports,PlatformHandle * platform_handles,size_t num_platform_handles)152 scoped_refptr<Dispatcher> Dispatcher::Deserialize(
153 Type type,
154 const void* bytes,
155 size_t num_bytes,
156 const ports::PortName* ports,
157 size_t num_ports,
158 PlatformHandle* platform_handles,
159 size_t num_platform_handles) {
160 switch (type) {
161 case Type::MESSAGE_PIPE:
162 return MessagePipeDispatcher::Deserialize(
163 bytes, num_bytes, ports, num_ports, platform_handles,
164 num_platform_handles);
165 case Type::SHARED_BUFFER:
166 return SharedBufferDispatcher::Deserialize(
167 bytes, num_bytes, ports, num_ports, platform_handles,
168 num_platform_handles);
169 case Type::DATA_PIPE_CONSUMER:
170 return DataPipeConsumerDispatcher::Deserialize(
171 bytes, num_bytes, ports, num_ports, platform_handles,
172 num_platform_handles);
173 case Type::DATA_PIPE_PRODUCER:
174 return DataPipeProducerDispatcher::Deserialize(
175 bytes, num_bytes, ports, num_ports, platform_handles,
176 num_platform_handles);
177 case Type::PLATFORM_HANDLE:
178 return PlatformHandleDispatcher::Deserialize(
179 bytes, num_bytes, ports, num_ports, platform_handles,
180 num_platform_handles);
181 default:
182 LOG(ERROR) << "Deserializing invalid dispatcher type.";
183 return nullptr;
184 }
185 }
186
Dispatcher()187 Dispatcher::Dispatcher() {}
188
~Dispatcher()189 Dispatcher::~Dispatcher() {}
190
191 } // namespace edk
192 } // namespace mojo
193