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.
5 #ifndef MOJO_SYSTEM_CORE_H_
6 #define MOJO_SYSTEM_CORE_H_
10 #include "base/macros.h"
11 #include "base/memory/ref_counted.h"
12 #include "base/memory/scoped_ptr.h"
13 #include "base/synchronization/lock.h"
14 #include "mojo/public/c/system/buffer.h"
15 #include "mojo/public/c/system/data_pipe.h"
16 #include "mojo/public/c/system/message_pipe.h"
17 #include "mojo/public/c/system/types.h"
18 #include "mojo/system/handle_table.h"
19 #include "mojo/system/mapping_table.h"
20 #include "mojo/system/memory.h"
21 #include "mojo/system/system_impl_export.h"
26 class PlatformSupport;
32 struct HandleSignalsState;
34 // |Core| is an object that implements the Mojo system calls. All public methods
36 class MOJO_SYSTEM_IMPL_EXPORT Core {
38 // ---------------------------------------------------------------------------
40 // These methods are only to be used by via the embedder API (and internally):
41 explicit Core(scoped_ptr<embedder::PlatformSupport> platform_support);
44 // Adds |dispatcher| to the handle table, returning the handle for it. Returns
45 // |MOJO_HANDLE_INVALID| on failure, namely if the handle table is full.
46 MojoHandle AddDispatcher(const scoped_refptr<Dispatcher>& dispatcher);
48 // Looks up the dispatcher for the given handle. Returns null if the handle is
50 scoped_refptr<Dispatcher> GetDispatcher(MojoHandle handle);
52 embedder::PlatformSupport* platform_support() const {
53 return platform_support_.get();
56 // ---------------------------------------------------------------------------
58 // System calls implementation:
59 MojoTimeTicks GetTimeTicksNow();
60 MojoResult Close(MojoHandle handle);
61 MojoResult Wait(MojoHandle handle,
62 MojoHandleSignals signals,
63 MojoDeadline deadline,
64 UserPointer<MojoHandleSignalsState> signals_state);
65 MojoResult WaitMany(UserPointer<const MojoHandle> handles,
66 UserPointer<const MojoHandleSignals> signals,
68 MojoDeadline deadline,
69 UserPointer<uint32_t> result_index,
70 UserPointer<MojoHandleSignalsState> signals_states);
71 MojoResult CreateMessagePipe(
72 UserPointer<const MojoCreateMessagePipeOptions> options,
73 UserPointer<MojoHandle> message_pipe_handle0,
74 UserPointer<MojoHandle> message_pipe_handle1);
75 MojoResult WriteMessage(MojoHandle message_pipe_handle,
76 UserPointer<const void> bytes,
78 UserPointer<const MojoHandle> handles,
80 MojoWriteMessageFlags flags);
81 MojoResult ReadMessage(MojoHandle message_pipe_handle,
82 UserPointer<void> bytes,
83 UserPointer<uint32_t> num_bytes,
84 UserPointer<MojoHandle> handles,
85 UserPointer<uint32_t> num_handles,
86 MojoReadMessageFlags flags);
87 MojoResult CreateDataPipe(
88 UserPointer<const MojoCreateDataPipeOptions> options,
89 UserPointer<MojoHandle> data_pipe_producer_handle,
90 UserPointer<MojoHandle> data_pipe_consumer_handle);
91 MojoResult WriteData(MojoHandle data_pipe_producer_handle,
92 UserPointer<const void> elements,
93 UserPointer<uint32_t> num_bytes,
94 MojoWriteDataFlags flags);
95 MojoResult BeginWriteData(MojoHandle data_pipe_producer_handle,
96 UserPointer<void*> buffer,
97 UserPointer<uint32_t> buffer_num_bytes,
98 MojoWriteDataFlags flags);
99 MojoResult EndWriteData(MojoHandle data_pipe_producer_handle,
100 uint32_t num_bytes_written);
101 MojoResult ReadData(MojoHandle data_pipe_consumer_handle,
102 UserPointer<void> elements,
103 UserPointer<uint32_t> num_bytes,
104 MojoReadDataFlags flags);
105 MojoResult BeginReadData(MojoHandle data_pipe_consumer_handle,
106 UserPointer<const void*> buffer,
107 UserPointer<uint32_t> buffer_num_bytes,
108 MojoReadDataFlags flags);
109 MojoResult EndReadData(MojoHandle data_pipe_consumer_handle,
110 uint32_t num_bytes_read);
111 MojoResult CreateSharedBuffer(
112 UserPointer<const MojoCreateSharedBufferOptions> options,
114 UserPointer<MojoHandle> shared_buffer_handle);
115 MojoResult DuplicateBufferHandle(
116 MojoHandle buffer_handle,
117 UserPointer<const MojoDuplicateBufferHandleOptions> options,
118 UserPointer<MojoHandle> new_buffer_handle);
119 MojoResult MapBuffer(MojoHandle buffer_handle,
122 UserPointer<void*> buffer,
123 MojoMapBufferFlags flags);
124 MojoResult UnmapBuffer(UserPointer<void> buffer);
127 friend bool internal::ShutdownCheckNoLeaks(Core*);
129 // Internal implementation of |Wait()| and |WaitMany()|; doesn't do basic
130 // validation of arguments. |*result_index| is only set if the result (whether
131 // success or failure) applies to a specific handle, so its value should be
132 // preinitialized to |static_cast<uint32_t>(-1)|.
133 MojoResult WaitManyInternal(const MojoHandle* handles,
134 const MojoHandleSignals* signals,
135 uint32_t num_handles,
136 MojoDeadline deadline,
137 uint32_t* result_index,
138 HandleSignalsState* signals_states);
140 const scoped_ptr<embedder::PlatformSupport> platform_support_;
142 // TODO(vtl): |handle_table_lock_| should be a reader-writer lock (if only we
144 base::Lock handle_table_lock_; // Protects |handle_table_|.
145 HandleTable handle_table_;
147 base::Lock mapping_table_lock_; // Protects |mapping_table_|.
148 MappingTable mapping_table_;
150 DISALLOW_COPY_AND_ASSIGN(Core);
153 } // namespace system
156 #endif // MOJO_SYSTEM_CORE_H_