static void useCounterCallback(v8::Isolate* isolate, v8::Isolate::UseCounterFeature feature)
{
switch (feature) {
case v8::Isolate::kUseAsm:
UseCounter::count(callingExecutionContext(isolate), UseCounter::UseAsm);
break;
case v8::Isolate::kBreakIterator:
UseCounter::count(callingExecutionContext(isolate), UseCounter::BreakIterator);
break;
default:
// This can happen if V8 has added counters that this version of Blink
// does not know about. It's harmless.
break;
}
}
void V8EventTarget::removeEventListenerMethodPrologueCustom(const v8::FunctionCallbackInfo<v8::Value>& info, EventTarget*)
{
if (info.Length() < 2) {
UseCounter::countIfNotPrivateScript(info.GetIsolate(), callingExecutionContext(info.GetIsolate()),
info.Length() == 0 ? UseCounter::RemoveEventListenerNoArguments : UseCounter::RemoveEventListenerOneArgument);
}
}
void V8TestInterfaceConstructor::constructorCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
{
TRACE_EVENT_SCOPED_SAMPLING_STATE("blink", "DOMConstructor");
UseCounter::countIfNotPrivateScript(info.GetIsolate(), callingExecutionContext(info.GetIsolate()), UseCounter::TestFeature);
if (!info.IsConstructCall()) {
V8ThrowException::throwTypeError(info.GetIsolate(), ExceptionMessages::constructorNotCallableAsFunction("TestInterfaceConstructor"));
return;
}
if (ConstructorMode::current(info.GetIsolate()) == ConstructorMode::WrapExistingObject) {
v8SetReturnValue(info, info.Holder());
return;
}
TestInterfaceConstructorV8Internal::constructor(info);
}
AtomicString V8CustomXPathNSResolver::lookupNamespaceURI(const String& prefix)
{
v8::Handle<v8::Function> lookupNamespaceURIFunc;
v8::Handle<v8::String> lookupNamespaceURIName = v8AtomicString(m_isolate, "lookupNamespaceURI");
// Check if the resolver has a function property named lookupNamespaceURI.
if (m_resolver->Has(lookupNamespaceURIName)) {
v8::Handle<v8::Value> lookupNamespaceURI = m_resolver->Get(lookupNamespaceURIName);
if (lookupNamespaceURI->IsFunction())
lookupNamespaceURIFunc = v8::Handle<v8::Function>::Cast(lookupNamespaceURI);
}
if (lookupNamespaceURIFunc.IsEmpty() && !m_resolver->IsFunction()) {
LocalFrame* frame = callingDOMWindow(m_isolate)->frame();
if (frame && frame->host())
frame->host()->console().addMessage(JSMessageSource, ErrorMessageLevel, "XPathNSResolver does not have a lookupNamespaceURI method.");
return nullAtom;
}
// Catch exceptions from calling the namespace resolver.
v8::TryCatch tryCatch;
tryCatch.SetVerbose(true); // Print exceptions to console.
const int argc = 1;
v8::Handle<v8::Value> argv[argc] = { v8String(m_isolate, prefix) };
v8::Handle<v8::Function> function = lookupNamespaceURIFunc.IsEmpty() ? v8::Handle<v8::Function>::Cast(m_resolver) : lookupNamespaceURIFunc;
v8::Handle<v8::Value> retval = ScriptController::callFunction(callingExecutionContext(m_isolate), function, m_resolver, argc, argv, m_isolate);
// Eat exceptions from namespace resolver and return an empty string. This will most likely cause NamespaceError.
if (tryCatch.HasCaught())
return nullAtom;
V8TRYCATCH_FOR_V8STRINGRESOURCE_RETURN(V8StringResource<WithNullCheck>, returnString, retval, nullAtom);
return returnString;
}
unsigned CSSStyleSheet::insertRule(const String& rule, ExceptionState& exceptionState)
{
UseCounter::countDeprecation(callingExecutionContext(V8PerIsolateData::mainThreadIsolate()), UseCounter::CSSStyleSheetInsertRuleOptionalArg);
return insertRule(rule, 0, exceptionState);
}
void V8Element::animateMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
{
v8::Isolate* isolate = info.GetIsolate();
ExceptionState exceptionState(ExceptionState::ExecutionContext, "animate", "Element", info.Holder(), isolate);
// AnimationPlayer animate(
// (AnimationEffect or sequence<Dictionary>)? effect,
// optional (double or Dictionary) timing);
switch (info.Length()) {
case 1:
// null resolved as to AnimationEffect, as if the member were nullable:
// (AnimationEffect? or sequence<Dictionary>)
// instead of the *union* being nullable:
// (AnimationEffect or sequence<Dictionary>)?
// AnimationPlayer animate(AnimationEffect? effect);
if (info[0]->IsNull()) {
animate1Method(info);
return;
}
// AnimationPlayer animate(AnimationEffect effect);
if (V8AnimationEffect::hasInstance(info[0], isolate)) {
animate1Method(info);
return;
}
// [MeasureAs=ElementAnimateKeyframeListEffectNoTiming]
// AnimationPlayer animate(sequence<Dictionary> effect);
if (info[0]->IsArray()) {
UseCounter::count(callingExecutionContext(isolate), UseCounter::ElementAnimateKeyframeListEffectNoTiming);
animate2Method(info);
return;
}
break;
case 2:
// As above, null resolved to AnimationEffect
// AnimationPlayer animate(AnimationEffect? effect, Dictionary timing);
if (info[0]->IsNull() && info[1]->IsObject()) {
animate4Method(info);
return;
}
// AnimationPlayer animate(AnimationEffect? effect, double timing);
if (info[0]->IsNull()) {
animate3Method(info);
return;
}
// AnimationPlayer animate(AnimationEffect effect, Dictionary timing);
if (V8AnimationEffect::hasInstance(info[0], isolate)
&& info[1]->IsObject()) {
animate4Method(info);
return;
}
// AnimationPlayer animate(AnimationEffect effect, double timing);
if (V8AnimationEffect::hasInstance(info[0], isolate)) {
animate3Method(info);
return;
}
// [MeasureAs=ElementAnimateKeyframeListEffectObjectTiming]
// AnimationPlayer animate(sequence<Dictionary> effect, Dictionary timing);
if (info[0]->IsArray() && info[1]->IsObject()) {
UseCounter::count(callingExecutionContext(isolate), UseCounter::ElementAnimateKeyframeListEffectObjectTiming);
animate6Method(info);
return;
}
// [MeasureAs=ElementAnimateKeyframeListEffectDoubleTiming]
// AnimationPlayer animate(sequence<Dictionary> effect, double timing);
if (info[0]->IsArray()) {
UseCounter::count(callingExecutionContext(isolate), UseCounter::ElementAnimateKeyframeListEffectDoubleTiming);
animate5Method(info);
return;
}
break;
default:
throwArityTypeError(exceptionState, "[1]", info.Length());
return;
break;
}
exceptionState.throwTypeError("No function was found that matched the signature provided.");
exceptionState.throwIfNeeded();
}