void npObjectIndexedGetter(uint32_t index, const v8::PropertyCallbackInfo<v8::Value>& info)
{
HTMLPlugInElement* imp = C::toNative(info.Holder());
ScriptInstance scriptInstance = imp->getInstance();
if (!scriptInstance)
return;
v8::Local<v8::Object> instance = scriptInstance->newLocal(v8::Isolate::GetCurrent());
if (instance.IsEmpty())
return;
npObjectGetIndexedProperty(instance, index, info);
}
void V8XMLHttpRequest::responseTextAttributeGetterCustom(const v8::PropertyCallbackInfo<v8::Value>& info)
{
XMLHttpRequest* xmlHttpRequest = V8XMLHttpRequest::toNative(info.Holder());
ExceptionState exceptionState(ExceptionState::GetterContext, "responseText", "XMLHttpRequest", info.Holder(), info.GetIsolate());
ScriptValue text = xmlHttpRequest->responseText(exceptionState);
if (exceptionState.throwIfNeeded())
return;
if (text.isEmpty()) {
v8SetReturnValueString(info, emptyString(), info.GetIsolate());
return;
}
v8SetReturnValue(info, text.v8Value());
}
static void npObjectNamedSetter(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<v8::Value>& info)
{
HTMLPlugInElement* imp = C::toNative(info.Holder());
ScriptInstance scriptInstance = imp->getInstance();
if (!scriptInstance)
return;
v8::Local<v8::Object> instance = scriptInstance->newLocal(info.GetIsolate());
if (instance.IsEmpty())
return;
npObjectSetNamedProperty(instance, name, value, info);
}
static void indexedPropertySetter(uint32_t index, v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<v8::Value>& info)
{
TestEventTarget* imp = V8TestEventTarget::toNative(info.Holder());
V8TRYCATCH_VOID(Node*, propertyValue, V8Node::toNativeWithTypeCheck(info.GetIsolate(), jsValue));
if (!isUndefinedOrNull(jsValue) && !V8Node::hasInstance(jsValue, info.GetIsolate())) {
exceptionState.throwTypeError("The provided value is not of type 'Node'.");
exceptionState.throwIfNeeded();
return;
}
bool result = imp->anonymousIndexedSetter(index, propertyValue);
if (!result)
return;
v8SetReturnValue(info, jsValue);
}
static void namedPropertyDeleter(v8::Local<v8::Name> name, const v8::PropertyCallbackInfo<v8::Boolean>& info)
{
if (!name->IsString())
return;
TestInterface2* impl = V8TestInterface2::toImpl(info.Holder());
AtomicString propertyName = toCoreAtomicString(name.As<v8::String>());
v8::String::Utf8Value namedProperty(name);
ExceptionState exceptionState(ExceptionState::DeletionContext, *namedProperty, "TestInterface2", info.Holder(), info.GetIsolate());
DeleteResult result = impl->deleteNamedItem(propertyName, exceptionState);
if (exceptionState.throwIfNeeded())
return;
if (result != DeleteUnknownProperty)
return v8SetReturnValueBool(info, result == DeleteSuccess);
}
static void namedPropertySetter(const AtomicString& name, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<v8::Value>& info)
{
TestSpecialOperations* impl = V8TestSpecialOperations::toImpl(info.Holder());
Node* propertyValue = V8Node::toImplWithTypeCheck(info.GetIsolate(), v8Value);
if (!propertyValue && !isUndefinedOrNull(v8Value)) {
exceptionState.throwTypeError("The provided value is not of type 'Node'.");
return;
}
bool result = impl->anonymousNamedSetter(name, propertyValue);
if (!result)
return;
v8SetReturnValue(info, v8Value);
}
static void namedPropertyEnumerator(const v8::PropertyCallbackInfo<v8::Array>& info)
{
TestInterface* impl = V8TestInterface::toNative(info.Holder());
v8::Isolate* isolate = info.GetIsolate();
Vector<String> names;
ExceptionState exceptionState(ExceptionState::EnumerationContext, "TestInterface", info.Holder(), isolate);
impl->namedPropertyEnumerator(names, exceptionState);
if (exceptionState.throwIfNeeded())
return;
v8::Handle<v8::Array> v8names = v8::Array::New(isolate, names.size());
for (size_t i = 0; i < names.size(); ++i)
v8names->Set(v8::Integer::New(isolate, i), v8String(isolate, names[i]));
v8SetReturnValue(info, v8names);
}
void V8Window::frameElementAttributeGetterCustom(const v8::PropertyCallbackInfo<v8::Value>& info)
{
LocalDOMWindow* impl = toLocalDOMWindow(V8Window::toImpl(info.Holder()));
ExceptionState exceptionState(ExceptionState::GetterContext, "frame", "Window", info.Holder(), info.GetIsolate());
// Do the security check against the parent frame rather than
// frameElement() itself, so that a remote parent frame can be handled
// properly. In that case, there's no frameElement(), yet we should still
// throw a proper exception and deny access.
Frame* target = impl->frame() ? impl->frame()->tree().parent() : nullptr;
if (!BindingSecurity::shouldAllowAccessToFrame(info.GetIsolate(), target, exceptionState)) {
v8SetReturnValueNull(info);
exceptionState.throwIfNeeded();
return;
}
// The wrapper for an <iframe> should get its prototype from the context of the frame it's in, rather than its own frame.
// So, use its containing document as the creation context when wrapping.
v8::Local<v8::Value> creationContext = toV8(&impl->frameElement()->document(), info.Holder(), info.GetIsolate());
RELEASE_ASSERT(!creationContext.IsEmpty());
v8::Local<v8::Value> wrapper = toV8(impl->frameElement(), v8::Local<v8::Object>::Cast(creationContext), info.GetIsolate());
v8SetReturnValue(info, wrapper);
}
void V8Window::eventAttributeSetterCustom(
v8::Local<v8::Value> value,
const v8::PropertyCallbackInfo<void>& info) {
LocalDOMWindow* impl = toLocalDOMWindow(V8Window::toImpl(info.Holder()));
ExceptionState exceptionState(ExceptionState::SetterContext, "event",
"Window", info.Holder(), info.GetIsolate());
if (!BindingSecurity::shouldAllowAccessTo(currentDOMWindow(info.GetIsolate()),
impl, exceptionState)) {
return;
}
LocalFrame* frame = impl->frame();
ASSERT(frame);
// This is a fast path to retrieve info.Holder()->CreationContext().
v8::Local<v8::Context> context =
toV8Context(frame, DOMWrapperWorld::current(info.GetIsolate()));
if (context.IsEmpty())
return;
V8HiddenValue::setHiddenValue(ScriptState::current(info.GetIsolate()),
context->Global(),
V8HiddenValue::event(info.GetIsolate()), value);
}
void V8Window::openerAttrSetterCustom(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info)
{
DOMWindow* imp = V8Window::toNative(info.Holder());
if (!BindingSecurity::shouldAllowAccessToFrame(imp->frame()))
return;
// Opener can be shadowed if it is in the same domain.
// Have a special handling of null value to behave
// like Firefox. See bug http://b/1224887 & http://b/791706.
if (value->IsNull()) {
// imp->frame() cannot be null,
// otherwise, SameOrigin check would have failed.
ASSERT(imp->frame());
imp->frame()->loader()->setOpener(0);
}
// Delete the accessor from this object.
info.Holder()->Delete(name);
// Put property on the front (this) object.
info.This()->Set(name, value);
}
void V8CSSStyleDeclaration::namedPropertyGetterCustom(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info)
{
// First look for API defined attributes on the style declaration object.
if (info.Holder()->HasRealNamedCallbackProperty(name))
return;
// Search the style declaration.
CSSPropertyInfo* propInfo = cssPropertyInfo(name);
// Do not handle non-property names.
if (!propInfo)
return;
CSSStyleDeclaration* impl = V8CSSStyleDeclaration::toNative(info.Holder());
RefPtr<CSSValue> cssValue = impl->getPropertyCSSValueInternal(static_cast<CSSPropertyID>(propInfo->propID));
if (cssValue) {
v8SetReturnValueStringOrNull(info, cssValue->cssText(), info.GetIsolate());
return;
}
String result = impl->getPropertyValueInternal(static_cast<CSSPropertyID>(propInfo->propID));
v8SetReturnValueString(info, result, info.GetIsolate());
}
static void namedPropertyEnumerator(const v8::PropertyCallbackInfo<v8::Array>& info)
{
TestInterface2* impl = V8TestInterface2::toImpl(info.Holder());
Vector<String> names;
ExceptionState exceptionState(ExceptionState::EnumerationContext, "TestInterface2", info.Holder(), info.GetIsolate());
impl->namedPropertyEnumerator(names, exceptionState);
if (exceptionState.throwIfNeeded())
return;
v8::Local<v8::Array> v8names = v8::Array::New(info.GetIsolate(), names.size());
for (size_t i = 0; i < names.size(); ++i) {
if (!v8CallBoolean(v8names->CreateDataProperty(info.GetIsolate()->GetCurrentContext(), i, v8String(info.GetIsolate(), names[i]))))
return;
}
v8SetReturnValue(info, v8names);
}
static void namedPropertyQuery(v8::Local<v8::Name> name, const v8::PropertyCallbackInfo<v8::Integer>& info)
{
if (!name->IsString())
return;
TestInterface2* impl = V8TestInterface2::toImpl(info.Holder());
AtomicString propertyName = toCoreAtomicString(name.As<v8::String>());
v8::String::Utf8Value namedProperty(name);
ExceptionState exceptionState(ExceptionState::GetterContext, *namedProperty, "TestInterface2", info.Holder(), info.GetIsolate());
bool result = impl->namedPropertyQuery(propertyName, exceptionState);
if (exceptionState.throwIfNeeded())
return;
if (!result)
return;
v8SetReturnValueInt(info, v8::None);
}
void V8Window::locationAttrSetterCustom(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info)
{
DOMWindow* imp = V8Window::toNative(info.Holder());
DOMWindow* active = activeDOMWindow();
if (!active)
return;
DOMWindow* first = firstDOMWindow();
if (!first)
return;
if (Location* location = imp->location())
location->setHref(active, first, toWebCoreString(value));
}
static void indexedPropertyGetter(uint32_t index, const v8::PropertyCallbackInfo<v8::Value>& info) {
ExceptionState exceptionState(info.GetIsolate(), ExceptionState::IndexedGetterContext, "TestInterface2");
TestInterface2* impl = V8TestInterface2::toImpl(info.Holder());
// We assume that all the implementations support length() method, although
// the spec doesn't require that length() must exist. It's okay that
// the interface does not have length attribute as long as the
// implementation supports length() member function.
if (index >= impl->length())
return; // Returns undefined due to out-of-range.
TestInterfaceEmpty* result = impl->item(index, exceptionState);
v8SetReturnValueFast(info, result, impl);
}
void V8Element::scrollTopAttributeSetterCustom(v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info)
{
ExceptionState exceptionState(ExceptionState::SetterContext, "scrollTop", "Element", info.Holder(), info.GetIsolate());
Element* imp = V8Element::toNative(info.Holder());
if (RuntimeEnabledFeatures::cssomSmoothScrollEnabled() && value->IsObject()) {
V8TRYCATCH_VOID(Dictionary, scrollOptionsVertical, Dictionary(value, info.GetIsolate()));
imp->setScrollTop(scrollOptionsVertical, exceptionState);
exceptionState.throwIfNeeded();
return;
}
V8TRYCATCH_EXCEPTION_VOID(int, position, toInt32(value, exceptionState), exceptionState);
imp->setScrollTop(position);
}
void V8PopStateEvent::stateAttributeGetterCustom(const v8::PropertyCallbackInfo<v8::Value>& info)
{
v8::Local<v8::Value> result = V8HiddenValue::getHiddenValue(info.GetIsolate(), info.Holder(), V8HiddenValue::state(info.GetIsolate()));
if (!result.IsEmpty()) {
v8SetReturnValue(info, result);
return;
}
PopStateEvent* event = V8PopStateEvent::toImpl(info.Holder());
History* history = event->history();
if (!history || !event->serializedState()) {
if (!event->serializedState()) {
// If we're in an isolated world and the event was created in the main world,
// we need to find the 'state' property on the main world wrapper and clone it.
v8::Local<v8::Value> mainWorldState = V8HiddenValue::getHiddenValueFromMainWorldWrapper(info.GetIsolate(), event, V8HiddenValue::state(info.GetIsolate()));
if (!mainWorldState.IsEmpty())
event->setSerializedState(SerializedScriptValueFactory::instance().createAndSwallowExceptions(info.GetIsolate(), mainWorldState));
}
if (event->serializedState())
result = event->serializedState()->deserialize();
else
result = v8::Null(info.GetIsolate());
v8SetReturnValue(info, cacheState(info.Holder(), result, info.GetIsolate()));
return;
}
// There's no cached value from a previous invocation, nor a state value was provided by the
// event, but there is a history object, so first we need to see if the state object has been
// deserialized through the history object already.
// The current history state object might've changed in the meantime, so we need to take care
// of using the correct one, and always share the same deserialization with history.state.
bool isSameState = history->isSameAsCurrentState(event->serializedState());
if (isSameState) {
v8::Local<v8::Value> v8HistoryValue = toV8(history, info.Holder(), info.GetIsolate());
if (v8HistoryValue.IsEmpty())
return;
v8::Local<v8::Object> v8History = v8HistoryValue.As<v8::Object>();
if (!history->stateChanged()) {
result = V8HiddenValue::getHiddenValue(info.GetIsolate(), v8History, V8HiddenValue::state(info.GetIsolate()));
if (!result.IsEmpty()) {
v8SetReturnValue(info, cacheState(info.Holder(), result, info.GetIsolate()));
return;
}
}
result = event->serializedState()->deserialize(info.GetIsolate());
V8HiddenValue::setHiddenValue(info.GetIsolate(), v8History, V8HiddenValue::state(info.GetIsolate()), result);
} else {
result = event->serializedState()->deserialize(info.GetIsolate());
}
v8SetReturnValue(info, cacheState(info.Holder(), result, info.GetIsolate()));
}
static void TestTypedefsConstructorAttributeSetterCallback(v8::Local<v8::Name>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
{
TRACE_EVENT_SET_SAMPLING_STATE("blink", "DOMSetter");
do {
v8::Local<v8::Value> data = info.Data();
ASSERT(data->IsExternal());
V8PerContextData* perContextData = V8PerContextData::from(info.Holder()->CreationContext());
if (!perContextData)
break;
const WrapperTypeInfo* wrapperTypeInfo = WrapperTypeInfo::unwrap(data);
if (!wrapperTypeInfo)
break;
TestTypedefsForceSetAttributeOnThis(v8String(info.GetIsolate(), wrapperTypeInfo->interfaceName), v8Value, info);
} while (false); // do ... while (false) just for use of break
TRACE_EVENT_SET_SAMPLING_STATE("v8", "V8Execution");
}
static void namedPropertyGetter(v8::Local<v8::Name> name, const v8::PropertyCallbackInfo<v8::Value>& info)
{
if (!name->IsString())
return;
auto nameString = name.As<v8::String>();
TestInterface2* impl = V8TestInterface2::toImpl(info.Holder());
AtomicString propertyName = toCoreAtomicString(nameString);
v8::String::Utf8Value namedProperty(nameString);
ExceptionState exceptionState(ExceptionState::GetterContext, *namedProperty, "TestInterface2", info.Holder(), info.GetIsolate());
TestInterfaceEmpty* result = impl->namedItem(propertyName, exceptionState);
if (exceptionState.throwIfNeeded())
return;
if (!result)
return;
v8SetReturnValueFast(info, result, impl);
}
void JsVlcPlayer::setJsCallback( v8::Local<v8::String> property,
v8::Local<v8::Value> value,
const v8::PropertyCallbackInfo<void>& info,
Callbacks_e callback )
{
using namespace v8;
Isolate* isolate = Isolate::GetCurrent();
HandleScope scope( isolate );
JsVlcPlayer* jsPlayer = ObjectWrap::Unwrap<JsVlcPlayer>( info.Holder() );
Local<Function> callbackFunc = Local<Function>::Cast( value );
if( !callbackFunc.IsEmpty() )
jsPlayer->_jsCallbacks[callback].Reset( isolate, callbackFunc );
}
void V8File::lastModifiedDateAttributeGetterCustom(const v8::PropertyCallbackInfo<v8::Value>& info)
{
// The auto-generated getters return null when the method in the underlying
// implementation returns NaN. The File API says we should return the
// current time when the last modification time is unknown.
// Section 7.2 of the File API spec. http://dev.w3.org/2006/webapi/FileAPI/
File* file = V8File::toNative(info.Holder());
double lastModified = file->lastModifiedDate();
if (!isValidFileTime(lastModified))
lastModified = currentTimeMS();
// lastModifiedDate returns a Date instance.
// http://www.w3.org/TR/FileAPI/#file-attrs
v8SetReturnValue(info, v8::Date::New(info.GetIsolate(), lastModified));
}
void V8CSSStyleDeclaration::namedPropertySetterCustom(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<v8::Value>& info)
{
CSSStyleDeclaration* impl = V8CSSStyleDeclaration::toNative(info.Holder());
CSSPropertyInfo* propInfo = cssPropertyInfo(name);
if (!propInfo)
return;
TOSTRING_VOID(V8StringResource<TreatNullAsNullString>, propertyValue, value);
ExceptionState exceptionState(ExceptionState::SetterContext, getPropertyName(static_cast<CSSPropertyID>(propInfo->propID)), "CSSStyleDeclaration", info.Holder(), info.GetIsolate());
impl->setPropertyInternal(static_cast<CSSPropertyID>(propInfo->propID), propertyValue, false, exceptionState);
if (exceptionState.throwIfNeeded())
return;
v8SetReturnValue(info, value);
}
void V8CSSStyleDeclaration::namedPropertySetterCustom(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<v8::Value>& info)
{
CSSStyleDeclaration* imp = V8CSSStyleDeclaration::toNative(info.Holder());
CSSPropertyInfo* propInfo = cssPropertyInfo(name);
if (!propInfo)
return;
countCssPropertyInfoUsage(info.GetIsolate(), *propInfo);
V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<WithNullCheck>, propertyValue, value);
ExceptionState exceptionState(ExceptionState::SetterContext, getPropertyName(static_cast<CSSPropertyID>(propInfo->propID)), "CSSStyleDeclaration", info.Holder(), info.GetIsolate());
imp->setPropertyInternal(static_cast<CSSPropertyID>(propInfo->propID), propertyValue, false, exceptionState);
if (exceptionState.throwIfNeeded())
return;
v8SetReturnValue(info, value);
}
static void indexedPropertySetter(uint32_t index, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<v8::Value>& info)
{
TestInterface2* impl = V8TestInterface2::toImpl(info.Holder());
TestInterfaceEmpty* propertyValue = V8TestInterfaceEmpty::toImplWithTypeCheck(info.GetIsolate(), v8Value);
ExceptionState exceptionState(ExceptionState::IndexedSetterContext, "TestInterface2", info.Holder(), info.GetIsolate());
if (!propertyValue) {
exceptionState.throwTypeError("The provided value is not of type 'TestInterfaceEmpty'.");
exceptionState.throwIfNeeded();
return;
}
bool result = impl->setItem(index, propertyValue, exceptionState);
if (exceptionState.throwIfNeeded())
return;
if (!result)
return;
v8SetReturnValue(info, v8Value);
}
void V8Document::locationAttrSetterCustom(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info)
{
Document* document = V8Document::toNative(info.Holder());
if (!document->frame())
return;
DOMWindow* active = activeDOMWindow();
if (!active)
return;
DOMWindow* first = firstDOMWindow();
if (!first)
return;
DOMWindow* window = document->domWindow();
if (Location* location = window->location())
location->setHref(active, first, toWebCoreString(value));
}
void V8Clipboard::typesAttrGetterCustom(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info)
{
Clipboard* clipboard = V8Clipboard::toNative(info.Holder());
ListHashSet<String> types = clipboard->types();
if (types.isEmpty()) {
v8SetReturnValueNull(info);
return;
}
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(v8::Integer::New(index, info.GetIsolate()), v8String(*it, info.GetIsolate()));
v8SetReturnValue(info, result);
}
static void namedPropertySetter(const AtomicString& name, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<v8::Value>& info) {
const CString& nameInUtf8 = name.utf8();
ExceptionState exceptionState(info.GetIsolate(), ExceptionState::SetterContext, "TestInterface2", nameInUtf8.data());
TestInterface2* impl = V8TestInterface2::toImpl(info.Holder());
TestInterfaceEmpty* propertyValue = V8TestInterfaceEmpty::toImplWithTypeCheck(info.GetIsolate(), v8Value);
if (!propertyValue && !isUndefinedOrNull(v8Value)) {
exceptionState.throwTypeError("The provided value is not of type 'TestInterfaceEmpty'.");
return;
}
bool result = impl->setNamedItem(name, propertyValue, exceptionState);
if (exceptionState.hadException())
return;
if (!result)
return;
v8SetReturnValue(info, v8Value);
}
void V8HTMLMediaElement::controllerAttributeSetterCustom(v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info)
{
MediaController* controller = 0;
if (!value->IsNull()) {
if (!V8MediaController::HasInstance(value, info.GetIsolate(), worldType(info.GetIsolate()))) {
throwTypeError("Value is not of type MediaController", info.GetIsolate());
return;
}
controller = V8MediaController::toNative(value->ToObject());
}
// 4.8.10.11.2 Media controllers: controller attribute.
// On setting, it must first remove the element's mediagroup attribute, if any,
HTMLMediaElement* imp = V8HTMLMediaElement::toNative(info.Holder());
imp->setMediaGroup(String());
// and then set the current media controller to the given value.
imp->setController(controller);
}
void JsVlcPlayer::getJsCallback( v8::Local<v8::String> property,
const v8::PropertyCallbackInfo<v8::Value>& info,
Callbacks_e callback )
{
using namespace v8;
JsVlcPlayer* jsPlayer = ObjectWrap::Unwrap<JsVlcPlayer>( info.Holder() );
if( jsPlayer->_jsCallbacks[callback].IsEmpty() )
return;
Isolate* isolate = Isolate::GetCurrent();
HandleScope scope( isolate );
Local<Function> callbackFunc =
Local<Function>::New( isolate, jsPlayer->_jsCallbacks[callback] );
info.GetReturnValue().Set( callbackFunc );
}
void V8HTMLOptionsCollection::lengthAttrSetterCustom(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info)
{
HTMLOptionsCollection* imp = V8HTMLOptionsCollection::toNative(info.Holder());
double v = value->NumberValue();
unsigned newLength = 0;
ExceptionCode ec = 0;
if (!std::isnan(v) && !std::isinf(v)) {
if (v < 0.0)
ec = INDEX_SIZE_ERR;
else if (v > static_cast<double>(UINT_MAX))
newLength = UINT_MAX;
else
newLength = static_cast<unsigned>(v);
}
if (!ec)
imp->setLength(newLength, ec);
setDOMException(ec, info.GetIsolate());
}
