v8::Handle<v8::Value> V8CPlatform::numberOfDevicesAttrGetterCustom(v8::Local<v8::String> name, const v8::AccessorInfo& info)
{
CPlatform* imp = V8CPlatform::toNative(info.Holder());
int number = imp->openclUtil()->numberOfDevices();
if (number == -1)
return throwError(v8SyntaxError, "Cannot get numberOfDevices.", info.GetIsolate());
return v8UnsignedInteger(number, info.GetIsolate());
}
static v8::Handle<v8::Value> insertRuleCallback(const v8::Arguments& args)
{
CSSStyleSheet* imp = V8CSSStyleSheet::toNative(args.Holder());
ExceptionCode ec = 0;
{
V8TRYCATCH_FOR_V8STRINGRESOURCE(V8StringResource<>, rule, MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined));
V8TRYCATCH(unsigned, index, toUInt32(MAYBE_MISSING_PARAMETER(args, 1, DefaultIsUndefined)));
unsigned result = imp->insertRule(rule, index, ec);
if (UNLIKELY(ec))
goto fail;
return v8UnsignedInteger(result, args.GetIsolate());
}
fail:
return setDOMException(ec, args.GetIsolate());
}
bool ArrayValue::get(size_t index, Dictionary& value) const
{
if (isUndefinedOrNull())
return false;
if (index >= m_array->Length())
return false;
v8::Local<v8::Value> indexedValue = m_array->Get(v8UnsignedInteger(index));
if (indexedValue.IsEmpty() || !indexedValue->IsObject())
return false;
ASSERT(m_isolate);
ASSERT(m_isolate == v8::Isolate::GetCurrent());
value = Dictionary(indexedValue, m_isolate);
return true;
}
static v8::Handle<v8::Value> lengthAttrGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
{
Int8Array* imp = V8Int8Array::toNative(info.Holder());
return v8UnsignedInteger(imp->length(), info.GetIsolate());
}
void V8LazyEventListener::prepareListenerObject(ScriptExecutionContext* context)
{
if (hasExistingListenerObject())
return;
if (context->isDocument() && !static_cast<Document*>(context)->contentSecurityPolicy()->allowInlineEventHandlers(m_sourceURL, m_position.m_line))
return;
v8::HandleScope handleScope;
ASSERT(context->isDocument());
Frame* frame = static_cast<Document*>(context)->frame();
ASSERT(frame);
if (!frame->script()->canExecuteScripts(NotAboutToExecuteScript))
return;
// Use the outer scope to hold context.
v8::Local<v8::Context> v8Context = toV8Context(context, worldContext());
// Bail out if we cannot get the context.
if (v8Context.IsEmpty())
return;
v8::Context::Scope scope(v8Context);
// Nodes other than the document object, when executing inline event
// handlers push document, form, and the target node on the scope chain.
// We do this by using 'with' statement.
// See chrome/fast/forms/form-action.html
// chrome/fast/forms/selected-index-value.html
// base/fast/overflow/onscroll-layer-self-destruct.html
//
// Don't use new lines so that lines in the modified handler
// have the same numbers as in the original code.
// FIXME: V8 does not allow us to programmatically create object environments so
// we have to do this hack! What if m_code escapes to run arbitrary script?
//
// Call with 4 arguments instead of 3, pass additional null as the last parameter.
// By calling the function with 4 arguments, we create a setter on arguments object
// which would shadow property "3" on the prototype.
String code = "(function() {"
"with (this[2]) {"
"with (this[1]) {"
"with (this[0]) {"
"return function(" + m_eventParameterName + ") {" +
m_code + "\n" // Insert '\n' otherwise //-style comments could break the handler.
"};"
"}}}})";
v8::Handle<v8::String> codeExternalString = v8ExternalString(code);
v8::Handle<v8::Script> script = ScriptSourceCode::compileScript(codeExternalString, m_sourceURL, m_position);
if (script.IsEmpty())
return;
// FIXME: Remove this code when we stop doing the 'with' hack above.
v8::Local<v8::Value> value;
{
V8RecursionScope::MicrotaskSuppression scope;
value = script->Run();
}
if (value.IsEmpty())
return;
// Call the outer function to get the inner function.
ASSERT(value->IsFunction());
v8::Local<v8::Function> intermediateFunction = value.As<v8::Function>();
HTMLFormElement* formElement = 0;
if (m_node && m_node->isHTMLElement())
formElement = static_cast<HTMLElement*>(m_node)->form();
v8::Handle<v8::Object> nodeWrapper = toObjectWrapper<Node>(m_node);
v8::Handle<v8::Object> formWrapper = toObjectWrapper<HTMLFormElement>(formElement);
v8::Handle<v8::Object> documentWrapper = toObjectWrapper<Document>(m_node ? m_node->ownerDocument() : 0);
v8::Local<v8::Object> thisObject = v8::Object::New();
if (thisObject.IsEmpty())
return;
if (!thisObject->ForceSet(v8UnsignedInteger(0), nodeWrapper))
return;
if (!thisObject->ForceSet(v8UnsignedInteger(1), formWrapper))
return;
if (!thisObject->ForceSet(v8UnsignedInteger(2), documentWrapper))
return;
// FIXME: Remove this code when we stop doing the 'with' hack above.
v8::Local<v8::Value> innerValue;
{
V8RecursionScope::MicrotaskSuppression scope;
innerValue = intermediateFunction->Call(thisObject, 0, 0);
}
if (innerValue.IsEmpty() || !innerValue->IsFunction())
return;
v8::Local<v8::Function> wrappedFunction = innerValue.As<v8::Function>();
// Change the toString function on the wrapper function to avoid it
// returning the source for the actual wrapper function. Instead it
// returns source for a clean wrapper function with the event
// argument wrapping the event source code. The reason for this is
// that some web sites use toString on event functions and eval the
// source returned (sometimes a RegExp is applied as well) for some
// other use. That fails miserably if the actual wrapper source is
// returned.
v8::Persistent<v8::FunctionTemplate>& toStringTemplate =
V8PerIsolateData::current()->lazyEventListenerToStringTemplate();
if (toStringTemplate.IsEmpty())
toStringTemplate = v8::Persistent<v8::FunctionTemplate>::New(v8::FunctionTemplate::New(V8LazyEventListenerToString));
v8::Local<v8::Function> toStringFunction;
if (!toStringTemplate.IsEmpty())
toStringFunction = toStringTemplate->GetFunction();
if (!toStringFunction.IsEmpty()) {
String toStringString = "function " + m_functionName + "(" + m_eventParameterName + ") {\n " + m_code + "\n}";
wrappedFunction->SetHiddenValue(V8HiddenPropertyName::toStringString(), v8ExternalString(toStringString));
wrappedFunction->Set(v8::String::NewSymbol("toString"), toStringFunction);
}
wrappedFunction->SetName(v8String(m_functionName));
// FIXME: Remove the following comment-outs.
// See https://bugs.webkit.org/show_bug.cgi?id=85152 for more details.
//
// For the time being, we comment out the following code since the
// second parsing can happen.
// // Since we only parse once, there's no need to keep data used for parsing around anymore.
// m_functionName = String();
// m_code = String();
// m_eventParameterName = String();
// m_sourceURL = String();
setListenerObject(wrappedFunction);
}
static v8::Handle<v8::Value> getPathSegAtLengthCallback(const v8::Arguments& args)
{
SVGPathElement* imp = V8SVGPathElement::toNative(args.Holder());
V8TRYCATCH(float, distance, static_cast<float>(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)->NumberValue()));
return v8UnsignedInteger(imp->getPathSegAtLength(distance), args.GetIsolate());
}
static v8::Handle<v8::Value> numberOfItemsAttrGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
{
SVGStaticListPropertyTearOff<SVGStringList>* imp = V8SVGStringList::toNative(info.Holder());
return v8UnsignedInteger(imp->numberOfItems(), info.GetIsolate());
}
static v8::Handle<v8::Value> indexAttrGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
{
Gamepad* imp = V8Gamepad::toNative(info.Holder());
return v8UnsignedInteger(imp->index(), info.GetIsolate());
}
static v8::Handle<v8::Value> lengthAttrGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
{
DOMNamedFlowCollection* imp = V8DOMNamedFlowCollection::toNative(info.Holder());
return v8UnsignedInteger(imp->length(), info.GetIsolate());
}
static v8::Handle<v8::Value> whatToShowAttrGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
{
TreeWalker* imp = V8TreeWalker::toNative(info.Holder());
return v8UnsignedInteger(imp->whatToShow(), info.GetIsolate());
}
static v8::Handle<v8::Value> videoHeightAttrGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
{
HTMLVideoElement* imp = V8HTMLVideoElement::toNative(info.Holder());
return v8UnsignedInteger(imp->videoHeight(), info.GetIsolate());
}
static v8::Handle<v8::Value> heightAttrGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
{
HTMLVideoElement* imp = V8HTMLVideoElement::toNative(info.Holder());
return v8UnsignedInteger(std::max(0, imp->getIntegralAttribute(WebCore::HTMLNames::heightAttr)), info.GetIsolate());
}