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 15namespace mojo { 16namespace edk { 17 18Dispatcher::DispatcherInTransit::DispatcherInTransit() {} 19 20Dispatcher::DispatcherInTransit::DispatcherInTransit( 21 const DispatcherInTransit& other) = default; 22 23Dispatcher::DispatcherInTransit::~DispatcherInTransit() {} 24 25MojoResult Dispatcher::Watch(MojoHandleSignals signals, 26 const Watcher::WatchCallback& callback, 27 uintptr_t context) { 28 return MOJO_RESULT_INVALID_ARGUMENT; 29} 30 31MojoResult Dispatcher::CancelWatch(uintptr_t context) { 32 return MOJO_RESULT_INVALID_ARGUMENT; 33} 34 35MojoResult Dispatcher::WriteMessage(std::unique_ptr<MessageForTransit> message, 36 MojoWriteMessageFlags flags) { 37 return MOJO_RESULT_INVALID_ARGUMENT; 38} 39 40MojoResult 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 49MojoResult Dispatcher::DuplicateBufferHandle( 50 const MojoDuplicateBufferHandleOptions* options, 51 scoped_refptr<Dispatcher>* new_dispatcher) { 52 return MOJO_RESULT_INVALID_ARGUMENT; 53} 54 55MojoResult 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 63MojoResult Dispatcher::ReadData(void* elements, 64 uint32_t* num_bytes, 65 MojoReadDataFlags flags) { 66 return MOJO_RESULT_INVALID_ARGUMENT; 67} 68 69MojoResult Dispatcher::BeginReadData(const void** buffer, 70 uint32_t* buffer_num_bytes, 71 MojoReadDataFlags flags) { 72 return MOJO_RESULT_INVALID_ARGUMENT; 73} 74 75MojoResult Dispatcher::EndReadData(uint32_t num_bytes_read) { 76 return MOJO_RESULT_INVALID_ARGUMENT; 77} 78 79MojoResult Dispatcher::WriteData(const void* elements, 80 uint32_t* num_bytes, 81 MojoWriteDataFlags flags) { 82 return MOJO_RESULT_INVALID_ARGUMENT; 83} 84 85MojoResult Dispatcher::BeginWriteData(void** buffer, 86 uint32_t* buffer_num_bytes, 87 MojoWriteDataFlags flags) { 88 return MOJO_RESULT_INVALID_ARGUMENT; 89} 90 91MojoResult Dispatcher::EndWriteData(uint32_t num_bytes_written) { 92 return MOJO_RESULT_INVALID_ARGUMENT; 93} 94 95MojoResult Dispatcher::AddWaitingDispatcher( 96 const scoped_refptr<Dispatcher>& dispatcher, 97 MojoHandleSignals signals, 98 uintptr_t context) { 99 return MOJO_RESULT_INVALID_ARGUMENT; 100} 101 102MojoResult Dispatcher::RemoveWaitingDispatcher( 103 const scoped_refptr<Dispatcher>& dispatcher) { 104 return MOJO_RESULT_INVALID_ARGUMENT; 105} 106 107MojoResult Dispatcher::GetReadyDispatchers(uint32_t* count, 108 DispatcherVector* dispatchers, 109 MojoResult* results, 110 uintptr_t* contexts) { 111 return MOJO_RESULT_INVALID_ARGUMENT; 112} 113 114HandleSignalsState Dispatcher::GetHandleSignalsState() const { 115 return HandleSignalsState(); 116} 117 118MojoResult Dispatcher::AddAwakable(Awakable* awakable, 119 MojoHandleSignals signals, 120 uintptr_t context, 121 HandleSignalsState* signals_state) { 122 return MOJO_RESULT_INVALID_ARGUMENT; 123} 124 125void Dispatcher::RemoveAwakable(Awakable* awakable, 126 HandleSignalsState* handle_signals_state) { 127 NOTREACHED(); 128} 129 130void 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 138bool 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 145bool Dispatcher::BeginTransit() { return true; } 146 147void Dispatcher::CompleteTransitAndClose() {} 148 149void Dispatcher::CancelTransit() {} 150 151// static 152scoped_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 187Dispatcher::Dispatcher() {} 188 189Dispatcher::~Dispatcher() {} 190 191} // namespace edk 192} // namespace mojo 193