Beispiel #1
0
void VBOModule::create(const v8::FunctionCallbackInfo<v8::Value>& args) {
  v8::Isolate* isolate = args.GetIsolate();
  v8::HandleScope scope(isolate);
  
  VboRef vbo;
  
  if(args.Length() == 2){
    VboRef vbo = Vbo::create(
      args[1]->ToUint32()->Value() // GLenum target
    );
  } else if(args.Length() == 4){
    
    // TODO: Support other array data types as well
    if(args[2]->IsNumber()){
      vbo = Vbo::create(
        args[1]->ToUint32()->Value(),
        args[2]->ToUint32()->Value(),
        nullptr,
        args[3]->ToUint32()->Value()
      );
    } else {
      Local<Float32Array> data = args[2].As<Float32Array>();
      
      // GLenum target, GLsizeiptr allocationSize, const void *data, GLenum usage
      vbo = Vbo::create(
        args[1]->ToUint32()->Value(),
        data->ByteLength(),
        *data,
        args[3]->ToUint32()->Value()
      );
    }
  }
  
  StaticFactory::put<Vbo>( isolate, vbo, args[0]->ToObject() );
  
  // TODO: throw isolate error on wrong arguments
  return;
}
void
HumixFaceRec::StartCam(const v8::FunctionCallbackInfo<v8::Value>& info) {

    v8::Local<v8::Integer> devInt = info[0].As<v8::Integer>();

    if (mVideoCap != NULL) {
        //restart the capture by delete the old one
        delete mVideoCap;
    }
    // Get a handle to the Video device:
    mVideoCap = new VideoCapture(devInt->Value());
    mVideoCap->set(CV_CAP_PROP_FRAME_WIDTH, 640);
    mVideoCap->set(CV_CAP_PROP_FRAME_HEIGHT, 480);

    // sleep 1 sec, waiting for camera warmup
    printf("waiting for camera.. %d\n", devInt->Value());
    sleep(1);

    if (!mVideoCap->isOpened()) {
        return info.GetReturnValue().Set(false);
    }
    info.GetReturnValue().Set(true);
}
void V8HTMLAllCollection::namedItemMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
{
    V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, name, info[0]);

    HTMLAllCollection* imp = V8HTMLAllCollection::toNative(info.Holder());
    v8::Handle<v8::Value> result = getNamedItems(imp, name, info);

    if (result.IsEmpty()) {
        v8SetReturnValueNull(info);
        return;
    }

    v8SetReturnValue(info, result);
}
void V8MutationObserver::constructorCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
{
    ExceptionState exceptionState(ExceptionState::ConstructionContext, "MutationObserver", info.Holder(), info.GetIsolate());
    if (info.Length() < 1) {
        exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, info.Length()));
        exceptionState.throwIfNeeded();
        return;
    }

    v8::Local<v8::Value> arg = info[0];
    if (!arg->IsFunction()) {
        exceptionState.throwTypeError("Callback argument must be a function");
        exceptionState.throwIfNeeded();
        return;
    }

    v8::Local<v8::Object> wrapper = info.Holder();

    RawPtr<MutationCallback> callback = V8MutationCallback::create(v8::Local<v8::Function>::Cast(arg), wrapper, ScriptState::current(info.GetIsolate()));
    RawPtr<MutationObserver> observer = MutationObserver::create(callback.release());

    v8SetReturnValue(info, V8DOMWrapper::associateObjectWithWrapper(info.GetIsolate(), observer.get(), &wrapperTypeInfo, wrapper));
}
Beispiel #5
0
void UnZip_Wrap::New(const v8::FunctionCallbackInfo<v8::Value>& args) {
  Isolate* isolate = Isolate::GetCurrent();
  HandleScope scope(isolate);

  if (args.IsConstructCall()) {
    // Invoked as constructor: `new UnZip_Wrap(...)`
    UnZip_Wrap* obj = nullptr;

    if(args.Length()>1) {
      if(args[0]->IsString() && args[1]->IsString()) {
        Local<String> fileName = args[0]->ToString(),folder = args[1]->ToString();
        obj = new UnZip_Wrap(fileName,folder);
      }
    } else {
        //error goes here
    }

    if ( obj != nullptr ) {
      obj->Wrap(args.This());
      args.GetReturnValue().Set(args.This());
    }
  }
}
Beispiel #6
0
void JsVlcVideo::jsCreate( const v8::FunctionCallbackInfo<v8::Value>& args )
{
    using namespace v8;

    Isolate* isolate = Isolate::GetCurrent();
    HandleScope scope( isolate );

    Local<Object> thisObject = args.Holder();
    if( args.IsConstructCall() && thisObject->InternalFieldCount() > 0 ) {
        JsVlcPlayer* jsPlayer =
            ObjectWrap::Unwrap<JsVlcPlayer>( Handle<Object>::Cast( args[0] ) );
        if( jsPlayer ) {
            JsVlcVideo* jsPlaylist = new JsVlcVideo( thisObject, jsPlayer );
            args.GetReturnValue().Set( thisObject );
        }
    } else {
        Local<Function> constructor =
            Local<Function>::New( isolate, _jsConstructor );
        Local<Value> argv[] = { args[0] };
        args.GetReturnValue().Set(
            constructor->NewInstance( sizeof( argv ) / sizeof( argv[0] ), argv ) );
    }
}
Beispiel #7
0
void JsVlcPlayer::jsCreate( const v8::FunctionCallbackInfo<v8::Value>& args )
{
    using namespace v8;

    Isolate* isolate = Isolate::GetCurrent();
    HandleScope scope( isolate );

    Local<Object> thisObject = args.Holder();
    if( args.IsConstructCall() ) {
        Local<Array> options;
        if( args.Length() == 1 && args[0]->IsArray() ) {
            options = Local<Array>::Cast( args[0] );
        }

        JsVlcPlayer* jsPlayer = new JsVlcPlayer( thisObject, options );
        args.GetReturnValue().Set( jsPlayer->handle() );
    } else {
        Local<Value> argv[] = { args[0] };
        Local<Function> constructor =
            Local<Function>::New( isolate, _jsConstructor );
        args.GetReturnValue().Set( constructor->NewInstance( sizeof( argv ) / sizeof( argv[0] ), argv ) );
    }
}
Beispiel #8
0
static void typeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
  v8::Local<v8::Object> holder = info.Holder();
  SVGTestInterface* impl = V8SVGTestInterface::toImpl(holder);

  // Skip on compact node DOMString getters.
  V0CustomElementProcessingStack::CallbackDeliveryScope deliveryScope;

  // Prepare the value to be set.
  V8StringResource<> cppValue = v8Value;
  if (!cppValue.prepare())
    return;

  impl->setAttribute(SVGNames::typeAttr, cppValue);
}
static void voidMethodDocumentMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
{
    ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodDocument", "TestInterface3", info.Holder(), info.GetIsolate());
    if (UNLIKELY(info.Length() < 2)) {
        setMinimumArityTypeError(exceptionState, 2, info.Length());
        exceptionState.throwIfNeeded();
        return;
    }
    Document* document;
    double d;
    {
        document = V8Document::toImplWithTypeCheck(info.GetIsolate(), info[0]);
        if (!document) {
            exceptionState.throwTypeError("parameter 1 is not of type 'Document'.");
            exceptionState.throwIfNeeded();
            return;
        }
        d = toRestrictedDouble(info.GetIsolate(), info[1], exceptionState);
        if (exceptionState.throwIfNeeded())
            return;
    }
    TestPartialInterface4::voidMethodDocument(document, d);
}
void V8HTMLOptionsCollection::addMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
{
    ExceptionState exceptionState(ExceptionState::ExecutionContext, "add", "HTMLOptionsCollection", info.Holder(), info.GetIsolate());
    if (!V8HTMLOptionElement::hasInstance(info[0], info.GetIsolate(), worldType(info.GetIsolate()))) {
        exceptionState.throwTypeError("The element provided was not an HTMLOptionElement.");
    } else {
        HTMLOptionsCollection* imp = V8HTMLOptionsCollection::toNative(info.Holder());
        HTMLOptionElement* option = V8HTMLOptionElement::toNative(v8::Handle<v8::Object>(v8::Handle<v8::Object>::Cast(info[0])));

        if (info.Length() < 2) {
            imp->add(option, exceptionState);
        } else {
            bool ok;
            V8TRYCATCH_VOID(int, index, toInt32(info[1], ok));
            if (!ok)
                exceptionState.throwTypeError("The index provided could not be interpreted as an integer.");
            else
                imp->add(option, index, exceptionState);
        }
    }

    exceptionState.throwIfNeeded();
}
Beispiel #11
0
result_t path_base::join(const v8::FunctionCallbackInfo<v8::Value> &args, exlib::string &retVal)
{
    exlib::string strBuffer;
    int32_t argc = args.Length();
    int32_t i;

    for (i = 0; i < argc; i++)
    {
        v8::String::Utf8Value s(args[i]);
        pathAdd(strBuffer, *s);
    }

    return normalize(strBuffer, retVal);
}
Beispiel #12
0
//v8::Handle<v8::Value> Execvp(const v8::Arguments& args) {
void Execvp(const v8::FunctionCallbackInfo<v8::Value>& args) {
   //v8::HandleScope scope;
   v8::Isolate* isolate = args.GetIsolate();
   
   // check input
   std::vector<std::string> str_vec = detail::parse_arguments(isolate, args);
   if(str_vec.size() == 0) {
      //return scope.Close(v8::Integer::New(-1));
      args.GetReturnValue().Set(v8::Integer::New(isolate, -1));
      return;
   }
   std::vector<char*> argv = detail::to_argv(str_vec);

   // get ready for the exec
   int status;
   detail::unset_cloexec(0);
   detail::unset_cloexec(1);
   detail::unset_cloexec(2);
   detail::handle_error(status = execvp(argv[0], &argv[0]), "execvp");
   
   //return scope.Close(v8::Integer::New(status));
   args.GetReturnValue().Set(v8::Integer::New(isolate, status));
}
static void partial2VoidMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
{
    ExceptionState exceptionState(ExceptionState::ExecutionContext, "partial2VoidMethod", "TestInterface", info.Holder(), info.GetIsolate());
    switch (std::min(1, info.Length())) {
    case 0:
        break;
    case 1:
        if (V8Node::hasInstance(info[0], info.GetIsolate())) {
            partial2VoidMethod3Method(info);
            return;
        }
        if (true) {
            partial2VoidMethod2Method(info);
            return;
        }
        break;
    default:
        break;
    }
    exceptionState.throwTypeError("No function was found that matched the signature provided.");
    exceptionState.throwIfNeeded();
    return;
}
void V8InjectedScriptHost::evalCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
{
    v8::Isolate* isolate = info.GetIsolate();
    if (info.Length() < 1) {
        isolate->ThrowException(v8::Exception::Error(v8::String::NewFromUtf8(isolate, "One argument expected.")));
        return;
    }

    v8::Local<v8::String> expression = info[0]->ToString(isolate);
    if (expression.IsEmpty()) {
        isolate->ThrowException(v8::Exception::Error(v8::String::NewFromUtf8(isolate, "The argument must be a string.")));
        return;
    }

    ASSERT(isolate->InContext());
    v8::TryCatch tryCatch(isolate);
    v8::Local<v8::Value> result;
    if (!v8Call(V8ScriptRunner::compileAndRunInternalScript(expression, info.GetIsolate()), result, tryCatch)) {
        v8SetReturnValue(info, tryCatch.ReThrow());
        return;
    }
    v8SetReturnValue(info, result);
}
Beispiel #15
0
static void deleteMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
{
    ExceptionState exceptionState(ExceptionState::ExecutionContext, "delete", "TestInterfaceGarbageCollected", info.Holder(), info.GetIsolate());
    if (UNLIKELY(info.Length() < 1)) {
        setMinimumArityTypeError(exceptionState, 1, info.Length());
        exceptionState.throwIfNeeded();
        return;
    }
    TestInterfaceGarbageCollected* impl = V8TestInterfaceGarbageCollected::toImpl(info.Holder());
    V8StringResource<> value;
    {
        value = info[0];
        if (!value.prepare())
            return;
    }
    ScriptState* scriptState = ScriptState::current(info.GetIsolate());
    bool result = impl->deleteForBinding(scriptState, value, exceptionState);
    if (exceptionState.hadException()) {
        exceptionState.throwIfNeeded();
        return;
    }
    v8SetReturnValueBool(info, result);
}
static void constructor4(const v8::FunctionCallbackInfo<v8::Value>& info)
{
    ExceptionState exceptionState(ExceptionState::ConstructionContext, "TestInterfaceConstructor", info.Holder(), info.GetIsolate());
    V8StringResource<> arg;
    V8StringResource<> arg2;
    V8StringResource<> arg3;
    {
        TOSTRING_VOID_INTERNAL(arg, info[0]);
        TOSTRING_VOID_INTERNAL(arg2, info[1]);
        TOSTRING_VOID_INTERNAL(arg3, info[2]);
    }
    ScriptState* scriptState = ScriptState::current(info.GetIsolate());
    ExecutionContext* executionContext = currentExecutionContext(info.GetIsolate());
    Document& document = *toDocument(currentExecutionContext(info.GetIsolate()));
    RefPtr<TestInterfaceConstructor> impl = TestInterfaceConstructor::create(scriptState, executionContext, document, arg, arg2, arg3, exceptionState);
    if (exceptionState.hadException()) {
        exceptionState.throwIfNeeded();
        return;
    }
    v8::Local<v8::Object> wrapper = info.Holder();
    impl->associateWithWrapper(info.GetIsolate(), &V8TestInterfaceConstructor::wrapperTypeInfo, wrapper);
    v8SetReturnValue(info, wrapper);
}
Beispiel #17
0
int TNodeJsUtil::GetArgInt32(const v8::FunctionCallbackInfo<v8::Value>& Args, const int& ArgN, const TStr& Property) {
	v8::Isolate* Isolate = v8::Isolate::GetCurrent();
	v8::HandleScope HandleScope(Isolate);

	EAssertR(Args.Length() > ArgN, "insufficient number of arguments!");

	EAssertR(Args[ArgN]->IsObject() && Args[ArgN]->ToObject()->Has(v8::String::NewFromUtf8(Isolate, Property.CStr())), TStr::Fmt("Argument %d, missing property %s", ArgN, Property.CStr()).CStr());

	v8::Handle<v8::Value> Val = Args[ArgN]->ToObject()->Get(v8::String::NewFromUtf8(Isolate, Property.CStr()));
	bool IsInt = Val->IsInt32();
	EAssertR(IsInt,
		TStr::Fmt("Argument %d, property %s expected to be int32", ArgN, Property.CStr()).CStr());
	return Val->ToNumber()->Int32Value();	
}
Beispiel #18
0
void DeviceNode::GetMethods(const v8::FunctionCallbackInfo<v8::Value>& args) {
  Isolate* isolate = Isolate::GetCurrent();
  HandleScope scope(isolate);
  Device* device = getDeviceBinding(args)->_device;
  std::vector<std::string> m = device->getMethods();
  v8::Handle<v8::Array> methods = Array::New(isolate);

  int i=0;
  for (std::vector<std::string>::iterator it = m.begin(); it != m.end(); ++it) {
    methods->Set(i++, String::NewFromUtf8(isolate, (*it).c_str()));
  }

  args.GetReturnValue().Set(methods);
}
Beispiel #19
0
double TNodeJsUtil::GetArgFlt(const v8::FunctionCallbackInfo<v8::Value>& Args, const int& ArgN, const TStr& Property, const double& DefVal) {
    v8::Isolate* Isolate = v8::Isolate::GetCurrent();
    v8::HandleScope HandleScope(Isolate);

    if (Args.Length() > ArgN) {
        if (Args[ArgN]->IsObject() && Args[ArgN]->ToObject()->Has(v8::String::NewFromUtf8(Isolate, Property.CStr()))) {
            v8::Handle<v8::Value> Val = Args[ArgN]->ToObject()->Get(v8::String::NewFromUtf8(Isolate, Property.CStr()));
            EAssertR(Val->IsNumber(),
                TStr::Fmt("Argument %d, property %s expected to be number", ArgN, Property.CStr()).CStr());
            return Val->NumberValue();
        }
    }
    return DefVal;
}
Beispiel #20
0
void TNodeJsFs::fileInfo(const v8::FunctionCallbackInfo<v8::Value>& Args) {
    v8::Isolate* Isolate = v8::Isolate::GetCurrent();
    v8::HandleScope HandleScope(Isolate);

    EAssertR(Args.Length() == 1 && Args[0]->IsString(),
        "Expected a file path as the only argument.");
    TStr FNm(*v8::String::Utf8Value(Args[0]->ToString()));
    EAssertR(TFile::Exists(FNm), TStr("File '" + FNm + "' does not exist").CStr());
    const uint64 CreateTm = TFile::GetCreateTm(FNm);
    const uint64 LastAccessTm = TFile::GetLastAccessTm(FNm);
    const uint64 LastWriteTm = TFile::GetLastWriteTm(FNm);
    const uint64 Size = TFile::GetSize(FNm);
    v8::Handle<v8::Object> Obj = v8::Object::New(Isolate);
    Obj->Set(v8::String::NewFromUtf8(Isolate, "createTime"),
        v8::String::NewFromUtf8(Isolate, TTm::GetTmFromMSecs(CreateTm).GetWebLogDateTimeStr().CStr()));
    Obj->Set(v8::String::NewFromUtf8(Isolate, "lastAccessTime"),
        v8::String::NewFromUtf8(Isolate, TTm::GetTmFromMSecs(LastAccessTm).GetWebLogDateTimeStr().CStr()));
    Obj->Set(v8::String::NewFromUtf8(Isolate, "lastWriteTime"),
        v8::String::NewFromUtf8(Isolate, TTm::GetTmFromMSecs(LastWriteTm).GetWebLogDateTimeStr().CStr()));
    Obj->Set(v8::String::NewFromUtf8(Isolate, "size"),
        v8::Number::New(Isolate, static_cast<double>(Size)));
    Args.GetReturnValue().Set(Obj);
}
Beispiel #21
0
void TNodeJsFs::listFile(const v8::FunctionCallbackInfo<v8::Value>& Args) {
    v8::Isolate* Isolate = v8::Isolate::GetCurrent();
    v8::HandleScope HandleScope(Isolate);

    EAssertR(Args.Length() >= 1 && Args[0]->IsString(),
        "Expected directory path as the first argument.");
    // Read parameters
    TStr FPath(*v8::String::Utf8Value(Args[0]->ToString()));
    TStrV FExtV;    
    if (Args.Length() >= 2 && Args[1]->IsString()) {
        FExtV.Add(TStr(*v8::String::Utf8Value(Args[1]->ToString())));
    }
    const bool RecurseP = Args.Length() >= 3 && Args[2]->IsBoolean() && Args[2]->BooleanValue();
    // Get file list
    TStrV FNmV;
    TFFile::GetFNmV(FPath, FExtV, RecurseP, FNmV);
    FNmV.Sort();
    v8::Handle<v8::Array> FNmArr = v8::Array::New(Isolate, FNmV.Len());
    for(int FldN = 0; FldN < FNmV.Len(); ++FldN) {
        FNmArr->Set(v8::Integer::New(Isolate, FldN), v8::String::NewFromUtf8(Isolate, FNmV.GetVal(FldN).CStr()));
    }
    Args.GetReturnValue().Set(FNmArr);
}
Beispiel #22
0
void context::run_file(v8::FunctionCallbackInfo<v8::Value> const& args)
{
	v8::Isolate* isolate = args.GetIsolate();

	v8::EscapableHandleScope scope(isolate);
	v8::Local<v8::Value> result;
	try
	{
		std::string const filename = from_v8<std::string>(isolate, args[0], "");
		if (filename.empty())
		{
			throw std::runtime_error("run_file: require filename string argument");
		}

		context* ctx = detail::get_external_data<context*>(args.Data());
		result = to_v8(isolate, ctx->run_file(filename));
	}
	catch (std::exception const& ex)
	{
		result = throw_ex(isolate, ex.what());
	}
	args.GetReturnValue().Set(scope.Escape(result));
}
Beispiel #23
0
static void namedItemMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
{
    if (UNLIKELY(info.Length() < 1)) {
        throwTypeError(ExceptionMessages::failedToExecute("namedItem", "TestInterface", ExceptionMessages::notEnoughArguments(1, info.Length())), info.GetIsolate());
        return;
    }
    TestInterface* impl = V8TestInterface::toNative(info.Holder());
    V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, name, info[0]);
    bool result0Enabled = false;
    RefPtr<Node> result0;
    bool result1Enabled = false;
    RefPtr<NodeList> result1;
    impl->getItem(name, result0Enabled, result0, result1Enabled, result1);
    if (result0Enabled) {
        v8SetReturnValue(info, result0.release());
        return;
    }
    if (result1Enabled) {
        v8SetReturnValue(info, result1.release());
        return;
    }
    v8SetReturnValueNull(info);
}
void NativePlatform::AppInitCallback(const v8::FunctionCallbackInfo<v8::Value>& args)
{
	try {
	auto isolate = Isolate::GetCurrent();

	if (args.Length() != 1)
	{
		throw NativeScriptException(string("Application should be initialized with single parameter"));
	}
	if (!args[0]->IsObject())
	{
		throw NativeScriptException(string("Application should be initialized with single object parameter containing overridden methods"));
	}

	// TODO: find another way to get "com/tns/NativeScriptApplication" metadata (move it to more appropriate place)
	auto node = MetadataNode::GetOrCreate("com/tns/NativeScriptApplication");
	auto appInstance = node->CreateJSWrapper(isolate);
	DEBUG_WRITE("Application object created id: %d", appInstance->GetIdentityHash());

	auto implementationObject = args[0]->ToObject();
	implementationObject->SetHiddenValue(V8StringConstants::GetClassImplementationObject(), External::New(isolate, node));
	DEBUG_WRITE("Application object implementation object is with id: %d", implementationObject->GetIdentityHash());
	implementationObject->SetPrototype(appInstance->GetPrototype());
	bool appSuccess = appInstance->SetPrototype(implementationObject);
	if (!appSuccess)
	{
		throw NativeScriptException(string("Application could not be initialized correctly"));
	}

	jweak applicationObject = g_objectManager->GetJavaObjectByID(AppJavaObjectID);

	JEnv env;
	jclass appClass = env.FindClass("com/tns/NativeScriptApplication");
	g_objectManager->Link(appInstance, AppJavaObjectID, appClass);

	JniLocalRef applicationClass(env.GetObjectClass(applicationObject));
	jmethodID setNativeScriptOverridesMethodId = env.GetMethodID((jclass)applicationClass, "setNativeScriptOverrides", "([Ljava/lang/String;)V");
	jobjectArray methodOverrides = NativeScriptRuntime::GetMethodOverrides(env, implementationObject);
	env.CallVoidMethod(applicationObject, setNativeScriptOverridesMethodId, methodOverrides);
	} catch (NativeScriptException& e) {
		e.ReThrowToV8();
	}
	catch (exception e) {
		DEBUG_WRITE("Error: c++ exception: %s", e.what());
	}
	catch (...) {
		DEBUG_WRITE("Error: c++ exception!");
	}
}
// The callback that is invoked by v8 whenever the JavaScript 'read'
// function is called.  This function loads the content of the file named in
// the argument into a JavaScript string.
void Read(const v8::FunctionCallbackInfo<v8::Value>& args) {
  if (args.Length() != 1) {
    args.GetIsolate()->ThrowException(
        v8::String::NewFromUtf8(args.GetIsolate(), "Bad parameters"));
    return;
  }
  v8::String::Utf8Value file(args[0]);
  if (*file == NULL) {
    args.GetIsolate()->ThrowException(
        v8::String::NewFromUtf8(args.GetIsolate(), "Error loading file"));
    return;
  }
  v8::Handle<v8::String> source = ReadFile(args.GetIsolate(), *file);
  if (source.IsEmpty()) {
    args.GetIsolate()->ThrowException(
        v8::String::NewFromUtf8(args.GetIsolate(), "Error loading file"));
    return;
  }
  args.GetReturnValue().Set(source);
}
Beispiel #26
0
void JSVideoFrameConstructor(const v8::FunctionCallbackInfo<v8::Value> &args) {
	TRACE("Attempt to construct video frame\n");
	if (!args.IsConstructCall()) {
		TRACE("Ignoring direct call to constructor.\n");
		// I'm not sure if this would get called in a "super" constructor if something were
		// to try and "extend" a video frame.
		return;
	}
	if (args.Length() == 1) {
		// In this case, the argument must be an external marking this as an
		// "internal" call to create a video frame.
		if (args[0]->IsExternal()) {
			// The external is a ProtoVideoFrame and is used to construct our "real" value.
			ProtoVideoFrame* proto = UnwrapExternal<ProtoVideoFrame>(args[0]);
			// I guess you can use "duck" typing in C++!
			new C(proto->frame, proto->vi, args.GetIsolate(), args.This());
			return;
		}
	} else if (args.Length() == 3) {
		// Allowed arguments for this are:
	}
	// Eventually, we may allow creating a frame in this fashion. For now:
	v8::ThrowException(v8::Exception::Error(v8::String::New("Cannot construct video frame directly")));
}
Beispiel #27
0
bool TNodeJsUtil::GetArgBool(const v8::FunctionCallbackInfo<v8::Value>& Args, const int& ArgN, const TStr& Property, const bool& DefVal) {
    v8::Isolate* Isolate = v8::Isolate::GetCurrent();
    v8::HandleScope HandleScope(Isolate);

    if (Args.Length() > ArgN) {
        if (Args[ArgN]->IsObject() && Args[ArgN]->ToObject()->Has(v8::String::NewFromUtf8(Isolate, Property.CStr()))) {
            v8::Handle<v8::Value> Val = Args[ArgN]->ToObject()->Get(v8::String::NewFromUtf8(Isolate, Property.CStr()));
            EAssertR(Val->IsBoolean(),
                     TStr::Fmt("Argument %d, property %s expected to be boolean", ArgN, Property.CStr()).CStr());
			v8::Local<v8::BooleanObject> BoolObj = v8::Local<v8::BooleanObject>::Cast(Val->ToObject());
			return static_cast<bool>(BoolObj->ValueOf());
        }
    }
    return DefVal;
}
Beispiel #28
0
void Profiler::StopCPUProfilerCallback(const v8::FunctionCallbackInfo<v8::Value>& args)
{
	try
	{
		auto isolate = args.GetIsolate();
		auto extData = args.Data().As<External>();
		auto thiz = static_cast<Profiler*>(extData->Value());
		thiz->StopCPUProfilerCallbackImpl(args);
	}
	catch (NativeScriptException& e)
	{
		e.ReThrowToV8();
	}
	catch (std::exception e) {
		stringstream ss;
		ss << "Error: c++ exception: " << e.what() << endl;
		NativeScriptException nsEx(ss.str());
		nsEx.ReThrowToV8();
	}
	catch (...) {
		NativeScriptException nsEx(std::string("Error: c++ exception!"));
		nsEx.ReThrowToV8();
	}
}
void V8Window::showModalDialogMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& args)
{
    DOMWindow* impl = V8Window::toNative(args.Holder());
    if (!BindingSecurity::shouldAllowAccessToFrame(impl->frame()))
        return;

    // FIXME: Handle exceptions properly.
    String urlString = toWebCoreStringWithUndefinedOrNullCheck(args[0]);
    DialogHandler handler(args[1]);
    String dialogFeaturesString = toWebCoreStringWithUndefinedOrNullCheck(args[2]);

    impl->showModalDialog(urlString, dialogFeaturesString, activeDOMWindow(), firstDOMWindow(), setUpDialog, &handler);

    v8SetReturnValue(args, handler.returnValue());
}
// This custom binding is shared by V8WorkerCrypto. As such:
//   * Do not call V8Crypto::toNative()
//   * Must be threadsafe
void V8Crypto::getRandomValuesMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
{
    ExceptionState exceptionState(ExceptionState::ExecutionContext, "getRandomValues", "Crypto", info.Holder(), info.GetIsolate());
    if (info.Length() < 1) {
        exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, info.Length()));
        exceptionState.throwIfNeeded();
        return;
    }

    v8::Handle<v8::Value> buffer = info[0];
    if (!V8ArrayBufferView::hasInstance(buffer, info.GetIsolate())) {
        exceptionState.throwTypeError("First argument is not an ArrayBufferView");
    } else {
        ArrayBufferView* arrayBufferView = V8ArrayBufferView::toNative(v8::Handle<v8::Object>::Cast(buffer));
        ASSERT(arrayBufferView);

        Crypto::getRandomValues(arrayBufferView, exceptionState);
    }

    if (exceptionState.throwIfNeeded())
        return;

    v8SetReturnValue(info, buffer);
}