| Index: sky/engine/bindings-dart/core/dart/DartJsInterop.cpp
|
| diff --git a/sky/engine/bindings-dart/core/dart/DartJsInterop.cpp b/sky/engine/bindings-dart/core/dart/DartJsInterop.cpp
|
| deleted file mode 100644
|
| index 4b4e8f9900d55c8fc3cbf0ad5d1e42a4883949f1..0000000000000000000000000000000000000000
|
| --- a/sky/engine/bindings-dart/core/dart/DartJsInterop.cpp
|
| +++ /dev/null
|
| @@ -1,1053 +0,0 @@
|
| -/*
|
| - * Copyright (C) 2013 Google Inc. All rights reserved.
|
| - *
|
| - * Redistribution and use in source and binary forms, with or without
|
| - * modification, are permitted provided that the following conditions are
|
| - * met:
|
| - *
|
| - * * Redistributions of source code must retain the above copyright
|
| - * notice, this list of conditions and the following disclaimer.
|
| - * * Redistributions in binary form must reproduce the above
|
| - * copyright notice, this list of conditions and the following disclaimer
|
| - * in the documentation and/or other materials provided with the
|
| - * distribution.
|
| - * * Neither the name of Google Inc. nor the names of its
|
| - * contributors may be used to endorse or promote products derived from
|
| - * this software without specific prior written permission.
|
| - *
|
| - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
| - * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
| - * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
| - * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
| - * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
| - * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
| - * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
| - * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
| - * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
| - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
| - * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
| - */
|
| -#include "config.h"
|
| -
|
| -#include "bindings/core/dart/DartJsInterop.h"
|
| -
|
| -#include "bindings/core/dart/DartDOMWrapper.h"
|
| -#include "bindings/core/dart/DartHandleProxy.h"
|
| -#include "bindings/core/dart/DartJsInteropData.h"
|
| -#include "bindings/core/dart/DartPersistentValue.h"
|
| -#include "bindings/core/dart/DartUtilities.h"
|
| -#include "bindings/core/dart/V8Converter.h"
|
| -#include "bindings/core/v8/V8Binding.h"
|
| -#include "bindings/core/v8/V8RecursionScope.h"
|
| -#include "bindings/core/v8/V8ScriptRunner.h"
|
| -
|
| -#include "wtf/StdLibExtras.h"
|
| -
|
| -#include <dart_api.h>
|
| -#include <limits>
|
| -
|
| -namespace blink {
|
| -
|
| -const int JsObject::dartClassId = _JsObjectClassId;
|
| -const int JsFunction::dartClassId = _JsFunctionClassId;
|
| -const int JsArray::dartClassId = _JsArrayClassId;
|
| -
|
| -static v8::Local<v8::FunctionTemplate> dartFunctionTemplate();
|
| -static v8::Local<v8::FunctionTemplate> dartObjectTemplate();
|
| -
|
| -template<typename CallbackInfo>
|
| -void setJsReturnValue(DartDOMData* domData, CallbackInfo info, Dart_Handle result)
|
| -{
|
| - if (Dart_IsError(result)) {
|
| - v8::Isolate* v8Isolate = v8::Isolate::GetCurrent();
|
| - V8ThrowException::throwException(v8::String::NewFromUtf8(v8Isolate, Dart_GetError(result)), v8Isolate);
|
| - } else {
|
| - Dart_Handle exception = 0;
|
| - v8::Local<v8::Value> ret = JsInterop::fromDart(domData, result, exception);
|
| - if (exception) {
|
| - V8ThrowException::throwException(V8Converter::stringToV8(Dart_ToString(exception)), v8::Isolate::GetCurrent());
|
| - return;
|
| - }
|
| - v8SetReturnValue(info, ret);
|
| - }
|
| -}
|
| -
|
| -static void functionInvocationCallback(const v8::FunctionCallbackInfo<v8::Value>& args)
|
| -{
|
| - DartScopes scopes(args.Holder());
|
| - Dart_Handle handle = scopes.handle;
|
| - DartDOMData* domData = DartDOMData::current();
|
| - ASSERT(domData);
|
| - ASSERT(DartUtilities::isFunction(domData, handle));
|
| -
|
| - Vector<Dart_Handle> dartFunctionArgs;
|
| - ASSERT(args.Length() == 1 || args.Length() == 2);
|
| - // If there is 1 argument, we assume it is a v8:Array or arguments, if
|
| - // there are 2 arguments, the first argument is "this" and the second
|
| - // argument is an array of arguments.
|
| - if (args.Length() > 1) {
|
| - dartFunctionArgs.append(JsInterop::toDart(args[0]));
|
| - }
|
| -
|
| - v8::Local<v8::Array> argsList = args[args.Length()-1].As<v8::Array>();
|
| - uint32_t argsListLength = argsList->Length();
|
| - for (uint32_t i = 0; i < argsListLength; i++) {
|
| - dartFunctionArgs.append(JsInterop::toDart(argsList->Get(i)));
|
| - }
|
| -
|
| - setJsReturnValue(domData, args, Dart_InvokeClosure(handle, dartFunctionArgs.size(), dartFunctionArgs.data()));
|
| -}
|
| -
|
| -static v8::Local<v8::ObjectTemplate> setupInstanceTemplate(v8::Local<v8::FunctionTemplate> proxyTemplate)
|
| -{
|
| - v8::Local<v8::ObjectTemplate> instanceTemplate = proxyTemplate->InstanceTemplate();
|
| - instanceTemplate->SetInternalFieldCount(1);
|
| - return instanceTemplate;
|
| -}
|
| -
|
| -static v8::Local<v8::FunctionTemplate> dartFunctionTemplate()
|
| -{
|
| - DEFINE_STATIC_LOCAL(v8::Persistent<v8::FunctionTemplate>, proxyTemplate, ());
|
| - v8::Local<v8::FunctionTemplate> proxyTemplateLocal;
|
| - v8::Isolate* v8Isolate = v8::Isolate::GetCurrent();
|
| - if (proxyTemplate.IsEmpty()) {
|
| - proxyTemplate.Reset(v8::Isolate::GetCurrent(), v8::FunctionTemplate::New(v8Isolate));
|
| - proxyTemplateLocal = v8::Local<v8::FunctionTemplate>::New(v8Isolate, proxyTemplate);
|
| - v8::Local<v8::ObjectTemplate> instanceTemplate = setupInstanceTemplate(proxyTemplateLocal);
|
| -
|
| - instanceTemplate->SetCallAsFunctionHandler(&functionInvocationCallback);
|
| - } else {
|
| - proxyTemplateLocal = v8::Local<v8::FunctionTemplate>::New(v8Isolate, proxyTemplate);
|
| - }
|
| - return proxyTemplateLocal;
|
| -}
|
| -
|
| -static v8::Local<v8::FunctionTemplate> dartObjectTemplate()
|
| -{
|
| - DEFINE_STATIC_LOCAL(v8::Persistent<v8::FunctionTemplate>, proxyTemplate, ());
|
| - v8::Local<v8::FunctionTemplate> proxyTemplateLocal;
|
| - v8::Isolate* v8Isolate = v8::Isolate::GetCurrent();
|
| - if (proxyTemplate.IsEmpty()) {
|
| - proxyTemplate.Reset(v8Isolate, v8::FunctionTemplate::New(v8Isolate));
|
| - proxyTemplateLocal = v8::Local<v8::FunctionTemplate>::New(v8Isolate, proxyTemplate);
|
| - proxyTemplateLocal->SetClassName(v8::String::NewFromUtf8(v8Isolate, "DartObject"));
|
| - setupInstanceTemplate(proxyTemplateLocal);
|
| - } else {
|
| - proxyTemplateLocal = v8::Local<v8::FunctionTemplate>::New(v8Isolate, proxyTemplate);
|
| - }
|
| - return proxyTemplateLocal;
|
| -}
|
| -
|
| -/**
|
| - * Helper class to manage scopes needed for JSInterop code.
|
| - */
|
| -class JsInteropScopes {
|
| -public:
|
| - Dart_NativeArguments args;
|
| - v8::Context::Scope v8Scope;
|
| - v8::TryCatch tryCatch;
|
| -
|
| - JsInteropScopes(Dart_NativeArguments args)
|
| - : args(args)
|
| - , v8Scope(DartUtilities::currentV8Context())
|
| - {
|
| - ASSERT(v8::Isolate::GetCurrent());
|
| - }
|
| -
|
| - ~JsInteropScopes()
|
| - {
|
| - // The user is expected to call handleJsException before the scope is
|
| - // closed so that V8 exceptions are properly sent back to Dart.
|
| - ASSERT(!tryCatch.HasCaught());
|
| - }
|
| -
|
| - bool handleJsException(Dart_Handle* exception)
|
| - {
|
| - if (!tryCatch.HasCaught())
|
| - return false;
|
| - // FIXME: terminate v8 if tryCatch.CanContinue() is false.
|
| - ASSERT(tryCatch.CanContinue());
|
| - ASSERT(exception);
|
| - v8::Handle<v8::Value> ex(tryCatch.Exception()->ToString());
|
| - if (ex.IsEmpty()) {
|
| - *exception = Dart_NewStringFromCString("Empty JavaScript exception");
|
| - } else {
|
| - *exception = V8Converter::stringToDart(ex);
|
| - }
|
| - tryCatch.Reset();
|
| - return true;
|
| - }
|
| -
|
| - void setReturnValue(Dart_Handle ret)
|
| - {
|
| - ASSERT(!tryCatch.HasCaught());
|
| - Dart_SetReturnValue(args, ret);
|
| - }
|
| -
|
| - void setReturnValue(v8::Local<v8::Value> ret)
|
| - {
|
| - ASSERT(!tryCatch.HasCaught());
|
| - Dart_SetReturnValue(args, JsInterop::toDart(ret));
|
| - ASSERT(!tryCatch.HasCaught());
|
| - }
|
| -
|
| - void setReturnValueInteger(int64_t ret)
|
| - {
|
| - ASSERT(!tryCatch.HasCaught());
|
| - Dart_SetIntegerReturnValue(args, ret);
|
| - }
|
| -};
|
| -
|
| -PassRefPtr<JsObject> JsObject::create(v8::Local<v8::Object> v8Handle)
|
| -{
|
| - return adoptRef(new JsObject(v8Handle));
|
| -}
|
| -
|
| -v8::Local<v8::Value> JsInterop::fromDart(DartDOMData* domData, Dart_Handle handle, Dart_Handle& exception)
|
| -{
|
| - v8::Handle<v8::Value> value = V8Converter::toV8IfPrimitive(domData, handle, exception);
|
| - if (!value.IsEmpty() || exception)
|
| - return value;
|
| -
|
| - value = V8Converter::toV8IfBrowserNative(domData, handle, exception);
|
| - if (!value.IsEmpty() || exception)
|
| - return value;
|
| -
|
| - if (DartDOMWrapper::subtypeOf(handle, JsObject::dartClassId)) {
|
| - JsObject* object = DartDOMWrapper::unwrapDartWrapper<JsObject>(domData, handle, exception);
|
| - if (exception)
|
| - return v8::Local<v8::Value>();
|
| - return object->localV8Object();
|
| - }
|
| -
|
| - if (DartUtilities::isFunction(domData, handle)) {
|
| - v8::Local<v8::Object> functionProxy = dartFunctionTemplate()->InstanceTemplate()->NewInstance();
|
| - DartHandleProxy::writePointerToProxy(functionProxy, handle);
|
| - // The raw functionProxy doesn't behave enough like a true JS function
|
| - // so we wrap it in a true JS function.
|
| - return domData->jsInteropData()->wrapDartFunction()->Call(functionProxy, 0, 0);
|
| - }
|
| -
|
| - v8::Local<v8::Object> proxy;
|
| - ASSERT(Dart_IsInstance(handle));
|
| - proxy = dartObjectTemplate()->InstanceTemplate()->NewInstance();
|
| - DartHandleProxy::writePointerToProxy(proxy, handle);
|
| - v8::Isolate* v8Isolate = v8::Isolate::GetCurrent();
|
| - proxy->SetHiddenValue(v8::String::NewFromUtf8(v8Isolate, "dartProxy"), v8::Boolean::New(v8Isolate, true));
|
| -
|
| - return proxy;
|
| -}
|
| -
|
| -JsObject::JsObject(v8::Local<v8::Object> v8Handle)
|
| -{
|
| - v8::Isolate* isolate = v8::Isolate::GetCurrent();
|
| - v8::Persistent<v8::Object> persistentHandle;
|
| - v8Object.Reset(isolate, v8Handle);
|
| -}
|
| -
|
| -v8::Local<v8::Object> JsObject::localV8Object()
|
| -{
|
| - return v8::Local<v8::Object>::New(v8::Isolate::GetCurrent(), v8Object);
|
| -}
|
| -
|
| -Dart_Handle JsInterop::toDart(v8::Local<v8::Value> v8Handle)
|
| -{
|
| - Dart_Handle handle = V8Converter::toDartIfPrimitive(v8Handle);
|
| - if (handle)
|
| - return handle;
|
| -
|
| - ASSERT(v8Handle->IsObject());
|
| - v8::Handle<v8::Object> object = v8Handle.As<v8::Object>();
|
| - Dart_Handle exception = 0;
|
| - handle = V8Converter::toDartIfBrowserNative(object, object->CreationContext()->GetIsolate(), exception);
|
| - ASSERT(!exception);
|
| - if (handle)
|
| - return handle;
|
| -
|
| - // Unwrap objects passed from Dart to JS that are being passed back to
|
| - // Dart. FIXME: we do not yet handle unwrapping JS functions passed
|
| - // from Dart to JS as we have to wrap them with true JS Function objects.
|
| - // If this use case is important we can support it at the cost of hanging
|
| - // an extra expando off the JS function wrapping the Dart function.
|
| - if (DartHandleProxy::isDartProxy(v8Handle)) {
|
| - DartPersistentValue* scriptValue = DartHandleProxy::readPointerFromProxy(v8Handle);
|
| - ASSERT(scriptValue->isIsolateAlive());
|
| - return scriptValue->value();
|
| - }
|
| -
|
| - return JsObject::toDart(object);
|
| -}
|
| -
|
| -Dart_Handle JsObject::toDart(v8::Local<v8::Object> object)
|
| -{
|
| - // FIXME: perform caching so that === can be used.
|
| - if (object->IsFunction()) {
|
| - RefPtr<JsFunction> jsFunction = JsFunction::create(object.As<v8::Function>());
|
| - return JsFunction::toDart(jsFunction);
|
| - }
|
| -
|
| - if (object->IsArray()) {
|
| - RefPtr<JsArray> jsArray = JsArray::create(object.As<v8::Array>());
|
| - return JsArray::toDart(jsArray);
|
| - }
|
| -
|
| - RefPtr<JsObject> jsObject = JsObject::create(object);
|
| - return JsObject::toDart(jsObject);
|
| -}
|
| -
|
| -Dart_Handle JsObject::toDart(PassRefPtr<JsObject> jsObject)
|
| -{
|
| - return DartDOMWrapper::createWrapper<JsObject>(DartDOMData::current(), jsObject.get(), JsObject::dartClassId);
|
| -}
|
| -
|
| -JsObject::~JsObject()
|
| -{
|
| - v8Object.Reset();
|
| -}
|
| -
|
| -Dart_Handle JsFunction::toDart(PassRefPtr<JsFunction> jsFunction)
|
| -{
|
| - return DartDOMWrapper::createWrapper<JsFunction>(DartDOMData::current(), jsFunction.get(), JsFunction::dartClassId);
|
| -}
|
| -
|
| -JsFunction::JsFunction(v8::Local<v8::Function> v8Handle) : JsObject(v8Handle) { }
|
| -
|
| -PassRefPtr<JsFunction> JsFunction::create(v8::Local<v8::Function> v8Handle)
|
| -{
|
| - return adoptRef(new JsFunction(v8Handle));
|
| -}
|
| -
|
| -v8::Local<v8::Function> JsFunction::localV8Function()
|
| -{
|
| - return localV8Object().As<v8::Function>();
|
| -}
|
| -
|
| -Dart_Handle JsArray::toDart(PassRefPtr<JsArray> jsArray)
|
| -{
|
| - return DartDOMWrapper::createWrapper<JsArray>(DartDOMData::current(), jsArray.get(), JsArray::dartClassId);
|
| -}
|
| -
|
| -JsArray::JsArray(v8::Local<v8::Array> v8Handle) : JsObject(v8Handle) { }
|
| -
|
| -PassRefPtr<JsArray> JsArray::create(v8::Local<v8::Array> v8Handle)
|
| -{
|
| - return adoptRef(new JsArray(v8Handle));
|
| -}
|
| -
|
| -v8::Local<v8::Array> JsArray::localV8Array()
|
| -{
|
| - return localV8Object().As<v8::Array>();
|
| -}
|
| -
|
| -namespace JsInteropInternal {
|
| -
|
| -typedef HashMap<Dart_Handle, v8::Handle<v8::Value> > DartHandleToV8Map;
|
| -v8::Handle<v8::Value> jsifyHelper(DartDOMData*, Dart_Handle value, DartHandleToV8Map&, Dart_Handle& exception);
|
| -
|
| -void argsListToV8(DartDOMData* domData, Dart_Handle args, Vector<v8::Local<v8::Value> >* v8Args, Dart_Handle& exception)
|
| -{
|
| - if (Dart_IsNull(args))
|
| - return;
|
| -
|
| - if (!Dart_IsList(args)) {
|
| - exception = Dart_NewStringFromCString("args not type list");
|
| - return;
|
| - }
|
| -
|
| - intptr_t argsLength = 0;
|
| - Dart_ListLength(args, &argsLength);
|
| - for (intptr_t i = 0; i < argsLength; i++) {
|
| - v8Args->append(JsInterop::fromDart(domData, Dart_ListGetAt(args, i), exception));
|
| - if (exception)
|
| - return;
|
| - }
|
| -}
|
| -
|
| -void argsListToV8DebuggerOnly(DartDOMData* domData, Dart_Handle args, Vector<v8::Local<v8::Value> >* v8Args, Dart_Handle& exception)
|
| -{
|
| - if (Dart_IsNull(args))
|
| - return;
|
| -
|
| - if (!Dart_IsList(args)) {
|
| - exception = Dart_NewStringFromCString("args not type list");
|
| - return;
|
| - }
|
| -
|
| - intptr_t argsLength = 0;
|
| - Dart_ListLength(args, &argsLength);
|
| - for (intptr_t i = 0; i < argsLength; i++) {
|
| - v8Args->append(DartHandleProxy::create(Dart_ListGetAt(args, i)));
|
| - }
|
| -}
|
| -
|
| -static void jsObjectConstructorCallback(Dart_NativeArguments args)
|
| -{
|
| - Dart_Handle exception = 0;
|
| - {
|
| - JsInteropScopes scopes(args);
|
| - DartDOMData* domData = static_cast<DartDOMData*>(Dart_GetNativeIsolateData(args));
|
| - v8::Local<v8::Value> constructorArg = JsInterop::fromDart(domData, Dart_GetNativeArgument(args, 0), exception);
|
| - if (exception)
|
| - goto fail;
|
| -
|
| - if (!constructorArg->IsFunction()) {
|
| - exception = Dart_NewStringFromCString("constructor not a function");
|
| - goto fail;
|
| - }
|
| -
|
| - Vector<v8::Local<v8::Value> > v8Args;
|
| - argsListToV8(domData, Dart_GetNativeArgument(args, 1), &v8Args, exception);
|
| -
|
| - v8::Local<v8::Value> ret = constructorArg.As<v8::Function>()->CallAsConstructor(v8Args.size(), v8Args.data());
|
| - crashIfV8IsDead();
|
| -
|
| - if (scopes.handleJsException(&exception))
|
| - goto fail;
|
| -
|
| - // Intentionally skip auto-conversion in this case as the user expects
|
| - // a JSObject. FIXME: evaluate if this is the right solution.
|
| - // Alternately, we could throw an exception.
|
| - if (ret->IsObject()) {
|
| - scopes.setReturnValue(JsObject::toDart(ret.As<v8::Object>()));
|
| - } else {
|
| - // This will throw an exception in Dart checked mode.
|
| - scopes.setReturnValue(ret);
|
| - }
|
| - return;
|
| - }
|
| -
|
| -fail:
|
| - Dart_ThrowException(exception);
|
| - ASSERT_NOT_REACHED();
|
| -}
|
| -
|
| -static void identityEqualityCallback(Dart_NativeArguments args)
|
| -{
|
| - Dart_Handle exception = 0;
|
| - {
|
| - JsInteropScopes scopes(args);
|
| - DartDOMData* domData = static_cast<DartDOMData*>(Dart_GetNativeIsolateData(args));
|
| - v8::Local<v8::Value> a = JsInterop::fromDart(domData, Dart_GetNativeArgument(args, 0), exception);
|
| - if (exception)
|
| - goto fail;
|
| - v8::Local<v8::Value> b = JsInterop::fromDart(domData, Dart_GetNativeArgument(args, 1), exception);
|
| - if (exception)
|
| - goto fail;
|
| -
|
| - bool strictEquals = a->StrictEquals(b);
|
| -
|
| - if (scopes.handleJsException(&exception))
|
| - goto fail;
|
| - scopes.setReturnValue(DartUtilities::boolToDart(strictEquals));
|
| - return;
|
| - }
|
| -
|
| -fail:
|
| - Dart_ThrowException(exception);
|
| - ASSERT_NOT_REACHED();
|
| -}
|
| -
|
| -static void getterCallback(Dart_NativeArguments args)
|
| -{
|
| - Dart_Handle exception = 0;
|
| - {
|
| - JsInteropScopes scopes(args);
|
| - JsObject* receiver = DartDOMWrapper::receiver<JsObject>(args);
|
| - v8::Local<v8::Object> v8Receiver = receiver->localV8Object();
|
| - Dart_Handle index = Dart_GetNativeArgument(args, 1);
|
| - uint64_t intIndex = 0;
|
| - v8::Local<v8::Value> ret;
|
| -
|
| - if (Dart_IsInteger(index)) {
|
| - bool isUint64 = false;
|
| - Dart_IntegerFitsIntoUint64(index, &isUint64);
|
| - if (isUint64) {
|
| - Dart_Handle ALLOW_UNUSED result = Dart_IntegerToUint64(index, &intIndex);
|
| - if (intIndex <= std::numeric_limits<uint32_t>::max()) {
|
| - ASSERT(!Dart_IsError(result));
|
| - ret = v8Receiver->Get((uint32_t)intIndex);
|
| - } else {
|
| - ret = v8Receiver->Get(V8Converter::numberToV8(index));
|
| - }
|
| - } else {
|
| - ret = v8Receiver->Get(V8Converter::numberToV8(index));
|
| - }
|
| - } else if (Dart_IsString(index)) {
|
| - ret = v8Receiver->Get(V8Converter::stringToV8(index));
|
| - } else if (Dart_IsNumber(index)) {
|
| - ret = v8Receiver->Get(V8Converter::numberToV8(index));
|
| - } else {
|
| - ret = v8Receiver->Get(V8Converter::stringToV8(Dart_ToString(index)));
|
| - }
|
| -
|
| - if (scopes.handleJsException(&exception))
|
| - goto fail;
|
| - scopes.setReturnValue(ret);
|
| - return;
|
| - }
|
| -
|
| -fail:
|
| - Dart_ThrowException(exception);
|
| - ASSERT_NOT_REACHED();
|
| -}
|
| -
|
| -static void hasPropertyCallback(Dart_NativeArguments args)
|
| -{
|
| - Dart_Handle exception = 0;
|
| - {
|
| - JsInteropScopes scopes(args);
|
| - JsObject* receiver = DartDOMWrapper::receiver<JsObject>(args);
|
| - v8::Local<v8::Object> v8Receiver = receiver->localV8Object();
|
| - Dart_Handle property = Dart_GetNativeArgument(args, 1);
|
| -
|
| - if (!Dart_IsString(property))
|
| - property = Dart_ToString(property);
|
| -
|
| - bool hasProperty = v8Receiver->Has(V8Converter::stringToV8(property));
|
| - if (scopes.handleJsException(&exception))
|
| - goto fail;
|
| - scopes.setReturnValue(DartUtilities::boolToDart(hasProperty));
|
| - return;
|
| - }
|
| -
|
| -fail:
|
| - Dart_ThrowException(exception);
|
| - ASSERT_NOT_REACHED();
|
| -}
|
| -
|
| -static void deletePropertyCallback(Dart_NativeArguments args)
|
| -{
|
| - Dart_Handle exception = 0;
|
| - {
|
| - JsInteropScopes scopes(args);
|
| - JsObject* receiver = DartDOMWrapper::receiver<JsObject>(args);
|
| - v8::Local<v8::Object> v8Receiver = receiver->localV8Object();
|
| - Dart_Handle property = Dart_GetNativeArgument(args, 1);
|
| - if (!Dart_IsString(property))
|
| - property = Dart_ToString(property);
|
| -
|
| - v8Receiver->Delete(V8Converter::stringToV8(property));
|
| - if (scopes.handleJsException(&exception))
|
| - goto fail;
|
| - return;
|
| - }
|
| -
|
| -fail:
|
| - Dart_ThrowException(exception);
|
| - ASSERT_NOT_REACHED();
|
| -}
|
| -
|
| -static void instanceofCallback(Dart_NativeArguments args)
|
| -{
|
| - Dart_Handle exception = 0;
|
| - {
|
| - JsInteropScopes scopes(args);
|
| - DartDOMData* domData = static_cast<DartDOMData*>(Dart_GetNativeIsolateData(args));
|
| - JsObject* receiver = DartDOMWrapper::receiver<JsObject>(args);
|
| - v8::Local<v8::Object> v8Receiver = receiver->localV8Object();
|
| - v8::Local<v8::Value> type = JsInterop::fromDart(domData, Dart_GetNativeArgument(args, 1), exception);
|
| -
|
| - // FIXME: we could optimize the following lines slightly as the return
|
| - // type is bool.
|
| - v8::Local<v8::Value> ret = domData->jsInteropData()->instanceofFunction()->Call(v8Receiver, 1, &type);
|
| - if (scopes.handleJsException(&exception))
|
| - goto fail;
|
| - scopes.setReturnValue(ret);
|
| - return;
|
| - }
|
| -
|
| -fail:
|
| - Dart_ThrowException(exception);
|
| - ASSERT_NOT_REACHED();
|
| -}
|
| -
|
| -static void setterCallback(Dart_NativeArguments args)
|
| -{
|
| - Dart_Handle exception = 0;
|
| - {
|
| - JsInteropScopes scopes(args);
|
| - DartDOMData* domData = static_cast<DartDOMData*>(Dart_GetNativeIsolateData(args));
|
| - JsObject* receiver = DartDOMWrapper::receiver<JsObject>(args);
|
| - v8::Local<v8::Object> v8Receiver = receiver->localV8Object();
|
| - Dart_Handle index = Dart_GetNativeArgument(args, 1);
|
| - v8::Local<v8::Value> value = JsInterop::fromDart(domData, Dart_GetNativeArgument(args, 2), exception);
|
| - if (exception)
|
| - goto fail;
|
| - uint64_t intIndex = 0;
|
| - bool ret = false;
|
| - if (Dart_IsInteger(index)) {
|
| - bool isUint64 = false;
|
| - Dart_IntegerFitsIntoUint64(index, &isUint64);
|
| - if (isUint64) {
|
| - Dart_Handle ALLOW_UNUSED result = Dart_IntegerToUint64(index, &intIndex);
|
| - if (intIndex <= std::numeric_limits<uint32_t>::max()) {
|
| - ASSERT(!Dart_IsError(result));
|
| - ret = v8Receiver->Set((uint32_t)intIndex, value);
|
| - } else {
|
| - ret = v8Receiver->Set(V8Converter::numberToV8(index), value);
|
| - }
|
| - } else {
|
| - ret = v8Receiver->Set(V8Converter::numberToV8(index), value);
|
| - }
|
| - } else if (Dart_IsString(index)) {
|
| - ret = v8Receiver->Set(V8Converter::stringToV8(index), value);
|
| - } else if (Dart_IsNumber(index)) {
|
| - ret = v8Receiver->Set(V8Converter::numberToV8(index), value);
|
| - } else {
|
| - ret = v8Receiver->Set(V8Converter::stringToV8(Dart_ToString(index)), value);
|
| - }
|
| -
|
| - if (scopes.handleJsException(&exception))
|
| - goto fail;
|
| - scopes.setReturnValue(DartUtilities::boolToDart(ret));
|
| - return;
|
| - }
|
| -
|
| -fail:
|
| - Dart_ThrowException(exception);
|
| - ASSERT_NOT_REACHED();
|
| -}
|
| -
|
| -static void hashCodeCallback(Dart_NativeArguments args)
|
| -{
|
| - Dart_Handle exception = 0;
|
| - {
|
| - JsInteropScopes scopes(args);
|
| - JsObject* receiver = DartDOMWrapper::receiver<JsObject>(args);
|
| - int hashCode = receiver->localV8Object()->GetIdentityHash();
|
| - // FIXME: salt the v8 hashcode so we don't leak information about v8
|
| - // memory allocation.
|
| - if (scopes.handleJsException(&exception))
|
| - goto fail;
|
| - scopes.setReturnValueInteger(hashCode);
|
| - return;
|
| - }
|
| -
|
| -fail:
|
| - Dart_ThrowException(exception);
|
| - ASSERT_NOT_REACHED();
|
| -}
|
| -
|
| -static void callMethodCallback(Dart_NativeArguments args)
|
| -{
|
| - Dart_Handle exception = 0;
|
| - {
|
| - JsInteropScopes scopes(args);
|
| - DartDOMData* domData = static_cast<DartDOMData*>(Dart_GetNativeIsolateData(args));
|
| - JsObject* receiver = DartDOMWrapper::receiver<JsObject>(args);
|
| - v8::Local<v8::Object> v8Receiver = receiver->localV8Object();
|
| -
|
| - Dart_Handle name = Dart_GetNativeArgument(args, 1);
|
| - Vector<v8::Local<v8::Value> > v8Args;
|
| - argsListToV8(domData, Dart_GetNativeArgument(args, 2), &v8Args, exception);
|
| - if (exception)
|
| - goto fail;
|
| - if (!Dart_IsString(name))
|
| - name = Dart_ToString(name);
|
| -
|
| - v8::Local<v8::Value> value = v8Receiver->Get(V8Converter::stringToV8(name));
|
| - v8::Local<v8::Value> ret;
|
| - if (value->IsFunction()) {
|
| - ret = V8ScriptRunner::callFunction(value.As<v8::Function>(), DartUtilities::scriptExecutionContext(), receiver->localV8Object(), v8Args.size(), v8Args.data(), v8::Isolate::GetCurrent());
|
| - } else if (value->IsObject()) {
|
| - ret = V8ScriptRunner::callAsFunction(v8::Isolate::GetCurrent(), value.As<v8::Object>(), receiver->localV8Object(), v8Args.size(), v8Args.data());
|
| - } else {
|
| - // FIXME: we currently convert this exception to a NoSuchMethod
|
| - // exception in the Dart code that wraps this native method.
|
| - // Consider throwing a NoSuchMethod exception directly instead.
|
| - exception = Dart_NewStringFromCString("property is not a function");
|
| - goto fail;
|
| - }
|
| -
|
| - if (scopes.handleJsException(&exception))
|
| - goto fail;
|
| - scopes.setReturnValue(ret);
|
| - return;
|
| - }
|
| -
|
| -fail:
|
| - Dart_ThrowException(exception);
|
| - ASSERT_NOT_REACHED();
|
| -}
|
| -
|
| -static void newJsArrayCallback(Dart_NativeArguments args)
|
| -{
|
| - JsInteropScopes scopes(args);
|
| - scopes.setReturnValue(JsObject::toDart(v8::Array::New(v8::Isolate::GetCurrent())));
|
| - return;
|
| -}
|
| -
|
| -static void newJsArrayFromSafeListCallback(Dart_NativeArguments args)
|
| -{
|
| - Dart_Handle exception = 0;
|
| - {
|
| - JsInteropScopes scopes(args);
|
| - DartDOMData* domData = static_cast<DartDOMData*>(Dart_GetNativeIsolateData(args));
|
| - Dart_Handle list = Dart_GetNativeArgument(args, 0);
|
| - // Code on the Dart side insures this arg is a native Dart list.
|
| - ASSERT(Dart_IsList(list));
|
| -
|
| - intptr_t length = 0;
|
| - Dart_Handle result = Dart_ListLength(list, &length);
|
| - ASSERT(!Dart_IsError(result));
|
| - v8::Local<v8::Array> array = v8::Array::New(v8::Isolate::GetCurrent(), length);
|
| -
|
| - for (intptr_t i = 0; i < length; ++i) {
|
| - result = Dart_ListGetAt(list, i);
|
| - ASSERT(!Dart_IsError(result));
|
| - v8::Handle<v8::Value> v8value = JsInterop::fromDart(domData, result, exception);
|
| - if (exception)
|
| - goto fail;
|
| -
|
| - array->Set(i, v8value);
|
| - }
|
| - scopes.setReturnValue(array);
|
| - return;
|
| - }
|
| -
|
| -fail:
|
| - Dart_ThrowException(exception);
|
| - ASSERT_NOT_REACHED();
|
| -}
|
| -
|
| -
|
| -static void jsArrayLengthCallback(Dart_NativeArguments args)
|
| -{
|
| - Dart_Handle exception = 0;
|
| - {
|
| - JsInteropScopes scopes(args);
|
| - JsArray* receiver = DartDOMWrapper::receiver<JsArray>(args);
|
| - uint32_t length = receiver->localV8Array()->Length();
|
| - if (scopes.handleJsException(&exception))
|
| - goto fail;
|
| - scopes.setReturnValueInteger(length);
|
| - return;
|
| - }
|
| -
|
| -fail:
|
| - Dart_ThrowException(exception);
|
| - ASSERT_NOT_REACHED();
|
| -}
|
| -
|
| -static void fromBrowserObjectCallback(Dart_NativeArguments args)
|
| -{
|
| - Dart_Handle exception = 0;
|
| - {
|
| - JsInteropScopes scopes(args);
|
| - DartDOMData* domData = static_cast<DartDOMData*>(Dart_GetNativeIsolateData(args));
|
| -
|
| - v8::Local<v8::Value> ret = V8Converter::toV8IfBrowserNative(domData, Dart_GetNativeArgument(args, 0), exception);
|
| - if (ret.IsEmpty()) {
|
| - exception = Dart_NewStringFromCString("object must be an Node, ArrayBuffer, Blob, ImageData, or IDBKeyRange");
|
| - goto fail;
|
| - }
|
| - if (exception)
|
| - goto fail;
|
| - ASSERT(ret->IsObject());
|
| - if (scopes.handleJsException(&exception))
|
| - goto fail;
|
| - scopes.setReturnValue(JsObject::toDart(ret.As<v8::Object>()));
|
| - return;
|
| - }
|
| -
|
| -fail:
|
| - Dart_ThrowException(exception);
|
| - ASSERT_NOT_REACHED();
|
| -}
|
| -
|
| -static void applyCallback(Dart_NativeArguments args)
|
| -{
|
| - Dart_Handle exception = 0;
|
| - {
|
| - JsInteropScopes scopes(args);
|
| - DartDOMData* domData = static_cast<DartDOMData*>(Dart_GetNativeIsolateData(args));
|
| - JsFunction* receiver = DartDOMWrapper::receiver<JsFunction>(args);
|
| -
|
| - Vector<v8::Local<v8::Value> > v8Args;
|
| - argsListToV8(domData, Dart_GetNativeArgument(args, 1), &v8Args, exception);
|
| - if (exception)
|
| - goto fail;
|
| -
|
| - v8::Local<v8::Value> thisArg;
|
| - Dart_Handle thisArgDart = Dart_GetNativeArgument(args, 2);
|
| - if (Dart_IsNull(thisArgDart)) {
|
| - // Use the global v8 object if no Dart thisArg was passed in.
|
| - thisArg = DartUtilities::currentV8Context()->Global();
|
| - } else {
|
| - thisArg = JsInterop::fromDart(domData, thisArgDart, exception);
|
| - if (exception)
|
| - goto fail;
|
| - if (!thisArg->IsObject()) {
|
| - exception = Dart_NewStringFromCString("thisArg is not an object");
|
| - goto fail;
|
| - }
|
| - }
|
| -
|
| - v8::Local<v8::Value> ret = V8ScriptRunner::callFunction(receiver->localV8Function(), DartUtilities::scriptExecutionContext(), thisArg.As<v8::Object>(), v8Args.size(), v8Args.data(), v8::Isolate::GetCurrent());
|
| - if (scopes.handleJsException(&exception))
|
| - goto fail;
|
| - scopes.setReturnValue(ret);
|
| - return;
|
| - }
|
| -
|
| -fail:
|
| - Dart_ThrowException(exception);
|
| - ASSERT_NOT_REACHED();
|
| -}
|
| -
|
| -static void applyDebuggerOnlyCallback(Dart_NativeArguments args)
|
| -{
|
| - Dart_Handle exception = 0;
|
| - {
|
| - JsInteropScopes scopes(args);
|
| - DartDOMData* domData = static_cast<DartDOMData*>(Dart_GetNativeIsolateData(args));
|
| - JsFunction* receiver = DartDOMWrapper::receiver<JsFunction>(args);
|
| -
|
| - Vector<v8::Local<v8::Value> > v8Args;
|
| - argsListToV8DebuggerOnly(domData, Dart_GetNativeArgument(args, 1), &v8Args, exception);
|
| - if (exception)
|
| - goto fail;
|
| -
|
| - v8::Local<v8::Value> thisArg;
|
| - Dart_Handle thisArgDart = Dart_GetNativeArgument(args, 2);
|
| - if (Dart_IsNull(thisArgDart)) {
|
| - // Use the global v8 object if no Dart thisArg was passed in.
|
| - thisArg = DartUtilities::currentV8Context()->Global();
|
| - } else {
|
| - thisArg = JsInterop::fromDart(domData, thisArgDart, exception);
|
| - if (exception)
|
| - goto fail;
|
| - if (!thisArg->IsObject()) {
|
| - exception = Dart_NewStringFromCString("thisArg is not an object");
|
| - goto fail;
|
| - }
|
| - }
|
| -
|
| - v8::Local<v8::Value> ret = V8ScriptRunner::callFunction(receiver->localV8Function(), DartUtilities::scriptExecutionContext(), thisArg.As<v8::Object>(), v8Args.size(), v8Args.data(), v8::Isolate::GetCurrent());
|
| - if (scopes.handleJsException(&exception))
|
| - goto fail;
|
| - scopes.setReturnValue(ret);
|
| - return;
|
| - }
|
| -
|
| -fail:
|
| - Dart_ThrowException(exception);
|
| - ASSERT_NOT_REACHED();
|
| -}
|
| -
|
| -static void toStringCallback(Dart_NativeArguments args)
|
| -{
|
| - Dart_Handle exception = 0;
|
| - {
|
| - JsInteropScopes scopes(args);
|
| - JsObject* receiver = DartDOMWrapper::receiver<JsObject>(args);
|
| - v8::Local<v8::Object> v8Object = receiver->localV8Object();
|
| - if (scopes.handleJsException(&exception))
|
| - goto fail;
|
| - if (v8Object.IsEmpty()) {
|
| - exception = Dart_NewStringFromCString("Invalid v8 handle");
|
| - goto fail;
|
| - }
|
| -
|
| - v8::Local<v8::String> v8String = v8Object->ToString();
|
| - if (scopes.handleJsException(&exception))
|
| - goto fail;
|
| - scopes.setReturnValue(v8String);
|
| - return;
|
| - }
|
| -fail:
|
| - Dart_ThrowException(exception);
|
| - ASSERT_NOT_REACHED();
|
| -}
|
| -
|
| -static void contextCallback(Dart_NativeArguments args)
|
| -{
|
| - v8::Local<v8::Context> v8Context = DartUtilities::currentV8Context();
|
| - v8::Context::Scope scope(v8Context);
|
| - Dart_SetReturnValue(args, JsObject::toDart(v8Context->Global()));
|
| -}
|
| -
|
| -v8::Handle<v8::Value> mapToV8(DartDOMData* domData, Dart_Handle value, DartHandleToV8Map& map, Dart_Handle& exception)
|
| -{
|
| - Dart_Handle asList = DartUtilities::invokeUtilsMethod("convertMapToList", 1, &value);
|
| - if (!DartUtilities::checkResult(asList, exception))
|
| - return v8::Handle<v8::Value>();
|
| - ASSERT(Dart_IsList(asList));
|
| -
|
| - // Now we have a list [key, value, key, value, ....], create a v8 object and set necesary
|
| - // properties on it.
|
| - v8::Handle<v8::Object> object = v8::Object::New(v8::Isolate::GetCurrent());
|
| - map.set(value, object);
|
| -
|
| - // We converted to internal Dart list, methods shouldn't throw exceptions now.
|
| - intptr_t length = 0;
|
| - Dart_Handle ALLOW_UNUSED result = Dart_ListLength(asList, &length);
|
| - ASSERT(!Dart_IsError(result));
|
| - ASSERT(!(length % 2));
|
| - for (intptr_t i = 0; i < length; i += 2) {
|
| - v8::Handle<v8::Value> key = jsifyHelper(domData, Dart_ListGetAt(asList, i), map, exception);
|
| - if (exception)
|
| - return v8::Handle<v8::Value>();
|
| - v8::Handle<v8::Value> value = jsifyHelper(domData, Dart_ListGetAt(asList, i + 1), map, exception);
|
| - if (exception)
|
| - return v8::Handle<v8::Value>();
|
| -
|
| - object->Set(key, value);
|
| - }
|
| -
|
| - return object;
|
| -}
|
| -
|
| -v8::Handle<v8::Value> listToV8(DartDOMData* domData, Dart_Handle value, DartHandleToV8Map& map, Dart_Handle& exception)
|
| -{
|
| - ASSERT(Dart_IsList(value));
|
| -
|
| - intptr_t length = 0;
|
| - Dart_Handle result = Dart_ListLength(value, &length);
|
| - if (!DartUtilities::checkResult(result, exception))
|
| - return v8::Handle<v8::Value>();
|
| -
|
| - v8::Local<v8::Array> array = v8::Array::New(v8::Isolate::GetCurrent(), length);
|
| - map.set(value, array);
|
| -
|
| - for (intptr_t i = 0; i < length; ++i) {
|
| - result = Dart_ListGetAt(value, i);
|
| - if (!DartUtilities::checkResult(result, exception))
|
| - return v8::Handle<v8::Value>();
|
| - v8::Handle<v8::Value> v8value = jsifyHelper(domData, result, map, exception);
|
| - if (exception)
|
| - return v8::Handle<v8::Value>();
|
| - array->Set(i, v8value);
|
| - }
|
| -
|
| - return array;
|
| -}
|
| -
|
| -v8::Handle<v8::Value> jsifyHelper(DartDOMData* domData, Dart_Handle value, DartHandleToV8Map& map, Dart_Handle& exception)
|
| -{
|
| - DartHandleToV8Map::iterator iter = map.find(value);
|
| - if (iter != map.end())
|
| - return iter->value;
|
| -
|
| - if (Dart_IsList(value))
|
| - return listToV8(domData, value, map, exception);
|
| -
|
| - bool isMap = DartUtilities::dartToBool(DartUtilities::invokeUtilsMethod("isMap", 1, &value), exception);
|
| - ASSERT(!exception);
|
| - if (isMap)
|
| - return mapToV8(domData, value, map, exception);
|
| -
|
| - Dart_Handle maybeList = DartUtilities::invokeUtilsMethod("toListIfIterable", 1, &value);
|
| - if (Dart_IsList(maybeList))
|
| - return listToV8(domData, maybeList, map, exception);
|
| -
|
| - v8::Handle<v8::Value> ret = JsInterop::fromDart(domData, value, exception);
|
| - map.set(value, ret);
|
| - return ret;
|
| -}
|
| -
|
| -static void jsifyCallback(Dart_NativeArguments args)
|
| -{
|
| - Dart_Handle exception = 0;
|
| - {
|
| - JsInteropScopes scopes(args);
|
| - Dart_Handle value = Dart_GetNativeArgument(args, 0);
|
| - DartDOMData* domData = static_cast<DartDOMData*>(Dart_GetNativeIsolateData(args));
|
| - DartHandleToV8Map map;
|
| - v8::Local<v8::Value> ret = jsifyHelper(domData, value, map, exception);
|
| - if (exception)
|
| - goto fail;
|
| -
|
| - if (scopes.handleJsException(&exception))
|
| - goto fail;
|
| - // Intentionally skip auto-conversion in this case as the user expects
|
| - // a JSObject. FIXME: evaluate if this is the right solution.
|
| - // Alternately, we could throw an exception.
|
| - if (ret->IsObject()) {
|
| - scopes.setReturnValue(JsObject::toDart(ret.As<v8::Object>()));
|
| - } else {
|
| - // This will throw an exception in Dart checked mode.
|
| - scopes.setReturnValue(ret);
|
| - }
|
| - return;
|
| - }
|
| -fail:
|
| - Dart_ThrowException(exception);
|
| - ASSERT_NOT_REACHED();
|
| -}
|
| -
|
| -static void withThisCallback(Dart_NativeArguments args)
|
| -{
|
| - Dart_Handle exception = 0;
|
| - {
|
| - JsInteropScopes scopes(args);
|
| - Dart_Handle function = Dart_GetNativeArgument(args, 0);
|
| - DartDOMData* domData = static_cast<DartDOMData*>(Dart_GetNativeIsolateData(args));
|
| - ASSERT(DartUtilities::isFunction(domData, function));
|
| -
|
| - v8::Local<v8::Object> proxy = dartFunctionTemplate()->InstanceTemplate()->NewInstance();
|
| - DartHandleProxy::writePointerToProxy(proxy, function);
|
| -
|
| - v8::Local<v8::Function> ret = v8::Local<v8::Function>::Cast(domData->jsInteropData()->captureThisFunction()->Call(proxy, 0, 0));
|
| -
|
| - if (scopes.handleJsException(&exception))
|
| - goto fail;
|
| - scopes.setReturnValue(ret);
|
| - return;
|
| - }
|
| -fail:
|
| - Dart_ThrowException(exception);
|
| - ASSERT_NOT_REACHED();
|
| -}
|
| -
|
| -}
|
| -
|
| -static DartNativeEntry nativeEntries[] = {
|
| - { JsInteropInternal::jsObjectConstructorCallback, 2, "JsObject_constructorCallback" },
|
| - { JsInteropInternal::contextCallback, 0, "Js_context_Callback" },
|
| - { JsInteropInternal::jsifyCallback, 1, "JsObject_jsify" },
|
| - { JsInteropInternal::withThisCallback, 1, "JsFunction_withThis" },
|
| - { JsInteropInternal::getterCallback, 2, "JsObject_[]" },
|
| - { JsInteropInternal::setterCallback, 3, "JsObject_[]=" },
|
| - { JsInteropInternal::hashCodeCallback, 1, "JsObject_hashCode" },
|
| - { JsInteropInternal::callMethodCallback, 3, "JsObject_callMethod" },
|
| - { JsInteropInternal::toStringCallback, 1, "JsObject_toString" },
|
| - { JsInteropInternal::identityEqualityCallback, 2, "JsObject_identityEquality" },
|
| - { JsInteropInternal::hasPropertyCallback, 2, "JsObject_hasProperty" },
|
| - { JsInteropInternal::deletePropertyCallback, 2, "JsObject_deleteProperty" },
|
| - { JsInteropInternal::instanceofCallback, 2, "JsObject_instanceof" },
|
| - { JsInteropInternal::applyCallback, 3, "JsFunction_apply" },
|
| - { JsInteropInternal::applyDebuggerOnlyCallback, 3, "JsFunction_applyDebuggerOnly" },
|
| - { JsInteropInternal::newJsArrayCallback, 0, "JsArray_newJsArray" },
|
| - { JsInteropInternal::newJsArrayFromSafeListCallback, 1, "JsArray_newJsArrayFromSafeList" },
|
| - { JsInteropInternal::jsArrayLengthCallback, 1, "JsArray_length" },
|
| - { JsInteropInternal::fromBrowserObjectCallback, 1, "JsObject_fromBrowserObject" },
|
| - { 0, 0, 0 },
|
| -};
|
| -
|
| -Dart_NativeFunction JsInterop::resolver(Dart_Handle nameHandle, int argumentCount, bool* autoSetupScope)
|
| -{
|
| - ASSERT(autoSetupScope);
|
| - *autoSetupScope = true;
|
| - String name = DartUtilities::toString(nameHandle);
|
| -
|
| - for (intptr_t i = 0; nativeEntries[i].nativeFunction != 0; i++) {
|
| - if (argumentCount == nativeEntries[i].argumentCount && name == nativeEntries[i].name) {
|
| - return nativeEntries[i].nativeFunction;
|
| - }
|
| - }
|
| -
|
| - return 0;
|
| -}
|
| -
|
| -const uint8_t* JsInterop::symbolizer(Dart_NativeFunction nf)
|
| -{
|
| - for (intptr_t i = 0; nativeEntries[i].nativeFunction != 0; i++) {
|
| - if (nf == nativeEntries[i].nativeFunction) {
|
| - return reinterpret_cast<const uint8_t*>(nativeEntries[i].name);
|
| - }
|
| - }
|
| - return 0;
|
| -}
|
| -
|
| -}
|
|
|