mirror of
https://github.com/dart-lang/sdk
synced 2024-09-05 16:41:07 +00:00
![Vyacheslav Egorov](/assets/img/avatar_default.png)
The problem with these changes was that closed ports still continue to receive messages and as a result we start using dead peer objects. Fixing that would require more intrusive changes into message handler implementation - so instead we are reverting the changes and restoring manual PORT -> PEER mapping. BUG= R=erikcorry@google.com Review-Url: https://codereview.chromium.org/2666063002 .
189 lines
5.1 KiB
C++
189 lines
5.1 KiB
C++
// Copyright (c) 2012, the Dart project authors. Please see the AUTHORS file
|
|
// for details. All rights reserved. Use of this source code is governed by a
|
|
// BSD-style license that can be found in the LICENSE file.
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include "include/dart_api.h"
|
|
#include "include/dart_native_api.h"
|
|
|
|
|
|
Dart_NativeFunction ResolveName(Dart_Handle name,
|
|
int argc,
|
|
bool* auto_setup_scope);
|
|
|
|
|
|
DART_EXPORT Dart_Handle sample_extension_Init(Dart_Handle parent_library) {
|
|
if (Dart_IsError(parent_library)) {
|
|
return parent_library;
|
|
}
|
|
|
|
Dart_Handle result_code =
|
|
Dart_SetNativeResolver(parent_library, ResolveName, NULL);
|
|
if (Dart_IsError(result_code)) {
|
|
return result_code;
|
|
}
|
|
|
|
return Dart_Null();
|
|
}
|
|
|
|
|
|
Dart_Handle HandleError(Dart_Handle handle) {
|
|
if (Dart_IsError(handle)) {
|
|
Dart_PropagateError(handle);
|
|
}
|
|
return handle;
|
|
}
|
|
|
|
|
|
void SystemRand(Dart_NativeArguments arguments) {
|
|
Dart_EnterScope();
|
|
Dart_Handle result = HandleError(Dart_NewInteger(rand()));
|
|
Dart_SetReturnValue(arguments, result);
|
|
Dart_ExitScope();
|
|
}
|
|
|
|
|
|
void SystemSrand(Dart_NativeArguments arguments) {
|
|
Dart_EnterScope();
|
|
bool success = false;
|
|
Dart_Handle seed_object = HandleError(Dart_GetNativeArgument(arguments, 0));
|
|
if (Dart_IsInteger(seed_object)) {
|
|
bool fits;
|
|
HandleError(Dart_IntegerFitsIntoInt64(seed_object, &fits));
|
|
if (fits) {
|
|
int64_t seed;
|
|
HandleError(Dart_IntegerToInt64(seed_object, &seed));
|
|
srand(static_cast<unsigned>(seed));
|
|
success = true;
|
|
}
|
|
}
|
|
Dart_SetReturnValue(arguments, HandleError(Dart_NewBoolean(success)));
|
|
Dart_ExitScope();
|
|
}
|
|
|
|
|
|
uint8_t* randomArray(int seed, int length) {
|
|
if (length <= 0 || length > 10000000) {
|
|
return NULL;
|
|
}
|
|
uint8_t* values = reinterpret_cast<uint8_t*>(malloc(length));
|
|
if (NULL == values) {
|
|
return NULL;
|
|
}
|
|
srand(seed);
|
|
for (int i = 0; i < length; ++i) {
|
|
values[i] = rand() % 256;
|
|
}
|
|
return values;
|
|
}
|
|
|
|
|
|
void wrappedRandomArray(Dart_Port dest_port_id,
|
|
Dart_CObject* message) {
|
|
Dart_Port reply_port_id = ILLEGAL_PORT;
|
|
if (message->type == Dart_CObject_kArray &&
|
|
3 == message->value.as_array.length) {
|
|
// Use .as_array and .as_int32 to access the data in the Dart_CObject.
|
|
Dart_CObject* param0 = message->value.as_array.values[0];
|
|
Dart_CObject* param1 = message->value.as_array.values[1];
|
|
Dart_CObject* param2 = message->value.as_array.values[2];
|
|
if (param0->type == Dart_CObject_kInt32 &&
|
|
param1->type == Dart_CObject_kInt32 &&
|
|
param2->type == Dart_CObject_kSendPort) {
|
|
int seed = param0->value.as_int32;
|
|
int length = param1->value.as_int32;
|
|
reply_port_id = param2->value.as_send_port.id;
|
|
uint8_t* values = randomArray(seed, length);
|
|
|
|
if (values != NULL) {
|
|
Dart_CObject result;
|
|
result.type = Dart_CObject_kTypedData;
|
|
result.value.as_typed_data.type = Dart_TypedData_kUint8;
|
|
result.value.as_typed_data.values = values;
|
|
result.value.as_typed_data.length = length;
|
|
Dart_PostCObject(reply_port_id, &result);
|
|
free(values);
|
|
// It is OK that result is destroyed when function exits.
|
|
// Dart_PostCObject has copied its data.
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
Dart_CObject result;
|
|
result.type = Dart_CObject_kNull;
|
|
Dart_PostCObject(reply_port_id, &result);
|
|
}
|
|
|
|
|
|
void randomArrayServicePort(Dart_NativeArguments arguments) {
|
|
Dart_EnterScope();
|
|
Dart_SetReturnValue(arguments, Dart_Null());
|
|
Dart_Port service_port =
|
|
Dart_NewNativePort("RandomArrayService", wrappedRandomArray, true);
|
|
if (service_port != ILLEGAL_PORT) {
|
|
Dart_Handle send_port = HandleError(Dart_NewSendPort(service_port));
|
|
Dart_SetReturnValue(arguments, send_port);
|
|
}
|
|
Dart_ExitScope();
|
|
}
|
|
|
|
|
|
struct FunctionLookup {
|
|
const char* name;
|
|
Dart_NativeFunction function;
|
|
};
|
|
|
|
|
|
FunctionLookup function_list[] = {
|
|
{"SystemRand", SystemRand},
|
|
{"SystemSrand", SystemSrand},
|
|
{"RandomArray_ServicePort", randomArrayServicePort},
|
|
{NULL, NULL}};
|
|
|
|
|
|
FunctionLookup no_scope_function_list[] = {
|
|
{"NoScopeSystemRand", SystemRand},
|
|
{NULL, NULL}
|
|
};
|
|
|
|
Dart_NativeFunction ResolveName(Dart_Handle name,
|
|
int argc,
|
|
bool* auto_setup_scope) {
|
|
if (!Dart_IsString(name)) {
|
|
return NULL;
|
|
}
|
|
Dart_NativeFunction result = NULL;
|
|
if (auto_setup_scope == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
Dart_EnterScope();
|
|
const char* cname;
|
|
HandleError(Dart_StringToCString(name, &cname));
|
|
|
|
for (int i=0; function_list[i].name != NULL; ++i) {
|
|
if (strcmp(function_list[i].name, cname) == 0) {
|
|
*auto_setup_scope = true;
|
|
result = function_list[i].function;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (result != NULL) {
|
|
Dart_ExitScope();
|
|
return result;
|
|
}
|
|
|
|
for (int i=0; no_scope_function_list[i].name != NULL; ++i) {
|
|
if (strcmp(no_scope_function_list[i].name, cname) == 0) {
|
|
*auto_setup_scope = false;
|
|
result = no_scope_function_list[i].function;
|
|
break;
|
|
}
|
|
}
|
|
|
|
Dart_ExitScope();
|
|
return result;
|
|
}
|