void V8DOMConfiguration::batchConfigureConstants(v8::Handle<v8::FunctionTemplate> functionDescriptor, v8::Handle<v8::ObjectTemplate> prototype, const BatchedConstant* constants, size_t constantCount, v8::Isolate* isolate)
{
for (size_t i = 0; i < constantCount; ++i) {
const BatchedConstant* constant = &constants[i];
functionDescriptor->Set(v8::String::NewSymbol(constant->name), v8Integer(constant->value, isolate), v8::ReadOnly);
prototype->Set(v8::String::NewSymbol(constant->name), v8Integer(constant->value, isolate), v8::ReadOnly);
}
}
v8::Handle<v8::Script> ScriptSourceCode::compileScript(v8::Handle<v8::String> code, const String& fileName, const TextPosition& scriptStartPosition, v8::ScriptData* scriptData, v8::Isolate* isolate)
{
v8::Handle<v8::String> name = v8String(fileName, isolate);
v8::Handle<v8::Integer> line = v8Integer(scriptStartPosition.m_line.zeroBasedInt(), isolate);
v8::Handle<v8::Integer> column = v8Integer(scriptStartPosition.m_column.zeroBasedInt(), isolate);
v8::ScriptOrigin origin(name, line, column);
v8::Handle<v8::Script> script = v8::Script::Compile(code, &origin, scriptData);
return script;
}
v8::Handle<v8::Script> V8Proxy::compileScript(v8::Handle<v8::String> code, const String& fileName, const TextPosition& scriptStartPosition, v8::ScriptData* scriptData)
{
const uint16_t* fileNameString = fromWebCoreString(fileName);
v8::Handle<v8::String> name = v8::String::New(fileNameString, fileName.length());
v8::Handle<v8::Integer> line = v8Integer(scriptStartPosition.m_line.zeroBasedInt());
v8::Handle<v8::Integer> column = v8Integer(scriptStartPosition.m_column.zeroBasedInt());
v8::ScriptOrigin origin(name, line, column);
v8::Handle<v8::Script> script = v8::Script::Compile(code, &origin, scriptData);
return script;
}
void batchConfigureConstants(v8::Handle<v8::FunctionTemplate> functionDescriptor,
v8::Handle<v8::ObjectTemplate> proto,
const BatchedConstant* constants,
size_t constantCount)
{
for (size_t i = 0; i < constantCount; ++i) {
const BatchedConstant* constant = &constants[i];
functionDescriptor->Set(v8::String::New(constant->name), v8Integer(constant->value), v8::ReadOnly);
proto->Set(v8::String::New(constant->name), v8Integer(constant->value), v8::ReadOnly);
}
}
v8::Handle<v8::Value> convertNPVariantToV8Object(const NPVariant* variant, NPObject* npobject)
{
NPVariantType type = variant->type;
switch (type) {
case NPVariantType_Int32:
return v8Integer(NPVARIANT_TO_INT32(*variant));
case NPVariantType_Double:
return v8::Number::New(NPVARIANT_TO_DOUBLE(*variant));
case NPVariantType_Bool:
return v8Boolean(NPVARIANT_TO_BOOLEAN(*variant));
case NPVariantType_Null:
return v8::Null();
case NPVariantType_Void:
return v8::Undefined();
case NPVariantType_String: {
NPString src = NPVARIANT_TO_STRING(*variant);
return v8::String::New(src.UTF8Characters, src.UTF8Length);
}
case NPVariantType_Object: {
NPObject* obj = NPVARIANT_TO_OBJECT(*variant);
if (obj->_class == npScriptObjectClass)
return reinterpret_cast<V8NPObject*>(obj)->v8Object;
return createV8ObjectForNPObject(obj, npobject);
}
default:
return v8::Undefined();
}
}
v8::Handle<v8::Value> V8HTMLOptionsCollection::lengthAccessorGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
{
INC_STATS("DOM.HTMLOptionsCollection.length._get");
HTMLOptionsCollection* imp = V8HTMLOptionsCollection::toNative(info.Holder());
int v = imp->length();
return v8Integer(v, info.GetIsolate());
}
static v8::Handle<v8::Value> meetOrSliceAttrGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
{
SVGPropertyTearOff<SVGPreserveAspectRatio>* wrapper = V8SVGPreserveAspectRatio::toNative(info.Holder());
SVGPreserveAspectRatio& impInstance = wrapper->propertyReference();
SVGPreserveAspectRatio* imp = &impInstance;
return v8Integer(imp->meetOrSlice(), info.GetIsolate());
}
v8::Handle<v8::Value> v8Array(PassRefPtr<DOMStringList> stringList, v8::Isolate* isolate)
{
if (!stringList)
return v8::Array::New();
v8::Local<v8::Array> result = v8::Array::New(stringList->length());
for (unsigned i = 0; i < stringList->length(); ++i)
result->Set(v8Integer(i, isolate), v8String(stringList->item(i), isolate));
return result;
}
v8::Handle<v8::Value> SetTimeoutOrInterval(const v8::Arguments& args, bool singleShot)
{
WorkerContext* workerContext = V8WorkerContext::toNative(args.Holder());
int argumentCount = args.Length();
if (argumentCount < 1)
return v8::Undefined();
v8::Handle<v8::Value> function = args[0];
int32_t timeout = argumentCount >= 2 ? args[1]->Int32Value() : 0;
int timerId;
WorkerContextExecutionProxy* proxy = workerContext->script()->proxy();
if (!proxy)
return v8::Undefined();
v8::Handle<v8::Context> v8Context = proxy->context();
if (function->IsString()) {
if (ContentSecurityPolicy* policy = workerContext->contentSecurityPolicy()) {
if (!policy->allowEval())
return v8Integer(0, args.GetIsolate());
}
WTF::String stringFunction = toWebCoreString(function);
timerId = DOMTimer::install(workerContext, adoptPtr(new ScheduledAction(v8Context, stringFunction, workerContext->url())), timeout, singleShot);
} else if (function->IsFunction()) {
size_t paramCount = argumentCount >= 2 ? argumentCount - 2 : 0;
v8::Local<v8::Value>* params = 0;
if (paramCount > 0) {
params = new v8::Local<v8::Value>[paramCount];
for (size_t i = 0; i < paramCount; ++i)
params[i] = args[i+2];
}
// ScheduledAction takes ownership of actual params and releases them in its destructor.
OwnPtr<ScheduledAction> action = adoptPtr(new ScheduledAction(v8Context, v8::Handle<v8::Function>::Cast(function), paramCount, params));
// FIXME: We should use a OwnArrayPtr for params.
delete [] params;
timerId = DOMTimer::install(workerContext, action.release(), timeout, singleShot);
} else
return v8::Undefined();
return v8Integer(timerId, args.GetIsolate());
}
// Use an array to hold dependents. It works like a ref-counted scheme.
// A value can be added more than once to the DOM object.
void createHiddenDependency(v8::Handle<v8::Object> object, v8::Local<v8::Value> value, int cacheIndex)
{
v8::Local<v8::Value> cache = object->GetInternalField(cacheIndex);
if (cache->IsNull() || cache->IsUndefined()) {
cache = v8::Array::New();
object->SetInternalField(cacheIndex, cache);
}
v8::Local<v8::Array> cacheArray = v8::Local<v8::Array>::Cast(cache);
cacheArray->Set(v8Integer(cacheArray->Length()), value);
}
v8::Handle<v8::Value> V8HTMLInputElement::selectionEndAttrGetterCustom(v8::Local<v8::String> name, const v8::AccessorInfo& info)
{
v8::Handle<v8::Object> holder = info.Holder();
HTMLInputElement* imp = V8HTMLInputElement::toNative(holder);
if (!imp->canHaveSelection())
return throwTypeError("Accessing selectionEnd on an input element that cannot have a selection.", info.GetIsolate());
int v = imp->selectionEnd();
return v8Integer(v, info.GetIsolate());
}
static v8::Handle<v8::Value> portsAttrGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
{
TestSerializedScriptValueInterface* imp = V8TestSerializedScriptValueInterface::toNative(info.Holder());
MessagePortArray* ports = imp->ports();
if (!ports)
return v8::Array::New(0);
MessagePortArray portsCopy(*ports);
v8::Local<v8::Array> portArray = v8::Array::New(portsCopy.size());
for (size_t i = 0; i < portsCopy.size(); ++i)
portArray->Set(v8Integer(i, info.GetIsolate()), toV8Fast(portsCopy[i].get(), info, imp));
return portArray;
}
static v8::Handle<v8::Value> addRuleCallback(const v8::Arguments& args)
{
CSSStyleSheet* imp = V8CSSStyleSheet::toNative(args.Holder());
ExceptionCode ec = 0;
{
V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, selector, MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined));
V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, style, MAYBE_MISSING_PARAMETER(args, 1, DefaultIsUndefined));
if (args.Length() <= 2) {
int result = imp->addRule(selector, style, ec);
if (UNLIKELY(ec))
goto fail;
return v8Integer(result, args.GetIsolate());
}
V8TRYCATCH(unsigned, index, toUInt32(MAYBE_MISSING_PARAMETER(args, 2, DefaultIsUndefined)));
int result = imp->addRule(selector, style, index, ec);
if (UNLIKELY(ec))
goto fail;
return v8Integer(result, args.GetIsolate());
}
fail:
return setDOMException(ec, args.GetIsolate());
}
v8::Handle<v8::Value> V8DataView::getUint8Callback(const v8::Arguments& args)
{
if (args.Length() < 1)
return throwNotEnoughArgumentsError(args.GetIsolate());
DataView* imp = V8DataView::toNative(args.Holder());
ExceptionCode ec = 0;
V8TRYCATCH(unsigned, byteOffset, toUInt32(args[0]));
uint8_t result = imp->getUint8(byteOffset, ec);
if (UNLIKELY(ec))
return setDOMException(ec, args.GetIsolate());
return v8Integer(result, args.GetIsolate());
}
v8::Handle<v8::Value> V8InjectedScriptHost::functionDetailsCallback(const v8::Arguments& args)
{
INC_STATS("InjectedScriptHost.functionDetailsCallback()");
if (args.Length() < 1)
return v8::Undefined();
v8::HandleScope handleScope;
v8::Handle<v8::Value> value = args[0];
if (!value->IsFunction())
return v8::Undefined();
v8::Handle<v8::Function> function = v8::Handle<v8::Function>::Cast(value);
int lineNumber = function->GetScriptLineNumber();
int columnNumber = function->GetScriptColumnNumber();
v8::Local<v8::Object> location = v8::Object::New();
location->Set(v8::String::NewSymbol("lineNumber"), v8Integer(lineNumber, args.GetIsolate()));
location->Set(v8::String::NewSymbol("columnNumber"), v8Integer(columnNumber, args.GetIsolate()));
location->Set(v8::String::NewSymbol("scriptId"), function->GetScriptId()->ToString());
v8::Local<v8::Object> result = v8::Object::New();
result->Set(v8::String::NewSymbol("location"), location);
v8::Handle<v8::Value> name = function->GetName();
if (name->IsString() && v8::Handle<v8::String>::Cast(name)->Length())
result->Set(v8::String::NewSymbol("name"), name);
v8::Handle<v8::Value> inferredName = function->GetInferredName();
if (inferredName->IsString() && v8::Handle<v8::String>::Cast(inferredName)->Length())
result->Set(v8::String::NewSymbol("inferredName"), inferredName);
InjectedScriptHost* host = V8InjectedScriptHost::toNative(args.Holder());
ScriptDebugServer& debugServer = host->scriptDebugServer();
v8::Handle<v8::Value> scopes = debugServer.functionScopes(function);
if (!scopes.IsEmpty() && scopes->IsArray())
result->Set(v8::String::NewSymbol("rawScopes"), scopes);
return result;
}
void removeHiddenDependency(v8::Handle<v8::Object> object, v8::Local<v8::Value> value, int cacheIndex)
{
v8::Local<v8::Value> cache = object->GetInternalField(cacheIndex);
if (!cache->IsArray())
return;
v8::Local<v8::Array> cacheArray = v8::Local<v8::Array>::Cast(cache);
for (int i = cacheArray->Length() - 1; i >= 0; --i) {
v8::Local<v8::Value> cached = cacheArray->Get(v8Integer(i));
if (cached->StrictEquals(value)) {
cacheArray->Delete(i);
return;
}
}
}
v8::Handle<v8::Integer> V8Storage::namedPropertyQuery(v8::Local<v8::String> v8Name, const v8::AccessorInfo& info)
{
Storage* storage = V8Storage::toNative(info.Holder());
String name = toWebCoreString(v8Name);
if (name == "length")
return v8::Handle<v8::Integer>();
ExceptionCode ec = 0;
bool found = storage->contains(name, ec);
if (ec)
return setDOMException<v8::Integer>(ec, info);
if (!found)
return v8::Handle<v8::Integer>();
return v8Integer(0, info.GetIsolate());
}
v8::Handle<v8::Value> V8MessageEvent::portsAccessorGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
{
MessageEvent* event = V8MessageEvent::toNative(info.Holder());
MessagePortArray* ports = event->ports();
if (!ports)
return v8::Array::New(0);
MessagePortArray portsCopy(*ports);
v8::Local<v8::Array> portArray = v8::Array::New(portsCopy.size());
for (size_t i = 0; i < portsCopy.size(); ++i)
portArray->Set(v8Integer(i, info.GetIsolate()), toV8(portsCopy[i].get(), info.Holder(), info.GetIsolate()));
return portArray;
}
v8::Handle<v8::Value> V8Clipboard::typesAccessorGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
{
INC_STATS("DOM.Clipboard.types()");
Clipboard* clipboard = V8Clipboard::toNative(info.Holder());
ListHashSet<String> types = clipboard->types();
if (types.isEmpty())
return v8::Null(info.GetIsolate());
v8::Local<v8::Array> result = v8::Array::New(types.size());
ListHashSet<String>::const_iterator end = types.end();
int index = 0;
for (ListHashSet<String>::const_iterator it = types.begin(); it != end; ++it, ++index)
result->Set(v8Integer(index, info.GetIsolate()), v8String(*it, info.GetIsolate()));
return result;
}
bool Dictionary::get(const String& key, HashSet<AtomicString>& value) const
{
v8::Local<v8::Value> v8Value;
if (!getKey(key, v8Value))
return false;
// FIXME: Support array-like objects
if (!v8Value->IsArray())
return false;
v8::Local<v8::Array> v8Array = v8::Local<v8::Array>::Cast(v8Value);
for (size_t i = 0; i < v8Array->Length(); ++i) {
v8::Local<v8::Value> indexedValue = v8Array->Get(v8Integer(i));
value.add(v8ValueToWebCoreString(indexedValue));
}
return true;
}
// Get an array containing the names of indexed properties in a collection.
v8::Handle<v8::Array> V8Storage::namedPropertyEnumerator(const v8::AccessorInfo& info)
{
Storage* storage = V8Storage::toNative(info.Holder());
ExceptionCode ec = 0;
unsigned length = storage->length(ec);
if (ec)
return setDOMException<v8::Array>(ec, info);
v8::Handle<v8::Array> properties = v8::Array::New(length);
for (unsigned i = 0; i < length; ++i) {
String key = storage->key(i, ec);
if (ec)
return setDOMException<v8::Array>(ec, info);
ASSERT(!key.isNull());
String val = storage->getItem(key, ec);
if (ec)
return setDOMException<v8::Array>(ec, info);
properties->Set(v8Integer(i, info.GetIsolate()), v8String(key, info.GetIsolate()));
}
return properties;
}
PassRefPtr<DOMStringList> toDOMStringList(v8::Handle<v8::Value> value)
{
v8::Local<v8::Value> v8Value(v8::Local<v8::Value>::New(value));
if (V8DOMStringList::HasInstance(v8Value)) {
RefPtr<DOMStringList> ret = V8DOMStringList::toNative(v8::Handle<v8::Object>::Cast(v8Value));
return ret.release();
}
if (!v8Value->IsArray())
return 0;
RefPtr<DOMStringList> ret = DOMStringList::create();
v8::Local<v8::Array> v8Array = v8::Local<v8::Array>::Cast(v8Value);
for (size_t i = 0; i < v8Array->Length(); ++i) {
v8::Local<v8::Value> indexedValue = v8Array->Get(v8Integer(i));
ret->append(toWebCoreString(indexedValue));
}
return ret.release();
}
bool V8MutationCallback::handleEvent(MutationRecordArray* mutations, MutationObserver* observer)
{
ASSERT(mutations);
if (!mutations)
return true;
if (!canInvokeCallback())
return true;
v8::HandleScope handleScope;
v8::Handle<v8::Context> v8Context = toV8Context(scriptExecutionContext(), m_worldContext);
if (v8Context.IsEmpty())
return true;
v8::Context::Scope scope(v8Context);
v8::Local<v8::Array> mutationsArray = v8::Array::New(mutations->size());
for (size_t i = 0; i < mutations->size(); ++i)
mutationsArray->Set(v8Integer(i, v8Context->GetIsolate()), toV8(mutations->at(i).get(), v8::Handle<v8::Object>(), v8Context->GetIsolate()));
v8::Handle<v8::Value> observerHandle = toV8(observer, v8::Handle<v8::Object>(), v8Context->GetIsolate());
if (observerHandle.IsEmpty()) {
if (!isScriptControllerTerminating())
CRASH();
return true;
}
if (!observerHandle->IsObject())
return true;
v8::Handle<v8::Value> argv[] = {
mutationsArray,
observerHandle
};
bool callbackReturnValue = false;
return !invokeCallback(m_callback.get(), v8::Handle<v8::Object>::Cast(observerHandle), 2, argv, callbackReturnValue, scriptExecutionContext());
}
static v8::Handle<v8::Value> excitingAttrAttrGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
{
TestActiveDOMObject* imp = V8TestActiveDOMObject::toNative(info.Holder());
return v8Integer(imp->excitingAttr(), info.GetIsolate());
}
static v8::Handle<v8::Value> supplementalStaticReadOnlyAttrAttrGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
{
INC_STATS("DOM.TestInterface.supplementalStaticReadOnlyAttr._get");
return v8Integer(TestSupplemental::supplementalStaticReadOnlyAttr(), info.GetIsolate());
}
v8::Local<v8::Value> V8WindowErrorHandler::callListenerFunction(ScriptExecutionContext* context, v8::Handle<v8::Value> jsEvent, Event* event)
{
if (!event->hasInterface(eventNames().interfaceForErrorEvent))
return V8EventListener::callListenerFunction(context, jsEvent, event);
ErrorEvent* errorEvent = static_cast<ErrorEvent*>(event);
v8::Local<v8::Object> listener = getListenerObject(context);
v8::Local<v8::Value> returnValue;
if (!listener.IsEmpty() && listener->IsFunction()) {
v8::Local<v8::Function> callFunction = v8::Local<v8::Function>::Cast(listener);
v8::Local<v8::Object> thisValue = v8::Context::GetCurrent()->Global();
v8::Handle<v8::Value> parameters[3] = { v8String(errorEvent->message()), v8String(errorEvent->filename()), v8Integer(errorEvent->lineno()) };
v8::TryCatch tryCatch;
tryCatch.SetVerbose(true);
returnValue = V8Proxy::instrumentedCallFunction(0 /* frame */, callFunction, thisValue, 3, parameters);
}
return returnValue;
}
static v8::Handle<v8::Value> codeAttrGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
{
CloseEvent* imp = V8CloseEvent::toNative(info.Holder());
return v8Integer(imp->code(), info.GetIsolate());
}
static v8::Handle<v8::Value> attrChangeAttrGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
{
MutationEvent* imp = V8MutationEvent::toNative(info.Holder());
return v8Integer(imp->attrChange(), info.GetIsolate());
}
static v8::Handle<v8::Value> codeAttrGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
{
XMLHttpRequestException* imp = V8XMLHttpRequestException::toNative(info.Holder());
return v8Integer(imp->code(), info.GetIsolate());
}
static v8::Handle<v8::Value> animValAttrGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
{
SVGAnimatedInteger* imp = V8SVGAnimatedInteger::toNative(info.Holder());
return v8Integer(imp->animVal(), info.GetIsolate());
}