void V8AbstractEventListener::invokeEventHandler(v8::Handle<v8::Context> v8Context, Event* event, v8::Handle<v8::Value> jsEvent)
{
// We push the event being processed into the global object, so that it can be exposed by DOMWindow's bindings.
v8::Local<v8::String> eventSymbol = v8::String::NewSymbol("event");
v8::Local<v8::Value> returnValue;
// In beforeunload/unload handlers, we want to avoid sleeps which do tight loops of calling Date.getTime().
if (event->type() == "beforeunload" || event->type() == "unload")
DateExtension::get()->setAllowSleep(false);
{
// Catch exceptions thrown in the event handler so they do not propagate to javascript code that caused the event to fire.
v8::TryCatch tryCatch;
tryCatch.SetVerbose(true);
// Save the old 'event' property so we can restore it later.
v8::Local<v8::Value> savedEvent = v8Context->Global()->GetHiddenValue(eventSymbol);
tryCatch.Reset();
// Make the event available in the global object, so DOMWindow can expose it.
v8Context->Global()->SetHiddenValue(eventSymbol, jsEvent);
tryCatch.Reset();
// Call the event handler.
tryCatch.SetVerbose(false); // We do not want to report the exception to the inspector console.
returnValue = callListenerFunction(jsEvent, event);
if (!tryCatch.CanContinue())
return;
// If an error occurs while handling the event, it should be reported.
if (tryCatch.HasCaught()) {
reportException(0, tryCatch);
tryCatch.Reset();
}
// Restore the old event. This must be done for all exit paths through this method.
tryCatch.SetVerbose(true);
if (savedEvent.IsEmpty())
v8Context->Global()->SetHiddenValue(eventSymbol, v8::Undefined());
else
v8Context->Global()->SetHiddenValue(eventSymbol, savedEvent);
tryCatch.Reset();
}
if (event->type() == "beforeunload" || event->type() == "unload")
DateExtension::get()->setAllowSleep(true);
ASSERT(!V8Proxy::handleOutOfMemory() || returnValue.IsEmpty());
if (returnValue.IsEmpty())
return;
if (!returnValue->IsNull() && !returnValue->IsUndefined() && event->storesResultAsString())
event->storeResult(toWebCoreString(returnValue));
// Prevent default action if the return value is false;
// FIXME: Add example, and reference to bug entry.
if (m_isAttribute && returnValue->IsBoolean() && !returnValue->BooleanValue())
event->preventDefault();
}
int sendToCtrlServer(MsgHeader *mh, Buffer *buffer) {
DBG("sendToCtrlServer E: cmd=%d token=%lld", mh->cmd(), mh->token());
int status = STATUS_OK;
v8::HandleScope handle_scope;
v8::TryCatch try_catch;
try_catch.SetVerbose(true);
// Get the onRilRequest Function
v8::Handle<v8::String> name = v8::String::New("onCtrlServerCmd");
v8::Handle<v8::Value> onCtrlServerCmdFunctionValue =
context_->Global()->Get(name);
v8::Handle<v8::Function> onCtrlServerCmdFunction =
v8::Handle<v8::Function>::Cast(onCtrlServerCmdFunctionValue);
// Create the CmdValue and TokenValue
v8::Handle<v8::Value> v8CmdValue = v8::Number::New(mh->cmd());
v8::Handle<v8::Value> v8TokenValue = v8::Number::New(mh->token());
// Invoke onRilRequest
const int argc = 3;
v8::Handle<v8::Value> buf;
if (mh->length_data() == 0) {
buf = v8::Undefined();
} else {
buf = buffer->handle_;
}
v8::Handle<v8::Value> argv[argc] = {
v8CmdValue, v8TokenValue, buf };
v8::Handle<v8::Value> result =
onCtrlServerCmdFunction->Call(context_->Global(), argc, argv);
if (try_catch.HasCaught()) {
ReportException(&try_catch);
status = STATUS_ERR;
} else {
v8::String::Utf8Value result_string(result);
DBG("sendToCtrlServer result=%s", ToCString(result_string));
status = STATUS_OK;
}
if (status != STATUS_OK) {
LOGE("sendToCtrlServer Error: status=%d", status);
// An error report complete now
mh->set_length_data(0);
mh->set_status(ril_proto::CTRL_STATUS_ERR);
g_ctrl_server->WriteMessage(mh, NULL);
}
DBG("sendToCtrlServer X: status=%d", status);
return status;
}
String DebuggerAgentImpl::executeUtilityFunction(
v8::Handle<v8::Context> context,
int callId,
const char* object,
const String &functionName,
const String& jsonArgs,
bool async,
String* exception)
{
v8::HandleScope scope;
ASSERT(!context.IsEmpty());
if (context.IsEmpty()) {
*exception = "No window context.";
return "";
}
v8::Context::Scope contextScope(context);
DebuggerAgentManager::UtilityContextScope utilityScope;
v8::Handle<v8::Object> dispatchObject = v8::Handle<v8::Object>::Cast(
context->Global()->Get(v8::String::New(object)));
v8::Handle<v8::Value> dispatchFunction = dispatchObject->Get(v8::String::New("dispatch"));
ASSERT(dispatchFunction->IsFunction());
v8::Handle<v8::Function> function = v8::Handle<v8::Function>::Cast(dispatchFunction);
v8::Handle<v8::String> functionNameWrapper = v8::Handle<v8::String>(
v8::String::New(functionName.utf8().data()));
v8::Handle<v8::String> jsonArgsWrapper = v8::Handle<v8::String>(
v8::String::New(jsonArgs.utf8().data()));
v8::Handle<v8::Number> callIdWrapper = v8::Handle<v8::Number>(
v8::Number::New(async ? callId : 0));
v8::Handle<v8::Value> args[] = {
functionNameWrapper,
jsonArgsWrapper,
callIdWrapper
};
v8::TryCatch tryCatch;
v8::Handle<v8::Value> resObj = function->Call(context->Global(), 3, args);
if (tryCatch.HasCaught()) {
v8::Local<v8::Message> message = tryCatch.Message();
if (message.IsEmpty())
*exception = "Unknown exception";
else
*exception = WebCore::toWebCoreString(message->Get());
return "";
}
return WebCore::toWebCoreStringWithNullCheck(resObj);
}
void V8Proxy::installHiddenObjectPrototype(v8::Handle<v8::Context> context)
{
v8::Handle<v8::String> objectString = v8::String::New("Object");
v8::Handle<v8::String> prototypeString = v8::String::New("prototype");
v8::Handle<v8::String> hiddenObjectPrototypeString = V8HiddenPropertyName::objectPrototype();
// Bail out if allocation failed.
if (objectString.IsEmpty() || prototypeString.IsEmpty() || hiddenObjectPrototypeString.IsEmpty())
return;
v8::Handle<v8::Object> object = v8::Handle<v8::Object>::Cast(context->Global()->Get(objectString));
v8::Handle<v8::Value> objectPrototype = object->Get(prototypeString);
context->Global()->SetHiddenValue(hiddenObjectPrototypeString, objectPrototype);
}
void TRI_InitV8Shell (v8::Handle<v8::Context> context) {
v8::HandleScope scope;
// .............................................................................
// create the global functions
// .............................................................................
context->Global()->Set(v8::String::New("processCsvFile"),
v8::FunctionTemplate::New(JS_ProcessCsvFile)->GetFunction(),
v8::ReadOnly);
context->Global()->Set(v8::String::New("processJsonFile"),
v8::FunctionTemplate::New(JS_ProcessJsonFile)->GetFunction(),
v8::ReadOnly);
}
//This function just prints out all properties associated with context ctx has
//additional parameter additionalMessage which prints out at the top of this
//function's debugging message. additionalMessage arose as a nice way to print
//the context multiple times and still be able to keep straight which printout
//was associated with which call to debug_checkCurrentContextX by specifying
//unique additionalMessages each time the function was called.
void debug_checkCurrentContextX(v8::Handle<v8::Context> ctx, std::string additionalMessage)
{
v8::HandleScope handle_scope;
std::cout<<"\n\n\nDoing checkCurrentContext with value passed in of: "<<additionalMessage<<"\n\n";
printAllPropertyNames(ctx->Global());
std::cout<<"\n\n";
}
void TRI_AddGlobalFunctionVocbase (v8::Handle<v8::Context> context,
const char* const name,
v8::Handle<v8::Function> func,
const bool isHidden) {
// all global functions are read-only
if (isHidden) {
context->Global()->Set(TRI_V8_SYMBOL(name),
func,
static_cast<v8::PropertyAttribute>(v8::ReadOnly | v8::DontEnum));
}
else {
context->Global()->Set(TRI_V8_SYMBOL(name),
func,
v8::ReadOnly);
}
}
void TRI_AddGlobalFunctionVocbase (v8::Handle<v8::Context> context,
const char* const name,
v8::Handle<v8::Value>(*func)(v8::Arguments const&),
const bool isHidden) {
// all global functions are read-only
if (isHidden) {
context->Global()->Set(TRI_V8_SYMBOL(name),
v8::FunctionTemplate::New(func)->GetFunction(),
static_cast<v8::PropertyAttribute>(v8::ReadOnly | v8::DontEnum));
}
else {
context->Global()->Set(TRI_V8_SYMBOL(name),
v8::FunctionTemplate::New(func)->GetFunction(),
v8::ReadOnly);
}
}
inline void DialogHandler::dialogCreated(DOMWindow* dialogFrame)
{
m_dialogContext = V8Proxy::context(dialogFrame->frame());
if (m_dialogContext.IsEmpty())
return;
if (m_dialogArguments.IsEmpty())
return;
v8::Context::Scope scope(m_dialogContext);
m_dialogContext->Global()->Set(v8::String::New("dialogArguments"), m_dialogArguments);
}
inline void DialogHandler::dialogCreated(DOMWindow* dialogFrame)
{
m_dialogContext = dialogFrame->frame() ? dialogFrame->frame()->script()->currentWorldContext() : v8::Local<v8::Context>();
if (m_dialogContext.IsEmpty())
return;
if (m_dialogArguments.IsEmpty())
return;
v8::Context::Scope scope(m_dialogContext);
m_dialogContext->Global()->Set(v8::String::NewSymbol("dialogArguments"), m_dialogArguments);
}
inline v8::Handle<v8::Value> DialogHandler::returnValue() const
{
if (m_dialogContext.IsEmpty())
return v8::Undefined();
v8::Context::Scope scope(m_dialogContext);
v8::Handle<v8::Value> returnValue = m_dialogContext->Global()->Get(v8::String::NewSymbol("returnValue"));
if (returnValue.IsEmpty())
return v8::Undefined();
return returnValue;
}
inline v8::Handle<v8::Value> DialogHandler::returnValue(v8::Isolate* isolate) const
{
if (m_dialogContext.IsEmpty())
return v8::Undefined(isolate);
v8::Context::Scope scope(m_dialogContext);
v8::Handle<v8::Value> returnValue = m_dialogContext->Global()->Get(v8AtomicString(isolate, "returnValue"));
if (returnValue.IsEmpty())
return v8::Undefined(isolate);
return returnValue;
}
V8PerContextData::V8PerContextData(v8::Handle<v8::Context> context)
: m_isolate(context->GetIsolate())
, m_wrapperBoilerplates(m_isolate)
, m_constructorMap(m_isolate)
, m_contextHolder(adoptPtr(new gin::ContextHolder(m_isolate)))
, m_context(m_isolate, context)
, m_customElementBindings(adoptPtr(new CustomElementBindingMap()))
{
m_contextHolder->SetContext(context);
v8::Context::Scope contextScope(context);
ASSERT(m_errorPrototype.isEmpty());
v8::Handle<v8::Object> object = v8::Handle<v8::Object>::Cast(context->Global()->Get(v8AtomicString(m_isolate, "Error")));
ASSERT(!object.IsEmpty());
v8::Handle<v8::Value> prototypeValue = object->Get(v8AtomicString(m_isolate, "prototype"));
ASSERT(!prototypeValue.IsEmpty());
m_errorPrototype.set(m_isolate, prototypeValue);
m_functionConstructor.set(m_isolate, v8::Handle<v8::Function>::Cast(context->Global()->Get(v8AtomicString(m_isolate, "Function"))));
}
inline void DialogHandler::dialogCreated(DOMWindow* dialogFrame, v8::Isolate* isolate)
{
// FIXME: It's wrong to use the current world. Instead we should use the world
// from which the modal dialog was requested.
m_dialogContext = dialogFrame->frame() ? toV8Context(isolate, dialogFrame->frame(), DOMWrapperWorld::current(isolate)) : v8::Local<v8::Context>();
if (m_dialogContext.IsEmpty())
return;
if (m_dialogArguments.IsEmpty())
return;
v8::Context::Scope scope(m_dialogContext);
m_dialogContext->Global()->Set(v8AtomicString(isolate, "dialogArguments"), m_dialogArguments);
}
bool V8DOMWindowShell::installHiddenObjectPrototype(v8::Handle<v8::Context> context)
{
v8::Handle<v8::String> objectString = v8::String::New("Object");
v8::Handle<v8::String> prototypeString = v8::String::New("prototype");
v8::Handle<v8::String> hiddenObjectPrototypeString = V8HiddenPropertyName::objectPrototype();
// Bail out if allocation failed.
if (objectString.IsEmpty() || prototypeString.IsEmpty() || hiddenObjectPrototypeString.IsEmpty())
return false;
v8::Handle<v8::Object> object = v8::Handle<v8::Object>::Cast(context->Global()->Get(objectString));
// Bail out if fetching failed.
if (object.IsEmpty())
return false;
v8::Handle<v8::Value> objectPrototype = object->Get(prototypeString);
// Bail out if fetching failed.
if (objectPrototype.IsEmpty())
return false;
context->Global()->SetHiddenValue(hiddenObjectPrototypeString, objectPrototype);
return true;
}
int callOnRilRequest(v8::Handle<v8::Context> context, int cmd,
const void *buffer, RIL_Token t) {
DBG("callOnRilRequest E: cmd=%d", cmd);
int status;
v8::HandleScope handle_scope;
v8::TryCatch try_catch;
// Get the onRilRequest Function
v8::Handle<v8::String> name = v8::String::New("onRilRequest");
v8::Handle<v8::Value> onRilRequestFunctionValue = context->Global()->Get(name);
v8::Handle<v8::Function> onRilRequestFunction =
v8::Handle<v8::Function>::Cast(onRilRequestFunctionValue);
// Create the cmd and token
v8::Handle<v8::Value> v8RequestValue = v8::Number::New(cmd);
v8::Handle<v8::Value> v8TokenValue = v8::Number::New(int64_t(t));
// Invoke onRilRequest
const int argc = 3;
v8::Handle<v8::Value> argv[argc] = {
v8RequestValue, v8TokenValue, ((Buffer *)buffer)->handle_ };
v8::Handle<v8::Value> result =
onRilRequestFunction->Call(context->Global(), argc, argv);
if (try_catch.HasCaught()) {
ALOGE("callOnRilRequest error");
ReportException(&try_catch);
status = STATUS_ERR;
} else {
v8::String::Utf8Value result_string(result);
DBG("callOnRilRequest result=%s", ToCString(result_string));
status = STATUS_OK;
}
DBG("callOnRilRequest X: status=%d", status);
return status;
}
V8PerContextData::V8PerContextData(v8::Handle<v8::Context> context)
: m_isolate(context->GetIsolate())
, m_wrapperBoilerplates(m_isolate)
, m_constructorMap(m_isolate)
, m_contextHolder(adoptPtr(new gin::ContextHolder(m_isolate)))
, m_context(m_isolate, context)
, m_activityLogger(0)
, m_compiledPrivateScript(m_isolate)
{
m_contextHolder->SetContext(context);
v8::Context::Scope contextScope(context);
ASSERT(m_errorPrototype.isEmpty());
v8::Handle<v8::Object> object = v8::Handle<v8::Object>::Cast(context->Global()->Get(v8AtomicString(m_isolate, "Error")));
ASSERT(!object.IsEmpty());
v8::Handle<v8::Value> prototypeValue = object->Get(v8AtomicString(m_isolate, "prototype"));
ASSERT(!prototypeValue.IsEmpty());
m_errorPrototype.set(m_isolate, prototypeValue);
}
bool V8DOMWindowShell::installDOMWindow(v8::Handle<v8::Context> context, DOMWindow* window)
{
// Create a new JS window object and use it as the prototype for the shadow global object.
v8::Handle<v8::Function> windowConstructor = V8DOMWrapper::getConstructor(&V8DOMWindow::info, getHiddenObjectPrototype(context));
v8::Local<v8::Object> jsWindow = SafeAllocation::newInstance(windowConstructor);
// Bail out if allocation failed.
if (jsWindow.IsEmpty())
return false;
// Wrap the window.
V8DOMWrapper::setDOMWrapper(jsWindow, &V8DOMWindow::info, window);
V8DOMWrapper::setDOMWrapper(v8::Handle<v8::Object>::Cast(jsWindow->GetPrototype()), &V8DOMWindow::info, window);
window->ref();
V8DOMWrapper::setJSWrapperForDOMObject(window, v8::Persistent<v8::Object>::New(jsWindow));
// Insert the window instance as the prototype of the shadow object.
v8::Handle<v8::Object> v8RealGlobal = v8::Handle<v8::Object>::Cast(context->Global()->GetPrototype());
V8DOMWrapper::setDOMWrapper(v8RealGlobal, &V8DOMWindow::info, window);
v8RealGlobal->SetPrototype(jsWindow);
return true;
}
bool V8Proxy::installDOMWindow(v8::Handle<v8::Context> context, DOMWindow* window)
{
v8::Handle<v8::String> implicitProtoString = v8::String::New("__proto__");
if (implicitProtoString.IsEmpty())
return false;
// Create a new JS window object and use it as the prototype for the shadow global object.
v8::Handle<v8::Function> windowConstructor = V8DOMWrapper::getConstructor(V8ClassIndex::DOMWINDOW, getHiddenObjectPrototype(context));
v8::Local<v8::Object> jsWindow = SafeAllocation::newInstance(windowConstructor);
// Bail out if allocation failed.
if (jsWindow.IsEmpty())
return false;
// Wrap the window.
V8DOMWrapper::setDOMWrapper(jsWindow, V8ClassIndex::ToInt(V8ClassIndex::DOMWINDOW), window);
window->ref();
V8DOMWrapper::setJSWrapperForDOMObject(window, v8::Persistent<v8::Object>::New(jsWindow));
// Insert the window instance as the prototype of the shadow object.
v8::Handle<v8::Object> v8Global = context->Global();
v8Global->Set(implicitProtoString, jsWindow);
return true;
}
v8::Handle<v8::Object> toInnerGlobalObject(v8::Handle<v8::Context> context)
{
return v8::Handle<v8::Object>::Cast(context->Global()->GetPrototype());
}
void TRI_AddGlobalVariableVocbase (v8::Handle<v8::Context> context,
const char* const name,
v8::Handle<v8::Value> value) {
// all global functions are read-only
context->Global()->Set(TRI_V8_SYMBOL(name), value, v8::ReadOnly);
}
void TRI_AddGlobalFunctionVocbase (v8::Handle<v8::Context> context,
const char* const name,
v8::Handle<v8::Function> func) {
// all global functions are read-only
context->Global()->Set(TRI_V8_SYMBOL(name), func, v8::ReadOnly);
}
void TRI_AddGlobalFunctionVocbase (v8::Handle<v8::Context> context,
const char* const name,
v8::Handle<v8::Value>(*func)(v8::Arguments const&)) {
// all global functions are read-only
context->Global()->Set(TRI_V8_SYMBOL(name), v8::FunctionTemplate::New(func)->GetFunction(), v8::ReadOnly);
}
int main(int argc, char* argv[]) {
setupSignals();
//v8::V8::SetFlagsFromCommandLine(&argc, argv, true);
v8::Locker l;
v8::HandleScope handle_scope;
v8::Handle<v8::ObjectTemplate> global = v8::ObjectTemplate::New();
installShellUtils( global );
installMongoGlobals( global );
baseContext_ = v8::Context::New(NULL, global);
v8::Context::Scope context_scope(baseContext_);
{ // init mongo code
v8::HandleScope handle_scope;
if ( ! ExecuteString( v8::String::New( jsconcatcode ) , v8::String::New( "(mongo init)" ) , false , true ) )
return -1;
}
string url = "test";
string dbhost;
string port;
string username;
string password;
bool runShell = false;
bool nodb = false;
int argNumber = 1;
for ( ; argNumber < argc; argNumber++) {
const char* str = argv[argNumber];
if (strcmp(str, "--shell") == 0) {
runShell = true;
continue;
}
if (strcmp(str, "--nodb") == 0) {
nodb = true;
continue;
}
if ( strcmp( str , "--port" ) == 0 ){
port = argv[argNumber+1];
argNumber++;
continue;
}
if ( strcmp( str , "--host" ) == 0 ){
dbhost = argv[argNumber+1];
argNumber++;
continue;
}
if ( strcmp( str , "-u" ) == 0 ){
username = argv[argNumber+1];
argNumber++;
continue;
}
if ( strcmp( str , "-p" ) == 0 ){
password = argv[argNumber+1];
argNumber++;
continue;
}
if ( strstr( str , "-p" ) == str ){
password = str;
password = password.substr( 2 );
continue;
}
if ( strcmp(str, "--help") == 0 ||
strcmp(str, "-h" ) == 0 ) {
cout
<< "usage: " << argv[0] << " [options] [db address] [file names]\n"
<< "db address can be:\n"
<< " foo = foo database on local machine\n"
<< " 192.169.0.5/foo = foo database on 192.168.0.5 machine\n"
<< " 192.169.0.5:9999/foo = foo database on 192.168.0.5 machine on port 9999\n"
<< "options\n"
<< " --shell run the shell after executing files\n"
<< " -u <username>\n"
<< " -p<password> - notice no space\n"
<< " --host <host> - server to connect to\n"
<< " --port <port> - port to connect to\n"
<< " --nodb don't connect to mongo program on startup. No 'db address' arg expected.\n"
<< "file names: a list of files to run. will exit after unless --shell is specified\n"
;
return 0;
}
if (strcmp(str, "-f") == 0) {
continue;
}
if (strncmp(str, "--", 2) == 0) {
printf("Warning: unknown flag %s.\nTry --help for options\n", str);
continue;
}
if ( nodb )
break;
const char * last = strstr( str , "/" );
if ( last )
last++;
else
last = str;
if ( ! strstr( last , "." ) ){
url = str;
continue;
}
if ( strstr( last , ".js" ) )
break;
path p( str );
if ( ! boost::filesystem::exists( p ) ){
url = str;
continue;
}
break;
}
if ( !nodb ) { // init mongo code
v8::HandleScope handle_scope;
cout << "url: " << url << endl;
string setup = (string)"db = connect( \"" + fixHost( url , dbhost , port ) + "\")";
if ( ! ExecuteString( v8::String::New( setup.c_str() ) , v8::String::New( "(connect)" ) , false , true ) ){
return -1;
}
if ( username.size() && password.size() ){
stringstream ss;
ss << "if ( ! db.auth( \"" << username << "\" , \"" << password << "\" ) ){ throw 'login failed'; }";
if ( ! ExecuteString( v8::String::New( ss.str().c_str() ) , v8::String::New( "(auth)" ) , true , true ) ){
cout << "login failed" << endl;
return -1;
}
}
}
int numFiles = 0;
for ( ; argNumber < argc; argNumber++) {
const char* str = argv[argNumber];
v8::HandleScope handle_scope;
v8::Handle<v8::String> file_name = v8::String::New(str);
v8::Handle<v8::String> source = ReadFile(str);
if (source.IsEmpty()) {
printf("Error reading '%s'\n", str);
return 1;
}
if (!ExecuteString(source, file_name, false, true)){
cout << "error processing: " << file_name << endl;
return 1;
}
numFiles++;
}
if ( numFiles == 0 )
runShell = true;
if ( runShell ){
shellHistoryInit();
cout << "type \"help\" for help" << endl;
v8::Handle<v8::Object> shellHelper = baseContext_->Global()->Get( v8::String::New( "shellHelper" ) )->ToObject();
while ( 1 ){
char * line = shellReadline( "> " );
if ( ! line || ( strlen(line) == 4 && strstr( line , "exit" ) ) ){
cout << "bye" << endl;
break;
}
string code = line;
if ( code == "exit" ){
break;
}
{
string cmd = line;
if ( cmd.find( " " ) > 0 )
cmd = cmd.substr( 0 , cmd.find( " " ) );
if ( shellHelper->HasRealNamedProperty( v8::String::New( cmd.c_str() ) ) ){
stringstream ss;
ss << "shellHelper( \"" << cmd << "\" , \"" << code.substr( cmd.size() ) << "\" )";
code = ss.str();
}
}
v8::HandleScope handle_scope;
ExecuteString(v8::String::New( code.c_str() ),
v8::String::New("(shell)"),
true,
true);
shellHistoryAdd( line );
}
shellHistoryDone();
}
return 0;
}
bool callOnRilRequest(v8::Handle<v8::Context> context, int request,
void *data, size_t datalen, RIL_Token t) {
v8::HandleScope handle_scope;
v8::TryCatch try_catch;
// Get the onRilRequestFunction, making sure its a function
v8::Handle<v8::String> name = v8::String::New("onRilRequest");
v8::Handle<v8::Value> onRilRequestFunctionValue = context->Global()->Get(name);
if(!onRilRequestFunctionValue->IsFunction()) {
// Wasn't a function
ALOGD("callOnRilRequest X wasn't a function");
return false;
}
v8::Handle<v8::Function> onRilRequestFunction =
v8::Handle<v8::Function>::Cast(onRilRequestFunctionValue);
// Create the request
v8::Handle<v8::Value> v8RequestValue = v8::Number::New(request);
// Create the parameter for the request
v8::Handle<v8::Object> params_obj =
v8::ObjectTemplate::New()->NewInstance();
switch(request) {
case(RIL_REQUEST_SCREEN_STATE): {
ALOGD("callOnRilRequest RIL_REQUEST_SCREEN_STATE");
if (datalen < sizeof(int)) {
ALOGD("callOnRilRequest err size < sizeof int");
} else {
v8::Handle<v8::ObjectTemplate> params_obj_template =
v8::ObjectTemplate::New();
params_obj_template->SetInternalFieldCount(1);
params_obj_template->SetAccessor(v8::String::New(
"ReqScreenState"), GetReqScreenState, NULL);
// How to not leak this pointer!!!
int *p = new int;
*p = ((int *)data)[0];
params_obj = params_obj_template->NewInstance();
params_obj->SetInternalField(0, v8::External::New(p));
}
break;
}
default: {
ALOGD("callOnRilRequest X unknown request");
break;
}
}
// Invoke onRilRequest
bool retValue;
const int argc = 2;
v8::Handle<v8::Value> argv[argc] = { v8RequestValue, params_obj };
v8::Handle<v8::Value> result =
onRilRequestFunction->Call(context->Global(), argc, argv);
if (try_catch.HasCaught()) {
ALOGD("callOnRilRequest error");
ReportException(&try_catch);
retValue = false;
} else {
v8::String::Utf8Value result_string(result);
ALOGD("callOnRilRequest result=%s", ToCString(result_string));
retValue = true;
}
return retValue;
}
v8::Handle<v8::Value> V8Proxy::getHiddenObjectPrototype(v8::Handle<v8::Context> context)
{
return context->Global()->GetHiddenValue(V8HiddenPropertyName::objectPrototype());
}
static v8::Local<v8::Value> getEvent(const v8::Handle<v8::Context>& context)
{
static v8::Persistent<v8::String> eventSymbol(v8::Persistent<v8::String>::New(v8::String::NewSymbol("event")));
return context->Global()->GetHiddenValue(eventSymbol);
}