OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "mojo/android/system/core_impl.h" | 5 #include "mojo/android/system/core_impl.h" |
6 | 6 |
7 #include "base/android/base_jni_registrar.h" | 7 #include "base/android/base_jni_registrar.h" |
8 #include "base/android/jni_android.h" | 8 #include "base/android/jni_android.h" |
9 #include "base/android/jni_registrar.h" | 9 #include "base/android/jni_registrar.h" |
10 #include "base/android/library_loader/library_loader_hooks.h" | 10 #include "base/android/library_loader/library_loader_hooks.h" |
(...skipping 31 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
42 result, | 42 result, |
43 callback_data->callback.obj(), | 43 callback_data->callback.obj(), |
44 callback_data->cancellable.obj()); | 44 callback_data->cancellable.obj()); |
45 } | 45 } |
46 | 46 |
47 } // namespace | 47 } // namespace |
48 | 48 |
49 namespace mojo { | 49 namespace mojo { |
50 namespace android { | 50 namespace android { |
51 | 51 |
52 static jlong GetTimeTicksNow(JNIEnv* env, jobject jcaller) { | 52 static jlong GetTimeTicksNow(JNIEnv* env, |
| 53 const JavaParamRef<jobject>& jcaller) { |
53 return MojoGetTimeTicksNow(); | 54 return MojoGetTimeTicksNow(); |
54 } | 55 } |
55 | 56 |
56 static jint WaitMany(JNIEnv* env, | 57 static jint WaitMany(JNIEnv* env, |
57 jobject jcaller, | 58 const JavaParamRef<jobject>& jcaller, |
58 jobject buffer, | 59 const JavaParamRef<jobject>& buffer, |
59 jlong deadline) { | 60 jlong deadline) { |
60 // |buffer| contains, in this order | 61 // |buffer| contains, in this order |
61 // input: The array of N handles (MojoHandle, 4 bytes each) | 62 // input: The array of N handles (MojoHandle, 4 bytes each) |
62 // input: The array of N signals (MojoHandleSignals, 4 bytes each) | 63 // input: The array of N signals (MojoHandleSignals, 4 bytes each) |
63 // space for output: The array of N handle states (MojoHandleSignalsState, 8 | 64 // space for output: The array of N handle states (MojoHandleSignalsState, 8 |
64 // bytes each) | 65 // bytes each) |
65 // space for output: The result index (uint32_t, 4 bytes) | 66 // space for output: The result index (uint32_t, 4 bytes) |
66 uint8_t* buffer_start = | 67 uint8_t* buffer_start = |
67 static_cast<uint8_t*>(env->GetDirectBufferAddress(buffer)); | 68 static_cast<uint8_t*>(env->GetDirectBufferAddress(buffer)); |
68 DCHECK(buffer_start); | 69 DCHECK(buffer_start); |
(...skipping 12 matching lines...) Expand all Loading... |
81 reinterpret_cast<const MojoHandleSignals*>(buffer_start + 4 * nb_handles); | 82 reinterpret_cast<const MojoHandleSignals*>(buffer_start + 4 * nb_handles); |
82 MojoHandleSignalsState* states_start = | 83 MojoHandleSignalsState* states_start = |
83 reinterpret_cast<MojoHandleSignalsState*>(buffer_start + 8 * nb_handles); | 84 reinterpret_cast<MojoHandleSignalsState*>(buffer_start + 8 * nb_handles); |
84 uint32_t* result_index = | 85 uint32_t* result_index = |
85 reinterpret_cast<uint32_t*>(buffer_start + 16 * nb_handles); | 86 reinterpret_cast<uint32_t*>(buffer_start + 16 * nb_handles); |
86 *result_index = static_cast<uint32_t>(-1); | 87 *result_index = static_cast<uint32_t>(-1); |
87 return MojoWaitMany(handle_start, signals_start, nb_handles, deadline, | 88 return MojoWaitMany(handle_start, signals_start, nb_handles, deadline, |
88 result_index, states_start); | 89 result_index, states_start); |
89 } | 90 } |
90 | 91 |
91 static ScopedJavaLocalRef<jobject> CreateMessagePipe(JNIEnv* env, | 92 static ScopedJavaLocalRef<jobject> CreateMessagePipe( |
92 jobject jcaller, | 93 JNIEnv* env, |
93 jobject options_buffer) { | 94 const JavaParamRef<jobject>& jcaller, |
| 95 const JavaParamRef<jobject>& options_buffer) { |
94 const MojoCreateMessagePipeOptions* options = NULL; | 96 const MojoCreateMessagePipeOptions* options = NULL; |
95 if (options_buffer) { | 97 if (options_buffer) { |
96 const void* buffer_start = env->GetDirectBufferAddress(options_buffer); | 98 const void* buffer_start = env->GetDirectBufferAddress(options_buffer); |
97 DCHECK(buffer_start); | 99 DCHECK(buffer_start); |
98 DCHECK_EQ(reinterpret_cast<const uintptr_t>(buffer_start) % 8, 0u); | 100 DCHECK_EQ(reinterpret_cast<const uintptr_t>(buffer_start) % 8, 0u); |
99 const size_t buffer_size = env->GetDirectBufferCapacity(options_buffer); | 101 const size_t buffer_size = env->GetDirectBufferCapacity(options_buffer); |
100 DCHECK_EQ(buffer_size, sizeof(MojoCreateMessagePipeOptions)); | 102 DCHECK_EQ(buffer_size, sizeof(MojoCreateMessagePipeOptions)); |
101 options = static_cast<const MojoCreateMessagePipeOptions*>(buffer_start); | 103 options = static_cast<const MojoCreateMessagePipeOptions*>(buffer_start); |
102 DCHECK_EQ(options->struct_size, buffer_size); | 104 DCHECK_EQ(options->struct_size, buffer_size); |
103 } | 105 } |
104 MojoHandle handle1; | 106 MojoHandle handle1; |
105 MojoHandle handle2; | 107 MojoHandle handle2; |
106 MojoResult result = MojoCreateMessagePipe(options, &handle1, &handle2); | 108 MojoResult result = MojoCreateMessagePipe(options, &handle1, &handle2); |
107 return Java_CoreImpl_newNativeCreationResult(env, result, handle1, handle2); | 109 return Java_CoreImpl_newNativeCreationResult(env, result, handle1, handle2); |
108 } | 110 } |
109 | 111 |
110 static ScopedJavaLocalRef<jobject> CreateDataPipe(JNIEnv* env, | 112 static ScopedJavaLocalRef<jobject> CreateDataPipe( |
111 jobject jcaller, | 113 JNIEnv* env, |
112 jobject options_buffer) { | 114 const JavaParamRef<jobject>& jcaller, |
| 115 const JavaParamRef<jobject>& options_buffer) { |
113 const MojoCreateDataPipeOptions* options = NULL; | 116 const MojoCreateDataPipeOptions* options = NULL; |
114 if (options_buffer) { | 117 if (options_buffer) { |
115 const void* buffer_start = env->GetDirectBufferAddress(options_buffer); | 118 const void* buffer_start = env->GetDirectBufferAddress(options_buffer); |
116 DCHECK(buffer_start); | 119 DCHECK(buffer_start); |
117 DCHECK_EQ(reinterpret_cast<const uintptr_t>(buffer_start) % 8, 0u); | 120 DCHECK_EQ(reinterpret_cast<const uintptr_t>(buffer_start) % 8, 0u); |
118 const size_t buffer_size = env->GetDirectBufferCapacity(options_buffer); | 121 const size_t buffer_size = env->GetDirectBufferCapacity(options_buffer); |
119 DCHECK_EQ(buffer_size, sizeof(MojoCreateDataPipeOptions)); | 122 DCHECK_EQ(buffer_size, sizeof(MojoCreateDataPipeOptions)); |
120 options = static_cast<const MojoCreateDataPipeOptions*>(buffer_start); | 123 options = static_cast<const MojoCreateDataPipeOptions*>(buffer_start); |
121 DCHECK_EQ(options->struct_size, buffer_size); | 124 DCHECK_EQ(options->struct_size, buffer_size); |
122 } | 125 } |
123 MojoHandle handle1; | 126 MojoHandle handle1; |
124 MojoHandle handle2; | 127 MojoHandle handle2; |
125 MojoResult result = MojoCreateDataPipe(options, &handle1, &handle2); | 128 MojoResult result = MojoCreateDataPipe(options, &handle1, &handle2); |
126 return Java_CoreImpl_newNativeCreationResult(env, result, handle1, handle2); | 129 return Java_CoreImpl_newNativeCreationResult(env, result, handle1, handle2); |
127 } | 130 } |
128 | 131 |
129 static ScopedJavaLocalRef<jobject> CreateSharedBuffer(JNIEnv* env, | 132 static ScopedJavaLocalRef<jobject> CreateSharedBuffer( |
130 jobject jcaller, | 133 JNIEnv* env, |
131 jobject options_buffer, | 134 const JavaParamRef<jobject>& jcaller, |
132 jlong num_bytes) { | 135 const JavaParamRef<jobject>& options_buffer, |
| 136 jlong num_bytes) { |
133 const MojoCreateSharedBufferOptions* options = 0; | 137 const MojoCreateSharedBufferOptions* options = 0; |
134 if (options_buffer) { | 138 if (options_buffer) { |
135 const void* buffer_start = env->GetDirectBufferAddress(options_buffer); | 139 const void* buffer_start = env->GetDirectBufferAddress(options_buffer); |
136 DCHECK(buffer_start); | 140 DCHECK(buffer_start); |
137 DCHECK_EQ(reinterpret_cast<const uintptr_t>(buffer_start) % 8, 0u); | 141 DCHECK_EQ(reinterpret_cast<const uintptr_t>(buffer_start) % 8, 0u); |
138 const size_t buffer_size = env->GetDirectBufferCapacity(options_buffer); | 142 const size_t buffer_size = env->GetDirectBufferCapacity(options_buffer); |
139 DCHECK_EQ(buffer_size, sizeof(MojoCreateSharedBufferOptions)); | 143 DCHECK_EQ(buffer_size, sizeof(MojoCreateSharedBufferOptions)); |
140 options = static_cast<const MojoCreateSharedBufferOptions*>(buffer_start); | 144 options = static_cast<const MojoCreateSharedBufferOptions*>(buffer_start); |
141 DCHECK_EQ(options->struct_size, buffer_size); | 145 DCHECK_EQ(options->struct_size, buffer_size); |
142 } | 146 } |
143 MojoHandle handle; | 147 MojoHandle handle; |
144 MojoResult result = MojoCreateSharedBuffer(options, num_bytes, &handle); | 148 MojoResult result = MojoCreateSharedBuffer(options, num_bytes, &handle); |
145 return Java_CoreImpl_newResultAndInteger(env, result, handle); | 149 return Java_CoreImpl_newResultAndInteger(env, result, handle); |
146 } | 150 } |
147 | 151 |
148 static jint Close(JNIEnv* env, jobject jcaller, jint mojo_handle) { | 152 static jint Close(JNIEnv* env, |
| 153 const JavaParamRef<jobject>& jcaller, |
| 154 jint mojo_handle) { |
149 return MojoClose(mojo_handle); | 155 return MojoClose(mojo_handle); |
150 } | 156 } |
151 | 157 |
152 static jint Wait(JNIEnv* env, | 158 static jint Wait(JNIEnv* env, |
153 jobject jcaller, | 159 const JavaParamRef<jobject>& jcaller, |
154 jobject buffer, | 160 const JavaParamRef<jobject>& buffer, |
155 jint mojo_handle, | 161 jint mojo_handle, |
156 jint signals, | 162 jint signals, |
157 jlong deadline) { | 163 jlong deadline) { |
158 // Buffer contains space for the MojoHandleSignalsState | 164 // Buffer contains space for the MojoHandleSignalsState |
159 void* buffer_start = env->GetDirectBufferAddress(buffer); | 165 void* buffer_start = env->GetDirectBufferAddress(buffer); |
160 DCHECK(buffer_start); | 166 DCHECK(buffer_start); |
161 DCHECK_EQ(reinterpret_cast<const uintptr_t>(buffer_start) % 8, 0u); | 167 DCHECK_EQ(reinterpret_cast<const uintptr_t>(buffer_start) % 8, 0u); |
162 DCHECK_EQ(sizeof(struct MojoHandleSignalsState), | 168 DCHECK_EQ(sizeof(struct MojoHandleSignalsState), |
163 static_cast<size_t>(env->GetDirectBufferCapacity(buffer))); | 169 static_cast<size_t>(env->GetDirectBufferCapacity(buffer))); |
164 struct MojoHandleSignalsState* signals_state = | 170 struct MojoHandleSignalsState* signals_state = |
165 static_cast<struct MojoHandleSignalsState*>(buffer_start); | 171 static_cast<struct MojoHandleSignalsState*>(buffer_start); |
166 return MojoWait(mojo_handle, signals, deadline, signals_state); | 172 return MojoWait(mojo_handle, signals, deadline, signals_state); |
167 } | 173 } |
168 | 174 |
169 static jint WriteMessage(JNIEnv* env, | 175 static jint WriteMessage(JNIEnv* env, |
170 jobject jcaller, | 176 const JavaParamRef<jobject>& jcaller, |
171 jint mojo_handle, | 177 jint mojo_handle, |
172 jobject bytes, | 178 const JavaParamRef<jobject>& bytes, |
173 jint num_bytes, | 179 jint num_bytes, |
174 jobject handles_buffer, | 180 const JavaParamRef<jobject>& handles_buffer, |
175 jint flags) { | 181 jint flags) { |
176 const void* buffer_start = 0; | 182 const void* buffer_start = 0; |
177 uint32_t buffer_size = 0; | 183 uint32_t buffer_size = 0; |
178 if (bytes) { | 184 if (bytes) { |
179 buffer_start = env->GetDirectBufferAddress(bytes); | 185 buffer_start = env->GetDirectBufferAddress(bytes); |
180 DCHECK(buffer_start); | 186 DCHECK(buffer_start); |
181 DCHECK(env->GetDirectBufferCapacity(bytes) >= num_bytes); | 187 DCHECK(env->GetDirectBufferCapacity(bytes) >= num_bytes); |
182 buffer_size = num_bytes; | 188 buffer_size = num_bytes; |
183 } | 189 } |
184 const MojoHandle* handles = 0; | 190 const MojoHandle* handles = 0; |
185 uint32_t num_handles = 0; | 191 uint32_t num_handles = 0; |
186 if (handles_buffer) { | 192 if (handles_buffer) { |
187 handles = | 193 handles = |
188 static_cast<MojoHandle*>(env->GetDirectBufferAddress(handles_buffer)); | 194 static_cast<MojoHandle*>(env->GetDirectBufferAddress(handles_buffer)); |
189 num_handles = env->GetDirectBufferCapacity(handles_buffer) / 4; | 195 num_handles = env->GetDirectBufferCapacity(handles_buffer) / 4; |
190 } | 196 } |
191 // Java code will handle invalidating handles if the write succeeded. | 197 // Java code will handle invalidating handles if the write succeeded. |
192 return MojoWriteMessage( | 198 return MojoWriteMessage( |
193 mojo_handle, buffer_start, buffer_size, handles, num_handles, flags); | 199 mojo_handle, buffer_start, buffer_size, handles, num_handles, flags); |
194 } | 200 } |
195 | 201 |
196 static ScopedJavaLocalRef<jobject> ReadMessage(JNIEnv* env, | 202 static ScopedJavaLocalRef<jobject> ReadMessage( |
197 jobject jcaller, | 203 JNIEnv* env, |
198 jint mojo_handle, | 204 const JavaParamRef<jobject>& jcaller, |
199 jobject bytes, | 205 jint mojo_handle, |
200 jobject handles_buffer, | 206 const JavaParamRef<jobject>& bytes, |
201 jint flags) { | 207 const JavaParamRef<jobject>& handles_buffer, |
| 208 jint flags) { |
202 void* buffer_start = 0; | 209 void* buffer_start = 0; |
203 uint32_t buffer_size = 0; | 210 uint32_t buffer_size = 0; |
204 if (bytes) { | 211 if (bytes) { |
205 buffer_start = env->GetDirectBufferAddress(bytes); | 212 buffer_start = env->GetDirectBufferAddress(bytes); |
206 DCHECK(buffer_start); | 213 DCHECK(buffer_start); |
207 buffer_size = env->GetDirectBufferCapacity(bytes); | 214 buffer_size = env->GetDirectBufferCapacity(bytes); |
208 } | 215 } |
209 MojoHandle* handles = 0; | 216 MojoHandle* handles = 0; |
210 uint32_t num_handles = 0; | 217 uint32_t num_handles = 0; |
211 if (handles_buffer) { | 218 if (handles_buffer) { |
212 handles = | 219 handles = |
213 static_cast<MojoHandle*>(env->GetDirectBufferAddress(handles_buffer)); | 220 static_cast<MojoHandle*>(env->GetDirectBufferAddress(handles_buffer)); |
214 num_handles = env->GetDirectBufferCapacity(handles_buffer) / 4; | 221 num_handles = env->GetDirectBufferCapacity(handles_buffer) / 4; |
215 } | 222 } |
216 MojoResult result = MojoReadMessage( | 223 MojoResult result = MojoReadMessage( |
217 mojo_handle, buffer_start, &buffer_size, handles, &num_handles, flags); | 224 mojo_handle, buffer_start, &buffer_size, handles, &num_handles, flags); |
218 // Jave code will handle taking ownership of any received handle. | 225 // Jave code will handle taking ownership of any received handle. |
219 return Java_CoreImpl_newReadMessageResult(env, result, buffer_size, | 226 return Java_CoreImpl_newReadMessageResult(env, result, buffer_size, |
220 num_handles); | 227 num_handles); |
221 } | 228 } |
222 | 229 |
223 static ScopedJavaLocalRef<jobject> ReadData(JNIEnv* env, | 230 static ScopedJavaLocalRef<jobject> ReadData( |
224 jobject jcaller, | 231 JNIEnv* env, |
225 jint mojo_handle, | 232 const JavaParamRef<jobject>& jcaller, |
226 jobject elements, | 233 jint mojo_handle, |
227 jint elements_capacity, | 234 const JavaParamRef<jobject>& elements, |
228 jint flags) { | 235 jint elements_capacity, |
| 236 jint flags) { |
229 void* buffer_start = 0; | 237 void* buffer_start = 0; |
230 uint32_t buffer_size = elements_capacity; | 238 uint32_t buffer_size = elements_capacity; |
231 if (elements) { | 239 if (elements) { |
232 buffer_start = env->GetDirectBufferAddress(elements); | 240 buffer_start = env->GetDirectBufferAddress(elements); |
233 DCHECK(buffer_start); | 241 DCHECK(buffer_start); |
234 DCHECK(elements_capacity <= env->GetDirectBufferCapacity(elements)); | 242 DCHECK(elements_capacity <= env->GetDirectBufferCapacity(elements)); |
235 } | 243 } |
236 MojoResult result = | 244 MojoResult result = |
237 MojoReadData(mojo_handle, buffer_start, &buffer_size, flags); | 245 MojoReadData(mojo_handle, buffer_start, &buffer_size, flags); |
238 return Java_CoreImpl_newResultAndInteger( | 246 return Java_CoreImpl_newResultAndInteger( |
239 env, result, (result == MOJO_RESULT_OK) ? buffer_size : 0); | 247 env, result, (result == MOJO_RESULT_OK) ? buffer_size : 0); |
240 } | 248 } |
241 | 249 |
242 static ScopedJavaLocalRef<jobject> BeginReadData(JNIEnv* env, | 250 static ScopedJavaLocalRef<jobject> BeginReadData( |
243 jobject jcaller, | 251 JNIEnv* env, |
244 jint mojo_handle, | 252 const JavaParamRef<jobject>& jcaller, |
245 jint num_bytes, | 253 jint mojo_handle, |
246 jint flags) { | 254 jint num_bytes, |
| 255 jint flags) { |
247 void const* buffer = 0; | 256 void const* buffer = 0; |
248 uint32_t buffer_size = num_bytes; | 257 uint32_t buffer_size = num_bytes; |
249 MojoResult result = | 258 MojoResult result = |
250 MojoBeginReadData(mojo_handle, &buffer, &buffer_size, flags); | 259 MojoBeginReadData(mojo_handle, &buffer, &buffer_size, flags); |
251 jobject byte_buffer = 0; | 260 jobject byte_buffer = 0; |
252 if (result == MOJO_RESULT_OK) { | 261 if (result == MOJO_RESULT_OK) { |
253 byte_buffer = | 262 byte_buffer = |
254 env->NewDirectByteBuffer(const_cast<void*>(buffer), buffer_size); | 263 env->NewDirectByteBuffer(const_cast<void*>(buffer), buffer_size); |
255 } | 264 } |
256 return Java_CoreImpl_newResultAndBuffer(env, result, byte_buffer); | 265 return Java_CoreImpl_newResultAndBuffer(env, result, byte_buffer); |
257 } | 266 } |
258 | 267 |
259 static jint EndReadData(JNIEnv* env, | 268 static jint EndReadData(JNIEnv* env, |
260 jobject jcaller, | 269 const JavaParamRef<jobject>& jcaller, |
261 jint mojo_handle, | 270 jint mojo_handle, |
262 jint num_bytes_read) { | 271 jint num_bytes_read) { |
263 return MojoEndReadData(mojo_handle, num_bytes_read); | 272 return MojoEndReadData(mojo_handle, num_bytes_read); |
264 } | 273 } |
265 | 274 |
266 static ScopedJavaLocalRef<jobject> WriteData(JNIEnv* env, | 275 static ScopedJavaLocalRef<jobject> WriteData( |
267 jobject jcaller, | 276 JNIEnv* env, |
268 jint mojo_handle, | 277 const JavaParamRef<jobject>& jcaller, |
269 jobject elements, | 278 jint mojo_handle, |
270 jint limit, | 279 const JavaParamRef<jobject>& elements, |
271 jint flags) { | 280 jint limit, |
| 281 jint flags) { |
272 void* buffer_start = env->GetDirectBufferAddress(elements); | 282 void* buffer_start = env->GetDirectBufferAddress(elements); |
273 DCHECK(buffer_start); | 283 DCHECK(buffer_start); |
274 DCHECK(limit <= env->GetDirectBufferCapacity(elements)); | 284 DCHECK(limit <= env->GetDirectBufferCapacity(elements)); |
275 uint32_t buffer_size = limit; | 285 uint32_t buffer_size = limit; |
276 MojoResult result = | 286 MojoResult result = |
277 MojoWriteData(mojo_handle, buffer_start, &buffer_size, flags); | 287 MojoWriteData(mojo_handle, buffer_start, &buffer_size, flags); |
278 return Java_CoreImpl_newResultAndInteger( | 288 return Java_CoreImpl_newResultAndInteger( |
279 env, result, (result == MOJO_RESULT_OK) ? buffer_size : 0); | 289 env, result, (result == MOJO_RESULT_OK) ? buffer_size : 0); |
280 } | 290 } |
281 | 291 |
282 static ScopedJavaLocalRef<jobject> BeginWriteData(JNIEnv* env, | 292 static ScopedJavaLocalRef<jobject> BeginWriteData( |
283 jobject jcaller, | 293 JNIEnv* env, |
284 jint mojo_handle, | 294 const JavaParamRef<jobject>& jcaller, |
285 jint num_bytes, | 295 jint mojo_handle, |
286 jint flags) { | 296 jint num_bytes, |
| 297 jint flags) { |
287 void* buffer = 0; | 298 void* buffer = 0; |
288 uint32_t buffer_size = num_bytes; | 299 uint32_t buffer_size = num_bytes; |
289 MojoResult result = | 300 MojoResult result = |
290 MojoBeginWriteData(mojo_handle, &buffer, &buffer_size, flags); | 301 MojoBeginWriteData(mojo_handle, &buffer, &buffer_size, flags); |
291 jobject byte_buffer = 0; | 302 jobject byte_buffer = 0; |
292 if (result == MOJO_RESULT_OK) { | 303 if (result == MOJO_RESULT_OK) { |
293 byte_buffer = env->NewDirectByteBuffer(buffer, buffer_size); | 304 byte_buffer = env->NewDirectByteBuffer(buffer, buffer_size); |
294 } | 305 } |
295 return Java_CoreImpl_newResultAndBuffer(env, result, byte_buffer); | 306 return Java_CoreImpl_newResultAndBuffer(env, result, byte_buffer); |
296 } | 307 } |
297 | 308 |
298 static jint EndWriteData(JNIEnv* env, | 309 static jint EndWriteData(JNIEnv* env, |
299 jobject jcaller, | 310 const JavaParamRef<jobject>& jcaller, |
300 jint mojo_handle, | 311 jint mojo_handle, |
301 jint num_bytes_written) { | 312 jint num_bytes_written) { |
302 return MojoEndWriteData(mojo_handle, num_bytes_written); | 313 return MojoEndWriteData(mojo_handle, num_bytes_written); |
303 } | 314 } |
304 | 315 |
305 static ScopedJavaLocalRef<jobject> Duplicate(JNIEnv* env, | 316 static ScopedJavaLocalRef<jobject> Duplicate( |
306 jobject jcaller, | 317 JNIEnv* env, |
307 jint mojo_handle, | 318 const JavaParamRef<jobject>& jcaller, |
308 jobject options_buffer) { | 319 jint mojo_handle, |
| 320 const JavaParamRef<jobject>& options_buffer) { |
309 const MojoDuplicateBufferHandleOptions* options = 0; | 321 const MojoDuplicateBufferHandleOptions* options = 0; |
310 if (options_buffer) { | 322 if (options_buffer) { |
311 const void* buffer_start = env->GetDirectBufferAddress(options_buffer); | 323 const void* buffer_start = env->GetDirectBufferAddress(options_buffer); |
312 DCHECK(buffer_start); | 324 DCHECK(buffer_start); |
313 const size_t buffer_size = env->GetDirectBufferCapacity(options_buffer); | 325 const size_t buffer_size = env->GetDirectBufferCapacity(options_buffer); |
314 DCHECK_EQ(buffer_size, sizeof(MojoDuplicateBufferHandleOptions)); | 326 DCHECK_EQ(buffer_size, sizeof(MojoDuplicateBufferHandleOptions)); |
315 options = | 327 options = |
316 static_cast<const MojoDuplicateBufferHandleOptions*>(buffer_start); | 328 static_cast<const MojoDuplicateBufferHandleOptions*>(buffer_start); |
317 DCHECK_EQ(options->struct_size, buffer_size); | 329 DCHECK_EQ(options->struct_size, buffer_size); |
318 } | 330 } |
319 MojoHandle handle; | 331 MojoHandle handle; |
320 MojoResult result = MojoDuplicateBufferHandle(mojo_handle, options, &handle); | 332 MojoResult result = MojoDuplicateBufferHandle(mojo_handle, options, &handle); |
321 return Java_CoreImpl_newResultAndInteger(env, result, handle); | 333 return Java_CoreImpl_newResultAndInteger(env, result, handle); |
322 } | 334 } |
323 | 335 |
324 static ScopedJavaLocalRef<jobject> Map(JNIEnv* env, | 336 static ScopedJavaLocalRef<jobject> Map(JNIEnv* env, |
325 jobject jcaller, | 337 const JavaParamRef<jobject>& jcaller, |
326 jint mojo_handle, | 338 jint mojo_handle, |
327 jlong offset, | 339 jlong offset, |
328 jlong num_bytes, | 340 jlong num_bytes, |
329 jint flags) { | 341 jint flags) { |
330 void* buffer = 0; | 342 void* buffer = 0; |
331 MojoResult result = | 343 MojoResult result = |
332 MojoMapBuffer(mojo_handle, offset, num_bytes, &buffer, flags); | 344 MojoMapBuffer(mojo_handle, offset, num_bytes, &buffer, flags); |
333 jobject byte_buffer = 0; | 345 jobject byte_buffer = 0; |
334 if (result == MOJO_RESULT_OK) { | 346 if (result == MOJO_RESULT_OK) { |
335 byte_buffer = env->NewDirectByteBuffer(buffer, num_bytes); | 347 byte_buffer = env->NewDirectByteBuffer(buffer, num_bytes); |
336 } | 348 } |
337 return Java_CoreImpl_newResultAndBuffer(env, result, byte_buffer); | 349 return Java_CoreImpl_newResultAndBuffer(env, result, byte_buffer); |
338 } | 350 } |
339 | 351 |
340 static int Unmap(JNIEnv* env, jobject jcaller, jobject buffer) { | 352 static int Unmap(JNIEnv* env, |
| 353 const JavaParamRef<jobject>& jcaller, |
| 354 const JavaParamRef<jobject>& buffer) { |
341 void* buffer_start = env->GetDirectBufferAddress(buffer); | 355 void* buffer_start = env->GetDirectBufferAddress(buffer); |
342 DCHECK(buffer_start); | 356 DCHECK(buffer_start); |
343 return MojoUnmapBuffer(buffer_start); | 357 return MojoUnmapBuffer(buffer_start); |
344 } | 358 } |
345 | 359 |
346 static ScopedJavaLocalRef<jobject> AsyncWait(JNIEnv* env, | 360 static ScopedJavaLocalRef<jobject> AsyncWait( |
347 jobject jcaller, | 361 JNIEnv* env, |
348 jint mojo_handle, | 362 const JavaParamRef<jobject>& jcaller, |
349 jint signals, | 363 jint mojo_handle, |
350 jlong deadline, | 364 jint signals, |
351 jobject callback) { | 365 jlong deadline, |
| 366 const JavaParamRef<jobject>& callback) { |
352 AsyncWaitCallbackData* callback_data = | 367 AsyncWaitCallbackData* callback_data = |
353 new AsyncWaitCallbackData(env, jcaller, callback); | 368 new AsyncWaitCallbackData(env, jcaller, callback); |
354 MojoAsyncWaitID cancel_id; | 369 MojoAsyncWaitID cancel_id; |
355 if (static_cast<MojoHandle>(mojo_handle) != MOJO_HANDLE_INVALID) { | 370 if (static_cast<MojoHandle>(mojo_handle) != MOJO_HANDLE_INVALID) { |
356 cancel_id = Environment::GetDefaultAsyncWaiter()->AsyncWait( | 371 cancel_id = Environment::GetDefaultAsyncWaiter()->AsyncWait( |
357 mojo_handle, signals, deadline, AsyncWaitCallback, callback_data); | 372 mojo_handle, signals, deadline, AsyncWaitCallback, callback_data); |
358 } else { | 373 } else { |
359 cancel_id = kInvalidHandleCancelID; | 374 cancel_id = kInvalidHandleCancelID; |
360 base::MessageLoop::current()->PostTask( | 375 base::MessageLoop::current()->PostTask( |
361 FROM_HERE, | 376 FROM_HERE, |
362 base::Bind( | 377 base::Bind( |
363 &AsyncWaitCallback, callback_data, MOJO_RESULT_INVALID_ARGUMENT)); | 378 &AsyncWaitCallback, callback_data, MOJO_RESULT_INVALID_ARGUMENT)); |
364 } | 379 } |
365 base::android::ScopedJavaLocalRef<jobject> cancellable = | 380 base::android::ScopedJavaLocalRef<jobject> cancellable = |
366 Java_CoreImpl_newAsyncWaiterCancellableImpl( | 381 Java_CoreImpl_newAsyncWaiterCancellableImpl( |
367 env, jcaller, cancel_id, reinterpret_cast<intptr_t>(callback_data)); | 382 env, jcaller, cancel_id, reinterpret_cast<intptr_t>(callback_data)); |
368 callback_data->cancellable.Reset(env, cancellable.obj()); | 383 callback_data->cancellable.Reset(env, cancellable.obj()); |
369 return cancellable; | 384 return cancellable; |
370 } | 385 } |
371 | 386 |
372 static void CancelAsyncWait(JNIEnv* env, | 387 static void CancelAsyncWait(JNIEnv* env, |
373 jobject jcaller, | 388 const JavaParamRef<jobject>& jcaller, |
374 jlong id, | 389 jlong id, |
375 jlong data_ptr) { | 390 jlong data_ptr) { |
376 if (id == 0) { | 391 if (id == 0) { |
377 // If |id| is |kInvalidHandleCancelID|, the async wait was done on an | 392 // If |id| is |kInvalidHandleCancelID|, the async wait was done on an |
378 // invalid handle, so the AsyncWaitCallback will be called and will clear | 393 // invalid handle, so the AsyncWaitCallback will be called and will clear |
379 // the data_ptr. | 394 // the data_ptr. |
380 return; | 395 return; |
381 } | 396 } |
382 scoped_ptr<AsyncWaitCallbackData> deleter( | 397 scoped_ptr<AsyncWaitCallbackData> deleter( |
383 reinterpret_cast<AsyncWaitCallbackData*>(data_ptr)); | 398 reinterpret_cast<AsyncWaitCallbackData*>(data_ptr)); |
384 Environment::GetDefaultAsyncWaiter()->CancelWait(id); | 399 Environment::GetDefaultAsyncWaiter()->CancelWait(id); |
385 } | 400 } |
386 | 401 |
387 static jint GetNativeBufferOffset(JNIEnv* env, | 402 static jint GetNativeBufferOffset(JNIEnv* env, |
388 jobject jcaller, | 403 const JavaParamRef<jobject>& jcaller, |
389 jobject buffer, | 404 const JavaParamRef<jobject>& buffer, |
390 jint alignment) { | 405 jint alignment) { |
391 jint offset = | 406 jint offset = |
392 reinterpret_cast<uintptr_t>(env->GetDirectBufferAddress(buffer)) % | 407 reinterpret_cast<uintptr_t>(env->GetDirectBufferAddress(buffer)) % |
393 alignment; | 408 alignment; |
394 if (offset == 0) | 409 if (offset == 0) |
395 return 0; | 410 return 0; |
396 return alignment - offset; | 411 return alignment - offset; |
397 } | 412 } |
398 | 413 |
399 bool RegisterCoreImpl(JNIEnv* env) { | 414 bool RegisterCoreImpl(JNIEnv* env) { |
400 return RegisterNativesImpl(env); | 415 return RegisterNativesImpl(env); |
401 } | 416 } |
402 | 417 |
403 } // namespace android | 418 } // namespace android |
404 } // namespace mojo | 419 } // namespace mojo |
OLD | NEW |