void npObjectPropertyEnumerator(const v8::PropertyCallbackInfo<v8::Array>& info, bool namedProperty) { NPObject* npObject = v8ObjectToNPObject(info.Holder()); // Verify that our wrapper wasn't using a NPObject which // has already been deleted. if (!npObject || !_NPN_IsAlive(npObject)) throwError(v8ReferenceError, "NPObject deleted", info.GetIsolate()); if (NP_CLASS_STRUCT_VERSION_HAS_ENUM(npObject->_class) && npObject->_class->enumerate) { uint32_t count; NPIdentifier* identifiers; if (npObject->_class->enumerate(npObject, &identifiers, &count)) { v8::Handle<v8::Array> properties = v8::Array::New(count); for (uint32_t i = 0; i < count; ++i) { IdentifierRep* identifier = static_cast<IdentifierRep*>(identifiers[i]); if (namedProperty) properties->Set(v8::Integer::New(i, info.GetIsolate()), v8::String::NewSymbol(identifier->string())); else properties->Set(v8::Integer::New(i, info.GetIsolate()), v8::Integer::New(identifier->number(), info.GetIsolate())); } v8SetReturnValue(info, properties); return; } } }
void V8Window::openerAttributeSetterCustom( v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info) { v8::Isolate* isolate = info.GetIsolate(); DOMWindow* impl = V8Window::toImpl(info.Holder()); ExceptionState exceptionState(ExceptionState::SetterContext, "opener", "Window", info.Holder(), isolate); if (!BindingSecurity::shouldAllowAccessTo(currentDOMWindow(info.GetIsolate()), impl, exceptionState)) { 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()) { // impl->frame() has to be a non-null LocalFrame. Otherwise, the // same-origin check would have failed. ASSERT(impl->frame()); toLocalFrame(impl->frame())->loader().setOpener(0); } // Delete the accessor from the inner object. info.Holder()->Delete(isolate->GetCurrentContext(), v8AtomicString(isolate, "opener")); // Put property on the inner object. if (info.Holder()->IsObject()) { v8::Maybe<bool> unused = v8::Local<v8::Object>::Cast(info.Holder()) ->Set(isolate->GetCurrentContext(), v8AtomicString(isolate, "opener"), value); ALLOW_UNUSED_LOCAL(unused); } }
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; countCssPropertyInfoUsage(info.GetIsolate(), *propInfo); CSSStyleDeclaration* imp = V8CSSStyleDeclaration::toNative(info.Holder()); RefPtr<CSSValue> cssValue = imp->getPropertyCSSValueInternal(static_cast<CSSPropertyID>(propInfo->propID)); if (cssValue) { v8SetReturnValueStringOrNull(info, cssValue->cssText(), info.GetIsolate()); return; } String result = imp->getPropertyValueInternal(static_cast<CSSPropertyID>(propInfo->propID)); if (result.isNull()) result = ""; // convert null to empty string. v8SetReturnValueString(info, result, info.GetIsolate()); }
void V8CSSStyleDeclaration::namedPropertyGetterCustom(v8::Local<v8::Name> name, const v8::PropertyCallbackInfo<v8::Value>& info) { if (!name->IsString()) return; // First look for API defined attributes on the style declaration object. if (v8CallBoolean(info.Holder()->HasRealNamedCallbackProperty(info.GetIsolate()->GetCurrentContext(), name.As<v8::String>()))) return; // Search the style declaration. CSSPropertyInfo* propInfo = cssPropertyInfo(name.As<v8::String>(), info.GetIsolate()); // Do not handle non-property names. if (!propInfo) return; CSSStyleDeclaration* impl = V8CSSStyleDeclaration::toImpl(info.Holder()); RefPtrWillBeRawPtr<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()); }
void V8CSSStyleDeclaration::namedPropertyEnumeratorCustom(const v8::PropertyCallbackInfo<v8::Array>& info) { typedef Vector<String, numCSSProperties - 1> PreAllocatedPropertyVector; DEFINE_STATIC_LOCAL(PreAllocatedPropertyVector, propertyNames, ()); static unsigned propertyNamesLength = 0; if (propertyNames.isEmpty()) { for (int id = firstCSSProperty; id <= lastCSSProperty; ++id) { CSSPropertyID propertyId = static_cast<CSSPropertyID>(id); if (CSSPropertyMetadata::isEnabledProperty(propertyId)) propertyNames.append(getJSPropertyName(propertyId)); } std::sort(propertyNames.begin(), propertyNames.end(), codePointCompareLessThan); propertyNamesLength = propertyNames.size(); } v8::Handle<v8::Array> properties = v8::Array::New(info.GetIsolate(), propertyNamesLength); for (unsigned i = 0; i < propertyNamesLength; ++i) { String key = propertyNames.at(i); ASSERT(!key.isNull()); properties->Set(v8::Integer::New(info.GetIsolate(), i), v8String(info.GetIsolate(), key)); } v8SetReturnValue(info, properties); }
void V8CustomEvent::detailAttributeGetterCustom(const v8::PropertyCallbackInfo<v8::Value>& info) { CustomEvent* event = V8CustomEvent::toNative(info.Holder()); v8::Handle<v8::Value> result = V8HiddenValue::getHiddenValue(info.GetIsolate(), info.Holder(), V8HiddenValue::detail(info.GetIsolate())); if (!result.IsEmpty()) { v8SetReturnValue(info, result); return; } if (!event->serializedDetail()) { // If we're in an isolated world and the event was created in the main world, // we need to find the 'detail' property on the main world wrapper and clone it. v8::Local<v8::Value> mainWorldDetail = V8HiddenValue::getHiddenValueFromMainWorldWrapper(info.GetIsolate(), event, V8HiddenValue::detail(info.GetIsolate())); if (!mainWorldDetail.IsEmpty()) event->setSerializedDetail(SerializedScriptValue::createAndSwallowExceptions(mainWorldDetail, info.GetIsolate())); } if (event->serializedDetail()) { result = event->serializedDetail()->deserialize(); v8SetReturnValue(info, cacheState(info.Holder(), result, info.GetIsolate())); return; } v8SetReturnValue(info, cacheState(info.Holder(), v8::Null(info.GetIsolate()), info.GetIsolate())); }
void V8Window::eventAttributeGetterCustom( const v8::PropertyCallbackInfo<v8::Value>& info) { LocalDOMWindow* impl = toLocalDOMWindow(V8Window::toImpl(info.Holder())); ExceptionState exceptionState(ExceptionState::GetterContext, "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; v8::Local<v8::Value> jsEvent = V8HiddenValue::getHiddenValue( ScriptState::current(info.GetIsolate()), context->Global(), V8HiddenValue::event(info.GetIsolate())); if (jsEvent.IsEmpty()) return; v8SetReturnValue(info, jsEvent); }
void V8Window::openerAttributeSetterCustom(v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info) { LocalDOMWindow* impl = V8Window::toNative(info.Holder()); ExceptionState exceptionState(ExceptionState::SetterContext, "opener", "Window", info.Holder(), info.GetIsolate()); if (!BindingSecurity::shouldAllowAccessToFrame(info.GetIsolate(), impl->frame(), exceptionState)) { exceptionState.throwIfNeeded(); 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()) { // impl->frame() cannot be null, // otherwise, SameOrigin check would have failed. ASSERT(impl->frame()); impl->frame()->loader().setOpener(0); } // Delete the accessor from this object. info.Holder()->Delete(v8AtomicString(info.GetIsolate(), "opener")); // Put property on the front (this) object. if (info.This()->IsObject()) v8::Handle<v8::Object>::Cast(info.This())->Set(v8AtomicString(info.GetIsolate(), "opener"), value); }
static void hrefCallWithAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) { v8::Handle<v8::Object> holder = info.Holder(); TestNode* impl = V8TestNode::toImpl(holder); TOSTRING_VOID(V8StringResource<>, cppValue, v8Value); ExecutionContext* executionContext = currentExecutionContext(info.GetIsolate()); impl->setHrefCallWith(executionContext, callingDOMWindow(info.GetIsolate()), enteredDOMWindow(info.GetIsolate()), cppValue); }
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())); }
void V8Window::eventAttributeSetterCustom(v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info) { LocalFrame* frame = V8Window::toNative(info.Holder())->frame(); ExceptionState exceptionState(ExceptionState::SetterContext, "event", "Window", info.Holder(), info.GetIsolate()); if (!BindingSecurity::shouldAllowAccessToFrame(info.GetIsolate(), frame, exceptionState)) { exceptionState.throwIfNeeded(); return; } V8HiddenValue::setHiddenValue(info.GetIsolate(), info.Holder()->CreationContext()->Global(), V8HiddenValue::event(info.GetIsolate()), value); }
static void namedPropertyEnumerator(const v8::PropertyCallbackInfo<v8::Array>& info) { ExceptionState exceptionState(info.GetIsolate(), ExceptionState::EnumerationContext, "TestSpecialOperations"); TestSpecialOperations* impl = V8TestSpecialOperations::toImpl(info.Holder()); Vector<String> names; impl->namedPropertyEnumerator(names, exceptionState); if (exceptionState.hadException()) return; v8SetReturnValue(info, toV8(names, info.Holder(), info.GetIsolate()).As<v8::Array>()); }
static void namedPropertyEnumerator(const v8::PropertyCallbackInfo<v8::Array>& info) { ExceptionState exceptionState(info.Holder(), info.GetIsolate()); TestInterface* collection = V8TestInterface::toNative(info.Holder()); Vector<String> names; collection->namedPropertyEnumerator(names, exceptionState); if (exceptionState.throwIfNeeded()) return; v8::Handle<v8::Array> v8names = v8::Array::New(info.GetIsolate(), names.size()); for (size_t i = 0; i < names.size(); ++i) v8names->Set(v8::Integer::New(info.GetIsolate(), i), v8String(info.GetIsolate(), names[i])); v8SetReturnValue(info, v8names); }
void V8Window::eventAttributeGetterCustom(const v8::PropertyCallbackInfo<v8::Value>& info) { LocalFrame* frame = V8Window::toNative(info.Holder())->frame(); ExceptionState exceptionState(ExceptionState::GetterContext, "event", "Window", info.Holder(), info.GetIsolate()); if (!BindingSecurity::shouldAllowAccessToFrame(info.GetIsolate(), frame, exceptionState)) { exceptionState.throwIfNeeded(); return; } v8::Handle<v8::Value> jsEvent = V8HiddenValue::getHiddenValue(info.GetIsolate(), info.Holder()->CreationContext()->Global(), V8HiddenValue::event(info.GetIsolate())); if (jsEvent.IsEmpty()) return; v8SetReturnValue(info, jsEvent); }
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 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 var_get(v8::Local<v8::String>, v8::PropertyCallbackInfo<v8::Value> const& info) { v8::Isolate* isolate = info.GetIsolate(); Variable* var = detail::get_external_data<Variable*>(info.Data()); info.GetReturnValue().Set(to_v8(isolate, *var)); }
static void supplementalStr2AttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info) { v8::Handle<v8::Object> holder = info.Holder(); TestInterface* impl = V8TestInterface::toNative(holder); ASSERT(impl); v8SetReturnValueString(info, TestPartialInterface::supplementalStr2(*impl), info.GetIsolate()); }
// We lazy create interfaces like testRunner and internals on first access // inside layout tests since creating the bindings is expensive. Then we store // them in a hidden Map on the window so that later accesses will reuse the same // wrapper. static bool installTestInterfaceIfNeeded(LocalFrame& frame, v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info) { if (!LayoutTestSupport::isRunningLayoutTest()) return false; v8::Isolate* isolate = info.GetIsolate(); v8::Local<v8::Context> context = isolate->GetCurrentContext(); AtomicString propName = toCoreAtomicString(name); v8::Local<v8::Value> interfaces = V8HiddenValue::getHiddenValue(isolate, info.Holder(), V8HiddenValue::testInterfaces(isolate)); if (interfaces.IsEmpty()) { interfaces = v8::Map::New(isolate); V8HiddenValue::setHiddenValue(isolate, info.Holder(), V8HiddenValue::testInterfaces(isolate), interfaces); } v8::Local<v8::Map> interfacesMap = interfaces.As<v8::Map>(); v8::Local<v8::Value> result = v8CallOrCrash(interfacesMap->Get(context, name)); if (!result->IsUndefined()) { v8SetReturnValue(info, result); return true; } v8::Local<v8::Value> interface = frame.loader().client()->createTestInterface(propName); if (!interface.IsEmpty()) { v8CallOrCrash(interfacesMap->Set(context, name, interface)); v8SetReturnValue(info, interface); return true; } return false; }
static void doNotCheckSecurityUnforgeableVoidMethodOriginSafeMethodGetter(const v8::PropertyCallbackInfo<v8::Value>& info) { v8::Isolate* isolate = info.GetIsolate(); static int domTemplateKey; // This address is used for a key to look up the dom template. V8PerIsolateData* data = V8PerIsolateData::from(isolate); v8::Handle<v8::FunctionTemplate> privateTemplate = data->domTemplate(&domTemplateKey, TestInterfaceCheckSecurityV8Internal::doNotCheckSecurityUnforgeableVoidMethodMethodCallback, v8Undefined(), v8::Signature::New(info.GetIsolate(), V8TestInterfaceCheckSecurity::domTemplate(info.GetIsolate())), 0); v8::Handle<v8::Object> holder = V8TestInterfaceCheckSecurity::findInstanceInPrototypeChain(info.This(), isolate); if (holder.IsEmpty()) { // This is only reachable via |object.__proto__.func|, in which case it // has already passed the same origin security check v8SetReturnValue(info, privateTemplate->GetFunction()); return; } TestInterfaceCheckSecurity* impl = V8TestInterfaceCheckSecurity::toNative(holder); if (!BindingSecurity::shouldAllowAccessToFrame(isolate, impl->frame(), DoNotReportSecurityError)) { static int sharedTemplateKey; // This address is used for a key to look up the dom template. v8::Handle<v8::FunctionTemplate> sharedTemplate = data->domTemplate(&sharedTemplateKey, TestInterfaceCheckSecurityV8Internal::doNotCheckSecurityUnforgeableVoidMethodMethodCallback, v8Undefined(), v8::Signature::New(info.GetIsolate(), V8TestInterfaceCheckSecurity::domTemplate(info.GetIsolate())), 0); v8SetReturnValue(info, sharedTemplate->GetFunction()); return; } v8::Local<v8::Value> hiddenValue = v8::Handle<v8::Object>::Cast(info.This())->GetHiddenValue(v8AtomicString(isolate, "doNotCheckSecurityUnforgeableVoidMethod")); if (!hiddenValue.IsEmpty()) { v8SetReturnValue(info, hiddenValue); return; } v8SetReturnValue(info, privateTemplate->GetFunction()); }
static void var_set(v8::Local<v8::String>, v8::Local<v8::Value> value, v8::PropertyCallbackInfo<void> const& info) { v8::Isolate* isolate = info.GetIsolate(); Variable* var = detail::get_external_data<Variable*>(info.Data()); *var = v8pp::from_v8<Variable>(isolate, value); }
static void bAttributeSetter(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info) { RealClass* imp = V8TestInterfaceImplementedAs::toNative(info.Holder()); V8TRYCATCH_VOID(RealClass*, v, V8TestInterfaceImplementedAs::HasInstance(value, info.GetIsolate(), worldType(info.GetIsolate())) ? V8TestInterfaceImplementedAs::toNative(v8::Handle<v8::Object>::Cast(value)) : 0); imp->setB(WTF::getPtr(v)); return; }
void npObjectQueryProperty(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Integer>& info) { NPIdentifier identifier = getStringIdentifier(name); if (npObjectGetProperty(info.Holder(), identifier, name, info.GetIsolate()).IsEmpty()) return; v8SetReturnValueInt(info, 0); }
void V8Window::eventAttributeSetterCustom(v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info) { LocalFrame* frame = V8Window::toNative(info.Holder())->frame(); ExceptionState exceptionState(ExceptionState::SetterContext, "event", "Window", info.Holder(), info.GetIsolate()); if (!BindingSecurity::shouldAllowAccessToFrame(info.GetIsolate(), frame, exceptionState)) { exceptionState.throwIfNeeded(); return; } ASSERT(frame); v8::Local<v8::Context> context = toV8Context(info.GetIsolate(), frame, DOMWrapperWorld::current(info.GetIsolate())); if (context.IsEmpty()) return; V8HiddenValue::setHiddenValue(info.GetIsolate(), context->Global(), V8HiddenValue::event(info.GetIsolate()), value); }
static void Node13AttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info) { v8::Handle<v8::Object> holder = info.Holder(); TestInterface* impl = V8TestInterface::toNative(holder); ASSERT(impl); V8TRYCATCH_VOID(Node*, cppValue, V8Node::toNativeWithTypeCheck(info.GetIsolate(), v8Value)); TestPartialInterface::setNode13(*impl, WTF::getPtr(cppValue)); }
static void indexedPropertySetter(uint32_t index, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<v8::Value>& info) { ExceptionState exceptionState(info.GetIsolate(), ExceptionState::IndexedSetterContext, "TestInterface2"); TestInterface2* impl = V8TestInterface2::toImpl(info.Holder()); TestInterfaceEmpty* propertyValue = V8TestInterfaceEmpty::toImplWithTypeCheck(info.GetIsolate(), v8Value); if (!propertyValue) { exceptionState.throwTypeError("The provided value is not of type 'TestInterfaceEmpty'."); return; } bool result = impl->setItem(index, propertyValue, exceptionState); if (exceptionState.hadException()) return; if (!result) return; v8SetReturnValue(info, v8Value); }
void V8History::stateAttributeGetterCustom(const v8::PropertyCallbackInfo<v8::Value>& info) { History* history = V8History::toNative(info.Holder()); v8::Handle<v8::Value> value = V8HiddenValue::getHiddenValue(info.GetIsolate(), info.Holder(), V8HiddenValue::state(info.GetIsolate())); if (!value.IsEmpty() && !history->stateChanged()) { v8SetReturnValue(info, value); return; } RefPtr<SerializedScriptValue> serialized = history->state(); value = serialized ? serialized->deserialize(info.GetIsolate()) : v8::Handle<v8::Value>(v8::Null(info.GetIsolate())); V8HiddenValue::setHiddenValue(info.GetIsolate(), info.Holder(), V8HiddenValue::state(info.GetIsolate()), value); v8SetReturnValue(info, value); }
static void indexedPropertyGetter(uint32_t index, const v8::PropertyCallbackInfo<v8::Value>& info) { TestSpecialOperationsNotEnumerable* impl = V8TestSpecialOperationsNotEnumerable::toNative(info.Holder()); String result = impl->anonymousIndexedGetter(index); if (result.isNull()) return; v8SetReturnValueString(info, result, info.GetIsolate()); }
static void stringAttrWithGetterExceptionAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info) { TestTypedefs* imp = V8TestTypedefs::toNative(info.Holder()); ExceptionState exceptionState(ExceptionState::GetterContext, "stringAttrWithGetterException", "TestTypedefs", info.Holder(), info.GetIsolate()); String jsValue = imp->stringAttrWithGetterException(exceptionState); if (UNLIKELY(exceptionState.throwIfNeeded())) return; v8SetReturnValueString(info, jsValue, info.GetIsolate()); }
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); }