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

Side by Side Diff: mojo/public/dart/src/mojo_dart_core.cc

Issue 728133002: Update mojo sdk to rev e01f9a49449381a5eb430c1fd88bf2cae73ec35a (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: android + ios gyp fixes Created 6 years, 1 month 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/public/dart/src/message_pipe.dart ('k') | mojo/public/dart/src/types.dart » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
(Empty)
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
3 // found in the LICENSE file.
4
5 #include <stdio.h>
6 #include <string.h>
7
8 #include "base/memory/scoped_ptr.h"
9 #include "dart/runtime/include/dart_api.h"
10 #include "mojo/public/c/system/core.h"
11 #include "mojo/public/platform/native/system_thunks.h"
12
13
14 static Dart_NativeFunction ResolveName(
15 Dart_Handle name, int argc, bool* auto_setup_scope);
16
17
18 DART_EXPORT Dart_Handle mojo_dart_core_Init(Dart_Handle parent_library) {
19 if (Dart_IsError(parent_library)) {
20 return parent_library;
21 }
22
23 Dart_Handle result_code = Dart_SetNativeResolver(
24 parent_library, ResolveName, NULL);
25 if (Dart_IsError(result_code)) {
26 return result_code;
27 }
28
29 return Dart_Null();
30 }
31
32
33 static Dart_Handle HandleError(Dart_Handle handle) {
34 if (Dart_IsError(handle)) {
35 Dart_PropagateError(handle);
36 }
37 return handle;
38 }
39
40
41 static void SetNullReturn(Dart_NativeArguments arguments) {
42 Dart_SetReturnValue(arguments, Dart_Null());
43 }
44
45
46 static void SetInvalidArgumentReturn(Dart_NativeArguments arguments) {
47 Dart_SetIntegerReturnValue(
48 arguments, static_cast<int64_t>(MOJO_RESULT_INVALID_ARGUMENT));
49 }
50
51
52 #define CHECK_INTEGER_ARGUMENT(args, num, result, failure) \
53 { \
54 Dart_Handle __status; \
55 __status = Dart_GetNativeIntegerArgument(args, num, result); \
56 if (Dart_IsError(__status)) { \
57 Set##failure##Return(arguments); \
58 return; \
59 } \
60 } \
61
62
63 extern "C" {
64 extern size_t MojoSetSystemThunks(const MojoSystemThunks* system_thunks);
65 }
66
67
68 static void MojoSystemThunks_Set(Dart_NativeArguments arguments) {
69 int64_t thunks_addr = 0;
70 CHECK_INTEGER_ARGUMENT(arguments, 0, &thunks_addr, Null);
71
72 MojoSystemThunks* thunks = reinterpret_cast<MojoSystemThunks*>(thunks_addr);
73 MojoSetSystemThunks(thunks);
74
75 Dart_SetReturnValue(arguments, Dart_Null());
76 }
77
78
79 static void MojoHandle_Close(Dart_NativeArguments arguments) {
80 int64_t handle;
81 CHECK_INTEGER_ARGUMENT(arguments, 0, &handle, InvalidArgument);
82
83 MojoResult res = MojoClose(static_cast<MojoHandle>(handle));
84
85 Dart_SetIntegerReturnValue(arguments, static_cast<int64_t>(res));
86 }
87
88
89 static void MojoHandle_Wait(Dart_NativeArguments arguments) {
90 int64_t handle = 0;
91 int64_t signals = 0;
92 int64_t deadline = 0;
93 CHECK_INTEGER_ARGUMENT(arguments, 0, &handle, InvalidArgument);
94 CHECK_INTEGER_ARGUMENT(arguments, 1, &signals, InvalidArgument);
95 CHECK_INTEGER_ARGUMENT(arguments, 2, &deadline, InvalidArgument);
96
97 MojoResult r = MojoWait(static_cast<MojoHandle>(handle),
98 static_cast<MojoHandleSignals>(signals),
99 static_cast<MojoDeadline>(deadline));
100
101 Dart_SetIntegerReturnValue(arguments, static_cast<int64_t>(r));
102 }
103
104
105 static void MojoHandle_WaitMany(Dart_NativeArguments arguments) {
106 int64_t num_handles = 0;
107 int64_t deadline = 0;
108 Dart_Handle handles = Dart_GetNativeArgument(arguments, 0);
109 Dart_Handle signals = Dart_GetNativeArgument(arguments, 1);
110 CHECK_INTEGER_ARGUMENT(arguments, 2, &num_handles, InvalidArgument);
111 CHECK_INTEGER_ARGUMENT(arguments, 3, &deadline, InvalidArgument);
112
113 if (!Dart_IsList(handles) || !Dart_IsList(signals)) {
114 SetInvalidArgumentReturn(arguments);
115 return;
116 }
117
118 intptr_t handles_len = 0;
119 intptr_t signals_len = 0;
120 Dart_ListLength(handles, &handles_len);
121 Dart_ListLength(signals, &signals_len);
122 if ((handles_len != num_handles) || (signals_len != num_handles)) {
123 SetInvalidArgumentReturn(arguments);
124 return;
125 }
126
127 scoped_ptr<MojoHandle[]> mojo_handles(new MojoHandle[num_handles]);
128 scoped_ptr<MojoHandleSignals[]> mojo_signals(
129 new MojoHandleSignals[num_handles]);
130
131 for (int i = 0; i < num_handles; i++) {
132 Dart_Handle dart_handle = Dart_ListGetAt(handles, i);
133 Dart_Handle dart_signal = Dart_ListGetAt(signals, i);
134 if (!Dart_IsInteger(dart_handle) || !Dart_IsInteger(dart_signal)) {
135 SetInvalidArgumentReturn(arguments);
136 return;
137 }
138 int64_t mojo_handle = 0;
139 int64_t mojo_signal = 0;
140 Dart_IntegerToInt64(dart_handle, &mojo_handle);
141 Dart_IntegerToInt64(dart_signal, &mojo_signal);
142 mojo_handles[i] = static_cast<MojoHandle>(mojo_handle);
143 mojo_signals[i] = static_cast<MojoHandleSignals>(mojo_signal);
144 }
145
146 MojoResult res = MojoWaitMany(mojo_handles.get(), mojo_signals.get(),
147 static_cast<uint32_t>(num_handles),
148 static_cast<MojoDeadline>(deadline));
149 Dart_SetIntegerReturnValue(arguments, static_cast<int64_t>(res));
150 }
151
152
153 static void MojoSharedBuffer_Create(Dart_NativeArguments arguments) {
154 int64_t num_bytes = 0;
155 int64_t flags = 0;
156 CHECK_INTEGER_ARGUMENT(arguments, 0, &num_bytes, Null);
157 CHECK_INTEGER_ARGUMENT(arguments, 1, &flags, Null);
158
159 MojoCreateSharedBufferOptions options;
160 options.struct_size = sizeof(MojoCreateSharedBufferOptions);
161 options.flags = static_cast<MojoCreateSharedBufferOptionsFlags>(flags);
162
163 MojoHandle out = MOJO_HANDLE_INVALID;;
164 MojoResult res = MojoCreateSharedBuffer(
165 &options, static_cast<int32_t>(num_bytes), &out);
166
167 Dart_Handle list = Dart_NewList(2);
168 Dart_ListSetAt(list, 0, Dart_NewInteger(res));
169 Dart_ListSetAt(list, 1, Dart_NewInteger(out));
170 Dart_SetReturnValue(arguments, list);
171 }
172
173
174 static void MojoSharedBuffer_Duplicate(Dart_NativeArguments arguments) {
175 int64_t handle = 0;
176 int64_t flags = 0;
177 CHECK_INTEGER_ARGUMENT(arguments, 0, &handle, Null);
178 CHECK_INTEGER_ARGUMENT(arguments, 1, &flags, Null);
179
180 MojoDuplicateBufferHandleOptions options;
181 options.struct_size = sizeof(MojoDuplicateBufferHandleOptions);
182 options.flags = static_cast<MojoDuplicateBufferHandleOptionsFlags>(flags);
183
184 MojoHandle out = MOJO_HANDLE_INVALID;;
185 MojoResult res = MojoDuplicateBufferHandle(
186 static_cast<MojoHandle>(handle), &options, &out);
187
188 Dart_Handle list = Dart_NewList(2);
189 Dart_ListSetAt(list, 0, Dart_NewInteger(res));
190 Dart_ListSetAt(list, 1, Dart_NewInteger(out));
191 Dart_SetReturnValue(arguments, list);
192 }
193
194
195 static void MojoSharedBuffer_Map(Dart_NativeArguments arguments) {
196 int64_t handle = 0;
197 int64_t offset = 0;
198 int64_t num_bytes = 0;
199 int64_t flags = 0;
200 CHECK_INTEGER_ARGUMENT(arguments, 0, &handle, Null);
201 CHECK_INTEGER_ARGUMENT(arguments, 1, &offset, Null);
202 CHECK_INTEGER_ARGUMENT(arguments, 2, &num_bytes, Null);
203 CHECK_INTEGER_ARGUMENT(arguments, 3, &flags, Null);
204
205 void* out;
206 MojoResult res = MojoMapBuffer(static_cast<MojoHandle>(handle),
207 offset,
208 num_bytes,
209 &out,
210 static_cast<MojoMapBufferFlags>(flags));
211
212 Dart_Handle list = Dart_NewList(2);
213 Dart_Handle typed_data;
214 if (res == MOJO_RESULT_OK) {
215 typed_data = Dart_NewExternalTypedData(
216 Dart_TypedData_kByteData, out, num_bytes);
217 } else {
218 typed_data = Dart_Null();
219 }
220 Dart_ListSetAt(list, 0, Dart_NewInteger(res));
221 Dart_ListSetAt(list, 1, typed_data);
222 Dart_SetReturnValue(arguments, list);
223 }
224
225
226 static void MojoSharedBuffer_Unmap(Dart_NativeArguments arguments) {
227 Dart_Handle typed_data = Dart_GetNativeArgument(arguments, 0);
228 if (!Dart_IsTypedData(typed_data)) {
229 SetInvalidArgumentReturn(arguments);
230 return;
231 }
232
233 Dart_TypedData_Type typ;
234 void *data;
235 intptr_t len;
236 Dart_TypedDataAcquireData(typed_data, &typ, &data, &len);
237 MojoResult res = MojoUnmapBuffer(data);
238 Dart_TypedDataReleaseData(typed_data);
239
240 Dart_SetIntegerReturnValue(arguments, static_cast<int64_t>(res));
241 }
242
243
244 static void MojoDataPipe_Create(Dart_NativeArguments arguments) {
245 int64_t element_bytes = 0;
246 int64_t capacity_bytes = 0;
247 int64_t flags = 0;
248 CHECK_INTEGER_ARGUMENT(arguments, 0, &element_bytes, Null);
249 CHECK_INTEGER_ARGUMENT(arguments, 1, &capacity_bytes, Null);
250 CHECK_INTEGER_ARGUMENT(arguments, 2, &flags, Null);
251
252 MojoCreateDataPipeOptions options;
253 options.struct_size = sizeof(MojoCreateDataPipeOptions);
254 options.flags = static_cast<MojoCreateDataPipeOptionsFlags>(flags);
255 options.element_num_bytes = static_cast<uint32_t>(element_bytes);
256 options.capacity_num_bytes = static_cast<uint32_t>(capacity_bytes);
257
258 MojoHandle producer = MOJO_HANDLE_INVALID;
259 MojoHandle consumer = MOJO_HANDLE_INVALID;
260 MojoResult res = MojoCreateDataPipe(&options, &producer, &consumer);
261
262 Dart_Handle list = Dart_NewList(3);
263 Dart_ListSetAt(list, 0, Dart_NewInteger(res));
264 Dart_ListSetAt(list, 1, Dart_NewInteger(producer));
265 Dart_ListSetAt(list, 2, Dart_NewInteger(consumer));
266 Dart_SetReturnValue(arguments, list);
267 }
268
269
270 static void MojoDataPipe_WriteData(Dart_NativeArguments arguments) {
271 int64_t handle = 0;
272 CHECK_INTEGER_ARGUMENT(arguments, 0, &handle, Null);
273
274 Dart_Handle typed_data = Dart_GetNativeArgument(arguments, 1);
275 if (!Dart_IsTypedData(typed_data)) {
276 SetNullReturn(arguments);
277 return;
278 }
279
280 int64_t num_bytes = 0;
281 CHECK_INTEGER_ARGUMENT(arguments, 2, &num_bytes, Null);
282
283 int64_t flags = 0;
284 CHECK_INTEGER_ARGUMENT(arguments, 3, &flags, Null);
285
286 Dart_TypedData_Type type;
287 void* data;
288 intptr_t data_length;
289 Dart_TypedDataAcquireData(typed_data, &type, &data, &data_length);
290 uint32_t length = static_cast<uint32_t>(num_bytes);
291 MojoResult res = MojoWriteData(
292 static_cast<MojoHandle>(handle),
293 data,
294 &length,
295 static_cast<MojoWriteDataFlags>(flags));
296 Dart_TypedDataReleaseData(typed_data);
297
298 Dart_Handle list = Dart_NewList(2);
299 Dart_ListSetAt(list, 0, Dart_NewInteger(res));
300 Dart_ListSetAt(list, 1, Dart_NewInteger(length));
301 Dart_SetReturnValue(arguments, list);
302 }
303
304
305 static void MojoDataPipe_BeginWriteData(Dart_NativeArguments arguments) {
306 int64_t handle = 0;
307 int64_t buffer_bytes = 0;
308 int64_t flags = 0;
309 CHECK_INTEGER_ARGUMENT(arguments, 0, &handle, Null);
310 CHECK_INTEGER_ARGUMENT(arguments, 1, &buffer_bytes, Null);
311 CHECK_INTEGER_ARGUMENT(arguments, 2, &flags, Null);
312
313 void* buffer;
314 uint32_t size = static_cast<uint32_t>(buffer_bytes);
315 MojoResult res = MojoBeginWriteData(
316 static_cast<MojoHandle>(handle),
317 &buffer,
318 &size,
319 static_cast<MojoWriteDataFlags>(flags));
320
321 Dart_Handle list = Dart_NewList(2);
322 Dart_Handle typed_data;
323 if (res == MOJO_RESULT_OK) {
324 typed_data = Dart_NewExternalTypedData(
325 Dart_TypedData_kByteData, buffer, size);
326 } else {
327 typed_data = Dart_Null();
328 }
329 Dart_ListSetAt(list, 0, Dart_NewInteger(res));
330 Dart_ListSetAt(list, 1, typed_data);
331 Dart_SetReturnValue(arguments, list);
332 }
333
334
335 static void MojoDataPipe_EndWriteData(Dart_NativeArguments arguments) {
336 int64_t handle = 0;
337 int64_t num_bytes_written = 0;
338 CHECK_INTEGER_ARGUMENT(arguments, 0, &handle, InvalidArgument);
339 CHECK_INTEGER_ARGUMENT(arguments, 1, &num_bytes_written, InvalidArgument);
340
341 MojoResult res = MojoEndWriteData(
342 static_cast<MojoHandle>(handle),
343 static_cast<uint32_t>(num_bytes_written));
344
345 Dart_SetIntegerReturnValue(arguments, static_cast<int64_t>(res));
346 }
347
348
349 static void MojoDataPipe_ReadData(Dart_NativeArguments arguments) {
350 int64_t handle = 0;
351 CHECK_INTEGER_ARGUMENT(arguments, 0, &handle, Null);
352
353 Dart_Handle typed_data = Dart_GetNativeArgument(arguments, 1);
354 if (!Dart_IsTypedData(typed_data) && !Dart_IsNull(typed_data)) {
355 SetNullReturn(arguments);
356 return;
357 }
358
359 int64_t num_bytes = 0;
360 CHECK_INTEGER_ARGUMENT(arguments, 2, &num_bytes, Null);
361
362 int64_t flags = 0;
363 CHECK_INTEGER_ARGUMENT(arguments, 3, &flags, Null);
364
365 Dart_TypedData_Type typ;
366 void* data = NULL;
367 intptr_t bdlen = 0;
368 if (!Dart_IsNull(typed_data)) {
369 Dart_TypedDataAcquireData(typed_data, &typ, &data, &bdlen);
370 }
371 uint32_t len = static_cast<uint32_t>(num_bytes);
372 MojoResult res = MojoReadData(
373 static_cast<MojoHandle>(handle),
374 data,
375 &len,
376 static_cast<MojoReadDataFlags>(flags));
377 if (!Dart_IsNull(typed_data)) {
378 Dart_TypedDataReleaseData(typed_data);
379 }
380
381 Dart_Handle list = Dart_NewList(2);
382 Dart_ListSetAt(list, 0, Dart_NewInteger(res));
383 Dart_ListSetAt(list, 1, Dart_NewInteger(len));
384 Dart_SetReturnValue(arguments, list);
385 }
386
387
388 static void MojoDataPipe_BeginReadData(Dart_NativeArguments arguments) {
389 int64_t handle = 0;
390 int64_t buffer_bytes = 0;
391 int64_t flags = 0;
392 CHECK_INTEGER_ARGUMENT(arguments, 0, &handle, Null);
393 CHECK_INTEGER_ARGUMENT(arguments, 1, &buffer_bytes, Null);
394 CHECK_INTEGER_ARGUMENT(arguments, 2, &flags, Null);
395
396 void* buffer;
397 uint32_t size = static_cast<uint32_t>(buffer_bytes);
398 MojoResult res = MojoBeginReadData(
399 static_cast<MojoHandle>(handle),
400 const_cast<const void**>(&buffer),
401 &size,
402 static_cast<MojoWriteDataFlags>(flags));
403
404 Dart_Handle list = Dart_NewList(2);
405 Dart_Handle typed_data;
406 if (res == MOJO_RESULT_OK) {
407 typed_data = Dart_NewExternalTypedData(
408 Dart_TypedData_kByteData, buffer, size);
409 } else {
410 typed_data = Dart_Null();
411 }
412 Dart_ListSetAt(list, 0, Dart_NewInteger(res));
413 Dart_ListSetAt(list, 1, typed_data);
414 Dart_SetReturnValue(arguments, list);
415 }
416
417
418 static void MojoDataPipe_EndReadData(Dart_NativeArguments arguments) {
419 int64_t handle = 0;
420 int64_t num_bytes_read = 0;
421 CHECK_INTEGER_ARGUMENT(arguments, 0, &handle, InvalidArgument);
422 CHECK_INTEGER_ARGUMENT(arguments, 1, &num_bytes_read, InvalidArgument);
423
424 MojoResult res = MojoEndReadData(
425 static_cast<MojoHandle>(handle),
426 static_cast<uint32_t>(num_bytes_read));
427
428 Dart_SetIntegerReturnValue(arguments, static_cast<int64_t>(res));
429 }
430
431
432 static void MojoMessagePipe_Create(Dart_NativeArguments arguments) {
433 int64_t flags = 0;
434 CHECK_INTEGER_ARGUMENT(arguments, 0, &flags, Null);
435
436 MojoCreateMessagePipeOptions options;
437 options.struct_size = sizeof(MojoCreateMessagePipeOptions);
438 options.flags = static_cast<MojoCreateMessagePipeOptionsFlags>(flags);
439
440 MojoHandle end1 = MOJO_HANDLE_INVALID;
441 MojoHandle end2 = MOJO_HANDLE_INVALID;
442 MojoResult res = MojoCreateMessagePipe(&options, &end1, &end2);
443
444 Dart_Handle list = Dart_NewList(3);
445 Dart_ListSetAt(list, 0, Dart_NewInteger(res));
446 Dart_ListSetAt(list, 1, Dart_NewInteger(end1));
447 Dart_ListSetAt(list, 2, Dart_NewInteger(end2));
448 Dart_SetReturnValue(arguments, list);
449 }
450
451
452 static void MojoMessagePipe_Write(Dart_NativeArguments arguments) {
453 int64_t handle = 0;
454 CHECK_INTEGER_ARGUMENT(arguments, 0, &handle, InvalidArgument);
455
456 Dart_Handle typed_data = Dart_GetNativeArgument(arguments, 1);
457 if (!Dart_IsTypedData(typed_data) && !Dart_IsNull(typed_data)) {
458 SetInvalidArgumentReturn(arguments);
459 return;
460 }
461
462 int64_t num_bytes = 0;
463 CHECK_INTEGER_ARGUMENT(arguments, 2, &num_bytes, InvalidArgument);
464
465 Dart_Handle handles = Dart_GetNativeArgument(arguments, 3);
466 if (!Dart_IsList(handles) && !Dart_IsNull(handles)) {
467 SetInvalidArgumentReturn(arguments);
468 return;
469 }
470
471 int64_t flags = 0;
472 CHECK_INTEGER_ARGUMENT(arguments, 4, &flags, InvalidArgument);
473
474 // Grab the data if there is any.
475 Dart_TypedData_Type typ;
476 void* bytes = NULL;
477 intptr_t bdlen = 0;
478 if (!Dart_IsNull(typed_data)) {
479 Dart_TypedDataAcquireData(typed_data, &typ, &bytes, &bdlen);
480 }
481
482 // Grab the handles if there are any.
483 scoped_ptr<MojoHandle[]> mojo_handles;
484 intptr_t handles_len = 0;
485 if (!Dart_IsNull(handles)) {
486 Dart_ListLength(handles, &handles_len);
487 mojo_handles.reset(new MojoHandle[handles_len]);
488 for (int i = 0; i < handles_len; i++) {
489 Dart_Handle dart_handle = Dart_ListGetAt(handles, i);
490 if (!Dart_IsInteger(dart_handle)) {
491 SetInvalidArgumentReturn(arguments);
492 return;
493 }
494 int64_t mojo_handle = 0;
495 Dart_IntegerToInt64(dart_handle, &mojo_handle);
496 mojo_handles[i] = static_cast<MojoHandle>(mojo_handle);
497 }
498 }
499
500 MojoResult res = MojoWriteMessage(
501 static_cast<MojoHandle>(handle),
502 const_cast<const void*>(bytes),
503 static_cast<uint32_t>(num_bytes),
504 mojo_handles.get(),
505 static_cast<uint32_t>(handles_len),
506 static_cast<MojoWriteMessageFlags>(flags));
507
508 // Release the data.
509 if (!Dart_IsNull(typed_data)) {
510 Dart_TypedDataReleaseData(typed_data);
511 }
512
513 Dart_SetIntegerReturnValue(arguments, static_cast<int64_t>(res));
514 }
515
516
517 static void MojoMessagePipe_Read(Dart_NativeArguments arguments) {
518 int64_t handle = 0;
519 CHECK_INTEGER_ARGUMENT(arguments, 0, &handle, Null);
520
521 Dart_Handle typed_data = Dart_GetNativeArgument(arguments, 1);
522 if (!Dart_IsTypedData(typed_data) && !Dart_IsNull(typed_data)) {
523 SetNullReturn(arguments);
524 return;
525 }
526
527 int64_t num_bytes = 0;
528 CHECK_INTEGER_ARGUMENT(arguments, 2, &num_bytes, Null);
529
530 Dart_Handle handles = Dart_GetNativeArgument(arguments, 3);
531 if (!Dart_IsList(handles) && !Dart_IsNull(handles)) {
532 SetNullReturn(arguments);
533 return;
534 }
535
536 int64_t flags = 0;
537 CHECK_INTEGER_ARGUMENT(arguments, 4, &flags, Null);
538
539 // Grab the data if there is any.
540 Dart_TypedData_Type typ;
541 void* bytes = NULL;
542 intptr_t byte_data_len = 0;
543 if (!Dart_IsNull(typed_data)) {
544 Dart_TypedDataAcquireData(typed_data, &typ, &bytes, &byte_data_len);
545 }
546 uint32_t blen = static_cast<uint32_t>(num_bytes);
547
548 // Grab the handles if there are any.
549 scoped_ptr<MojoHandle[]> mojo_handles;
550 intptr_t handles_len = 0;
551 if (!Dart_IsNull(handles)) {
552 Dart_ListLength(handles, &handles_len);
553 mojo_handles.reset(new MojoHandle[handles_len]);
554 }
555 uint32_t hlen = static_cast<uint32_t>(handles_len);
556
557 MojoResult res = MojoReadMessage(
558 static_cast<MojoHandle>(handle),
559 bytes,
560 &blen,
561 mojo_handles.get(),
562 &hlen,
563 static_cast<MojoReadMessageFlags>(flags));
564
565 // Release the data.
566 if (!Dart_IsNull(typed_data)) {
567 Dart_TypedDataReleaseData(typed_data);
568 }
569
570 if (!Dart_IsNull(handles)) {
571 for (int i = 0; i < handles_len; i++) {
572 Dart_ListSetAt(handles, i, Dart_NewInteger(mojo_handles[i]));
573 }
574 }
575
576 Dart_Handle list = Dart_NewList(3);
577 Dart_ListSetAt(list, 0, Dart_NewInteger(res));
578 Dart_ListSetAt(list, 1, Dart_NewInteger(blen));
579 Dart_ListSetAt(list, 2, Dart_NewInteger(hlen));
580 Dart_SetReturnValue(arguments, list);
581 }
582
583
584 struct ControlData {
585 int64_t handle;
586 Dart_Port port;
587 int64_t data;
588 };
589
590
591 static void MojoHandleWatcher_SendControlData(Dart_NativeArguments arguments) {
592 int64_t control_handle = 0;
593 int64_t client_handle = 0;
594 CHECK_INTEGER_ARGUMENT(arguments, 0, &control_handle, InvalidArgument);
595 CHECK_INTEGER_ARGUMENT(arguments, 1, &client_handle, InvalidArgument);
596
597 Dart_Handle send_port_handle = Dart_GetNativeArgument(arguments, 2);
598 Dart_Port send_port_id = 0;
599 if (!Dart_IsNull(send_port_handle)) {
600 Dart_Handle result = Dart_SendPortGetId(send_port_handle, &send_port_id);
601 if (Dart_IsError(result)) {
602 SetInvalidArgumentReturn(arguments);
603 return;
604 }
605 }
606
607 int64_t data = 0;
608 CHECK_INTEGER_ARGUMENT(arguments, 3, &data, InvalidArgument);
609
610 ControlData cd;
611 cd.handle = client_handle;
612 cd.port = send_port_id;
613 cd.data = data;
614 const void* bytes = reinterpret_cast<const void*>(&cd);
615 MojoResult res = MojoWriteMessage(
616 control_handle, bytes, sizeof(cd), NULL, 0, 0);
617
618 Dart_SetIntegerReturnValue(arguments, static_cast<int64_t>(res));
619 }
620
621
622 static void MojoHandleWatcher_RecvControlData(Dart_NativeArguments arguments) {
623 int64_t control_handle = 0;
624 CHECK_INTEGER_ARGUMENT(arguments, 0, &control_handle, Null);
625
626 ControlData cd;
627 void* bytes = reinterpret_cast<void*>(&cd);
628 uint32_t num_bytes = sizeof(cd);
629 uint32_t num_handles = 0;
630 MojoResult res = MojoReadMessage(
631 control_handle, bytes, &num_bytes, NULL, &num_handles, 0);
632 if (res != MOJO_RESULT_OK) {
633 SetNullReturn(arguments);
634 return;
635 }
636
637 Dart_Handle list = Dart_NewList(3);
638 Dart_ListSetAt(list, 0, Dart_NewInteger(cd.handle));
639 Dart_ListSetAt(list, 1, Dart_NewSendPort(cd.port));
640 Dart_ListSetAt(list, 2, Dart_NewInteger(cd.data));
641 Dart_SetReturnValue(arguments, list);
642 }
643
644
645 static int64_t mojo_control_handle = MOJO_HANDLE_INVALID;
646 static void MojoHandleWatcher_SetControlHandle(Dart_NativeArguments arguments) {
647 int64_t control_handle;
648 CHECK_INTEGER_ARGUMENT(arguments, 0, &control_handle, InvalidArgument);
649
650 if (mojo_control_handle == MOJO_HANDLE_INVALID) {
651 mojo_control_handle = control_handle;
652 }
653
654 Dart_SetIntegerReturnValue(arguments, static_cast<int64_t>(MOJO_RESULT_OK));
655 }
656
657
658 static void MojoHandleWatcher_GetControlHandle(Dart_NativeArguments arguments) {
659 Dart_SetIntegerReturnValue(arguments, mojo_control_handle);
660 }
661
662
663 #define SCOPE_FUNCTIONS(V) \
664 V(MojoSharedBuffer_Create) \
665 V(MojoSharedBuffer_Duplicate) \
666 V(MojoSharedBuffer_Map) \
667 V(MojoSharedBuffer_Unmap) \
668 V(MojoDataPipe_Create) \
669 V(MojoDataPipe_WriteData) \
670 V(MojoDataPipe_BeginWriteData) \
671 V(MojoDataPipe_ReadData) \
672 V(MojoDataPipe_BeginReadData) \
673 V(MojoDataPipe_EndReadData) \
674 V(MojoMessagePipe_Create) \
675 V(MojoMessagePipe_Write) \
676 V(MojoMessagePipe_Read) \
677 V(MojoHandle_WaitMany) \
678 V(MojoHandleWatcher_SendControlData) \
679 V(MojoHandleWatcher_RecvControlData) \
680
681 #define NOSCOPE_FUNCTIONS(V) \
682 V(MojoSystemThunks_Set) \
683 V(MojoHandle_Close) \
684 V(MojoHandle_Wait) \
685 V(MojoDataPipe_EndWriteData) \
686 V(MojoHandleWatcher_SetControlHandle) \
687 V(MojoHandleWatcher_GetControlHandle) \
688
689 #define FUNCTION_STRING_MAP(name) {#name, name},
690
691 struct FunctionLookup {
692 const char* name;
693 Dart_NativeFunction function;
694 };
695
696 FunctionLookup function_list[] = {
697 SCOPE_FUNCTIONS(FUNCTION_STRING_MAP)
698 {NULL, NULL}
699 };
700
701 FunctionLookup no_scope_function_list[] = {
702 NOSCOPE_FUNCTIONS(FUNCTION_STRING_MAP)
703 {NULL, NULL}
704 };
705
706 #undef FUNCTION_STRING_MAP
707
708
709 Dart_NativeFunction ResolveName(Dart_Handle name,
710 int argc,
711 bool* auto_setup_scope) {
712 if (!Dart_IsString(name)) {
713 return NULL;
714 }
715 Dart_NativeFunction result = NULL;
716 if (auto_setup_scope == NULL) {
717 return NULL;
718 }
719
720 Dart_EnterScope();
721 const char* cname;
722 HandleError(Dart_StringToCString(name, &cname));
723
724 for (int i=0; function_list[i].name != NULL; ++i) {
725 if (strcmp(function_list[i].name, cname) == 0) {
726 *auto_setup_scope = true;
727 Dart_ExitScope();
728 return function_list[i].function;
729 }
730 }
731
732 for (int i=0; no_scope_function_list[i].name != NULL; ++i) {
733 if (strcmp(no_scope_function_list[i].name, cname) == 0) {
734 *auto_setup_scope = false;
735 result = no_scope_function_list[i].function;
736 break;
737 }
738 }
739
740 Dart_ExitScope();
741 return result;
742 }
OLDNEW
« no previous file with comments | « mojo/public/dart/src/message_pipe.dart ('k') | mojo/public/dart/src/types.dart » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698