Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(262)

Side by Side Diff: mojo/android/system/core_impl.cc

Issue 1312153003: jni_generator: Pass object parameters as JavaParamRef. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Rebase Created 5 years, 3 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « mojo/android/system/base_run_loop.cc ('k') | mojo/runner/android/bootstrap.cc » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
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
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
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
OLDNEW
« no previous file with comments | « mojo/android/system/base_run_loop.cc ('k') | mojo/runner/android/bootstrap.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698