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