void LayerAndroid::addAnimation(PassRefPtr<AndroidAnimation> prpAnim)
{
RefPtr<AndroidAnimation> anim = prpAnim;
pair<String, int> key(anim->name(), anim->type());
removeAnimationsForProperty(anim->type());
m_animations.add(key, anim);
}
void WebIDBCursorImpl::value(WebSerializedScriptValue& serializedScriptValue, WebIDBKey& idbKey) const
{
// Verify we're starting off with blank slates.
ASSERT(serializedScriptValue.isNull());
ASSERT(idbKey.type() == WebIDBKey::InvalidType);
RefPtr<IDBAny> any = m_idbCursorBackend->value();
if (any->type() == IDBAny::SerializedScriptValueType)
serializedScriptValue.assign(any->serializedScriptValue());
else if (any->type() == IDBAny::IDBKeyType)
idbKey.assign(any->idbKey());
else
ASSERT_NOT_REACHED();
}
void InjectedScriptBase::makeEvalCall(ErrorString* errorString, ScriptFunctionCall& function, RefPtr<TypeBuilder::Runtime::RemoteObject>* objectResult, TypeBuilder::OptOutput<bool>* wasThrown)
{
RefPtr<JSONValue> result;
makeCall(function, &result);
if (!result) {
*errorString = "Internal error: result value is empty";
return;
}
if (result->type() == JSONValue::TypeString) {
result->asString(errorString);
ASSERT(errorString->length());
return;
}
RefPtr<JSONObject> resultPair = result->asObject();
if (!resultPair) {
*errorString = "Internal error: result is not an Object";
return;
}
RefPtr<JSONObject> resultObj = resultPair->getObject("result");
bool wasThrownVal = false;
if (!resultObj || !resultPair->getBoolean("wasThrown", &wasThrownVal)) {
*errorString = "Internal error: result is not a pair of value and wasThrown flag";
return;
}
*objectResult = TypeBuilder::Runtime::RemoteObject::runtimeCast(resultObj);
*wasThrown = wasThrownVal;
}
unsigned CSSStyleSheet::insertRule(const String& ruleString, unsigned index, ExceptionCode& ec)
{
ASSERT(m_childRuleCSSOMWrappers.isEmpty() || m_childRuleCSSOMWrappers.size() == m_contents->ruleCount());
ec = 0;
if (index > length()) {
ec = INDEX_SIZE_ERR;
return 0;
}
CSSParser p(m_contents.get().parserContext());
RefPtr<StyleRuleBase> rule = p.parseRule(&m_contents.get(), ruleString);
if (!rule) {
ec = SYNTAX_ERR;
return 0;
}
RuleMutationScope mutationScope(this, RuleInsertion, rule->type() == StyleRuleBase::Keyframes ? static_cast<StyleRuleKeyframes*>(rule.get()) : 0);
bool success = m_contents.get().wrapperInsertRule(rule, index);
if (!success) {
ec = HIERARCHY_REQUEST_ERR;
return 0;
}
if (!m_childRuleCSSOMWrappers.isEmpty())
m_childRuleCSSOMWrappers.insert(index, RefPtr<CSSRule>());
return index;
}
void RenderLayerFilterInfo::updateReferenceFilterClients(const FilterOperations& operations)
{
removeReferenceFilterClients();
for (size_t i = 0; i < operations.size(); ++i) {
RefPtr<FilterOperation> filterOperation = operations.operations().at(i);
if (filterOperation->type() != FilterOperation::REFERENCE)
continue;
ReferenceFilterOperation* referenceFilterOperation = toReferenceFilterOperation(filterOperation.get());
DocumentResourceReference* documentReference = ReferenceFilterBuilder::documentResourceReference(referenceFilterOperation);
DocumentResource* cachedSVGDocument = documentReference ? documentReference->document() : 0;
if (cachedSVGDocument) {
// Reference is external; wait for notifyFinished().
cachedSVGDocument->addClient(this);
m_externalSVGReferences.append(cachedSVGDocument);
} else {
// Reference is internal; add layer as a client so we can trigger
// filter paint invalidation on SVG attribute change.
Element* filter = m_layer->renderer()->node()->document().getElementById(referenceFilterOperation->fragment());
if (!isSVGFilterElement(filter))
continue;
if (filter->renderer())
toRenderSVGResourceContainer(filter->renderer())->addClientRenderLayer(m_layer);
else
toSVGFilterElement(filter)->addClient(m_layer->renderer()->node());
m_internalSVGReferences.append(filter);
}
}
}
RefPtr<WebCore::IDBRequest> IDBObjectStore::get(ScriptExecutionContext* context, const Deprecated::ScriptValue& key, ExceptionCode& ec)
{
LOG(IndexedDB, "IDBObjectStore::get");
if (!context) {
ec = INVALID_STATE_ERR;
return nullptr;
}
if (!m_transaction->isActive()) {
ec = static_cast<ExceptionCode>(IDBExceptionCode::TransactionInactiveError);
return nullptr;
}
if (m_deleted) {
ec = INVALID_STATE_ERR;
return nullptr;
}
DOMRequestState requestState(context);
RefPtr<IDBKey> idbKey = scriptValueToIDBKey(&requestState, key);
if (!idbKey || idbKey->type() == KeyType::Invalid) {
ec = static_cast<ExceptionCode>(IDBExceptionCode::DataError);
return nullptr;
}
Ref<IDBRequest> request = m_transaction->requestGetRecord(*context, *this, idbKey.get());
return WTF::move(request);
}
RefPtr<WebCore::IDBRequest> IDBObjectStore::get(ScriptExecutionContext* context, const Deprecated::ScriptValue& key, ExceptionCodeWithMessage& ec)
{
LOG(IndexedDB, "IDBObjectStore::get");
if (!context) {
ec.code = IDBDatabaseException::InvalidStateError;
return nullptr;
}
if (!m_transaction->isActive()) {
ec.code = IDBDatabaseException::TransactionInactiveError;
ec.message = ASCIILiteral("Failed to execute 'get' on 'IDBObjectStore': The transaction is inactive or finished.");
return nullptr;
}
if (m_deleted) {
ec.code = IDBDatabaseException::InvalidStateError;
return nullptr;
}
DOMRequestState requestState(context);
RefPtr<IDBKey> idbKey = scriptValueToIDBKey(&requestState, key);
if (!idbKey || idbKey->type() == KeyType::Invalid) {
ec.code = IDBDatabaseException::DataError;
ec.message = ASCIILiteral("Failed to execute 'get' on 'IDBObjectStore': The parameter is not a valid key.");
return nullptr;
}
Ref<IDBRequest> request = m_transaction->requestGetRecord(*context, *this, idbKey.get());
return WTF::move(request);
}
bool EventDispatcher::dispatchEvent(PassRefPtr<Event> prpEvent)
{
#ifndef NDEBUG
ASSERT(!m_eventDispatched);
m_eventDispatched = true;
#endif
RefPtr<Event> event = prpEvent;
ChildNodesLazySnapshot::takeChildNodesLazySnapshot();
event->setTarget(eventTargetRespectingTargetRules(m_node.get()));
ASSERT(!NoEventDispatchAssertion::isEventDispatchForbidden());
ASSERT(event->target());
ASSERT(!event->type().isNull()); // JavaScript code can create an event with an empty name, but not null.
ensureEventAncestors(event.get());
WindowEventContext windowEventContext(event.get(), m_node.get(), topEventContext());
InspectorInstrumentationCookie cookie = InspectorInstrumentation::willDispatchEvent(m_node->document(), *event, windowEventContext.window(), m_node.get(), m_ancestors);
void* preDispatchEventHandlerResult;
if (dispatchEventPreProcess(event, preDispatchEventHandlerResult) == ContinueDispatching)
if (dispatchEventAtCapturing(event, windowEventContext) == ContinueDispatching)
if (dispatchEventAtTarget(event) == ContinueDispatching)
dispatchEventAtBubbling(event, windowEventContext);
dispatchEventPostProcess(event, preDispatchEventHandlerResult);
// Ensure that after event dispatch, the event's target object is the
// outermost shadow DOM boundary.
event->setTarget(windowEventContext.target());
event->setCurrentTarget(0);
InspectorInstrumentation::didDispatchEvent(cookie);
return !event->defaultPrevented();
}
void InjectedScript::makeEvalCall(ErrorString* errorString, ScriptFunctionCall& function, RefPtr<InspectorObject>* objectResult, bool* wasThrown)
{
RefPtr<InspectorValue> result;
makeCall(function, &result);
if (!result) {
*errorString = "Internal error: result value is empty";
return;
}
if (result->type() == InspectorValue::TypeString) {
result->asString(errorString);
return;
}
RefPtr<InspectorObject> resultPair = result->asObject();
if (!resultPair) {
*errorString = "Internal error: result is not an Object";
return;
}
RefPtr<InspectorObject> resultObj = resultPair->getObject("result");
bool wasThrownVal = false;
if (!resultObj || !resultPair->getBoolean("wasThrown", &wasThrownVal)) {
*errorString = "Internal error: result is not a pair of value and wasThrown flag";
return;
}
*objectResult = resultObj;
*wasThrown = wasThrownVal;
}
bool IDBRequest::dispatchEvent(PassRefPtr<Event> prpEvent)
{
LOG(IndexedDB, "IDBRequest::dispatchEvent - %s", prpEvent->type().characters8());
RefPtr<Event> event = prpEvent;
if (event->type() != eventNames().blockedEvent)
m_readyState = IDBRequestReadyState::Done;
Vector<RefPtr<EventTarget>> targets;
targets.append(this);
if (m_transaction) {
targets.append(m_transaction);
targets.append(m_transaction->db());
}
bool dontPreventDefault;
{
TransactionActivator activator(m_transaction.get());
dontPreventDefault = IDBEventDispatcher::dispatch(event.get(), targets);
}
m_hasPendingActivity = false;
return dontPreventDefault;
}
static v8::Handle<v8::Array> getJSListenerFunctions(Document* document, const EventListenerInfo& listenerInfo)
{
v8::Local<v8::Array> result = v8::Array::New();
size_t handlersCount = listenerInfo.eventListenerVector.size();
for (size_t i = 0, outputIndex = 0; i < handlersCount; ++i) {
RefPtr<EventListener> listener = listenerInfo.eventListenerVector[i].listener;
if (listener->type() != EventListener::JSEventListenerType) {
ASSERT_NOT_REACHED();
continue;
}
V8AbstractEventListener* v8Listener = static_cast<V8AbstractEventListener*>(listener.get());
v8::Local<v8::Context> context = toV8Context(document, v8Listener->world());
// Hide listeners from other contexts.
if (context != v8::Context::GetCurrent())
continue;
v8::Local<v8::Object> function;
{
// getListenerObject() may cause JS in the event attribute to get compiled, potentially unsuccessfully.
v8::TryCatch block;
function = v8Listener->getListenerObject(document);
if (block.HasCaught())
continue;
}
ASSERT(!function.IsEmpty());
v8::Local<v8::Object> listenerEntry = v8::Object::New();
listenerEntry->Set(v8::String::NewSymbol("listener"), function);
listenerEntry->Set(v8::String::NewSymbol("useCapture"), v8::Boolean::New(listenerInfo.eventListenerVector[i].useCapture));
result->Set(v8::Number::New(outputIndex++), listenerEntry);
}
return result;
}
void InjectedScript::setVariableValue(ErrorString* errorString, v8::Local<v8::Object> callFrames, const String* callFrameIdOpt, const String* functionObjectIdOpt, int scopeNumber, const String& variableName, const String& newValueStr)
{
ScriptFunctionCall function(injectedScriptObject(), "setVariableValue");
if (callFrameIdOpt) {
function.appendArgument(callFrames);
function.appendArgument(*callFrameIdOpt);
} else {
function.appendArgument(false);
function.appendArgument(false);
}
if (functionObjectIdOpt)
function.appendArgument(*functionObjectIdOpt);
else
function.appendArgument(false);
function.appendArgument(scopeNumber);
function.appendArgument(variableName);
function.appendArgument(newValueStr);
RefPtr<JSONValue> resultValue;
makeCall(function, &resultValue);
if (!resultValue) {
*errorString = "Internal error";
return;
}
if (resultValue->type() == JSONValue::TypeString) {
resultValue->asString(errorString);
return;
}
// Normal return.
}
RefPtr<TrackSourceInfo> RealtimeMediaSourceCenterMac::sourceWithUID(const String& UID, RealtimeMediaSource::Type type, MediaConstraints* constraints)
{
RefPtr<RealtimeMediaSource> mediaSource = AVCaptureDeviceManager::singleton().sourceWithUID(UID, type, constraints);
if (!mediaSource)
return nullptr;
return TrackSourceInfo::create(mediaSource->id(), mediaSource->type() == RealtimeMediaSource::Type::Video ? TrackSourceInfo::SourceKind::Video : TrackSourceInfo::SourceKind::Audio, mediaSource->name());
}
void InjectedScriptCanvasModule::callStartCapturingFunction(const String& functionName, ErrorString* errorString, TraceLogId* traceLogId)
{
Deprecated::ScriptFunctionCall function(injectedScriptObject(), functionName, WebCore::functionCallHandlerFromAnyThread);
RefPtr<InspectorValue> resultValue;
makeCall(function, &resultValue);
if (!resultValue || resultValue->type() != InspectorValue::TypeString || !resultValue->asString(traceLogId))
*errorString = "Internal error: " + functionName;
}
void CustomElementRegistry::registerElement(CustomElementConstructorBuilder* constructorBuilder, const AtomicString& userSuppliedName, ExceptionCode& ec)
{
RefPtr<CustomElementRegistry> protect(this);
if (!constructorBuilder->isFeatureAllowed())
return;
AtomicString type = userSuppliedName.lower();
if (!isValidName(type)) {
ec = INVALID_CHARACTER_ERR;
return;
}
if (!constructorBuilder->validateOptions()) {
ec = INVALID_STATE_ERR;
return;
}
QualifiedName tagName = nullQName();
if (!constructorBuilder->findTagName(type, tagName)) {
ec = NAMESPACE_ERR;
return;
}
ASSERT(tagName.namespaceURI() == HTMLNames::xhtmlNamespaceURI || tagName.namespaceURI() == SVGNames::svgNamespaceURI);
if (m_definitions.contains(type)) {
ec = INVALID_STATE_ERR;
return;
}
RefPtr<CustomElementCallback> lifecycleCallbacks = constructorBuilder->createCallback(document());
// Consulting the constructor builder could execute script and
// kill the document.
if (!document()) {
ec = INVALID_STATE_ERR;
return;
}
RefPtr<CustomElementDefinition> definition = CustomElementDefinition::create(type, tagName.localName(), tagName.namespaceURI(), lifecycleCallbacks);
if (!constructorBuilder->createConstructor(document(), definition.get())) {
ec = NOT_SUPPORTED_ERR;
return;
}
m_definitions.add(definition->type(), definition);
// Upgrade elements that were waiting for this definition.
CustomElementUpgradeCandidateMap::ElementSet upgradeCandidates = m_candidates.takeUpgradeCandidatesFor(definition.get());
constructorBuilder->didRegisterDefinition(definition.get(), upgradeCandidates);
for (CustomElementUpgradeCandidateMap::ElementSet::iterator it = upgradeCandidates.begin(); it != upgradeCandidates.end(); ++it) {
(*it)->setNeedsStyleRecalc(); // :unresolved has changed
enqueueReadyCallback(lifecycleCallbacks.get(), *it);
}
}
PassRefPtr<SVGPropertyBase> SVGAnimatedTypeAnimator::resetAnimation(const WillBeHeapVector<RawPtrWillBeMember<SVGElement> >& list)
{
ASSERT(isAnimatingSVGDom());
RefPtr<SVGPropertyBase> animatedValue = m_animatedProperty->createAnimatedValue();
ASSERT(animatedValue->type() == m_type);
setAnimatedValueOnAllTargetProperties(list, m_animatedProperty->attributeName(), animatedValue);
return animatedValue.release();
}
void InjectedScript::getStepInPositions(ErrorString* errorString, v8::Local<v8::Object> callFrames, const String& callFrameId, RefPtr<Array<TypeBuilder::Debugger::Location>>& positions)
{
ScriptFunctionCall function(injectedScriptObject(), "getStepInPositions");
function.appendArgument(callFrames);
function.appendArgument(callFrameId);
RefPtr<JSONValue> resultValue;
makeCall(function, &resultValue);
if (resultValue) {
if (resultValue->type() == JSONValue::TypeString) {
resultValue->asString(errorString);
return;
}
if (resultValue->type() == JSONValue::TypeArray) {
positions = Array<TypeBuilder::Debugger::Location>::runtimeCast(resultValue);
return;
}
}
*errorString = "Internal error";
}
void InjectedScript::restartFrame(ErrorString* errorString, const ScriptValue& callFrames, const String& callFrameId, RefPtr<JSONObject>* result)
{
ScriptFunctionCall function(injectedScriptObject(), "restartFrame");
function.appendArgument(callFrames);
function.appendArgument(callFrameId);
RefPtr<JSONValue> resultValue;
makeCall(function, &resultValue);
if (resultValue) {
if (resultValue->type() == JSONValue::TypeString) {
resultValue->asString(errorString);
return;
}
if (resultValue->type() == JSONValue::TypeObject) {
*result = resultValue->asObject();
return;
}
}
*errorString = "Internal error";
}
InjectedScript InjectedScriptManager::injectedScriptForObjectId(const String& objectId)
{
RefPtr<InspectorValue> parsedObjectId = InspectorValue::parseJSON(objectId);
if (parsedObjectId && parsedObjectId->type() == InspectorValue::TypeObject) {
long injectedScriptId = 0;
bool success = parsedObjectId->asObject()->getNumber("injectedScriptId", &injectedScriptId);
if (success)
return m_idToInjectedScript.get(injectedScriptId);
}
return InjectedScript();
}
PassRefPtr<InspectorArray> InjectedScript::wrapCallFrames(const ScriptValue& callFrames)
{
ASSERT(!hasNoValue());
ScriptFunctionCall function(m_injectedScriptObject, "wrapCallFrames");
function.appendArgument(callFrames);
ScriptValue callFramesValue = function.call();
RefPtr<InspectorValue> result = callFramesValue.toInspectorValue(m_injectedScriptObject.scriptState());
if (result->type() == InspectorValue::TypeArray)
return result->asArray();
return InspectorArray::create();
}
RefPtr<WebCore::IDBRequest> IDBObjectStore::deleteFunction(ScriptExecutionContext* context, const Deprecated::ScriptValue& key, ExceptionCode& ec)
{
DOMRequestState requestState(context);
RefPtr<IDBKey> idbKey = scriptValueToIDBKey(&requestState, key);
if (!idbKey || idbKey->type() == KeyType::Invalid) {
ec = static_cast<ExceptionCode>(IDBExceptionCode::DataError);
return nullptr;
}
return deleteFunction(context, &IDBKeyRange::create(idbKey.get()).get(), ec);
}
RefPtr<RealtimeMediaSourceQt5WebRTC> RealtimeMediaSourceCenterQt5WebRTC::findSource(const String& id, RealtimeMediaSource::Type type)
{
if (!id.isEmpty()) {
auto sourceIterator = m_sourceMap.find(id);
if (sourceIterator != m_sourceMap.end()) {
RefPtr<RealtimeMediaSourceQt5WebRTC> source = sourceIterator->value;
if (source->type() == type)
return source.release();
}
}
return nullptr;
}
PassRefPtr<JSONObject> RemoteObjectIdBase::parseInjectedScriptId(const String& objectId)
{
RefPtr<JSONValue> parsedValue = parseJSON(objectId);
if (!parsedValue || parsedValue->type() != JSONValue::TypeObject)
return nullptr;
RefPtr<JSONObject> parsedObjectId = parsedValue->asObject();
bool success = parsedObjectId->getNumber("injectedScriptId", &m_injectedScriptId);
if (success)
return parsedObjectId.release();
return nullptr;
}
RefPtr<WebCore::IDBRequest> IDBObjectStore::deleteFunction(ScriptExecutionContext* context, JSC::JSValue key, ExceptionCodeWithMessage& ec)
{
DOMRequestState requestState(context);
RefPtr<IDBKey> idbKey = scriptValueToIDBKey(&requestState, key);
if (!idbKey || idbKey->type() == KeyType::Invalid) {
ec.code = IDBDatabaseException::DataError;
ec.message = ASCIILiteral("Failed to execute 'delete' on 'IDBObjectStore': The parameter is not a valid key.");
return nullptr;
}
return deleteFunction(context, &IDBKeyRange::create(idbKey.get()).get(), ec);
}
PassRefPtr<Array<CallFrame> > InjectedScript::wrapCallFrames(const ScriptValue& callFrames)
{
ASSERT(!hasNoValue());
ScriptFunctionCall function(m_injectedScriptObject, "wrapCallFrames");
function.appendArgument(callFrames);
bool hadException = false;
ScriptValue callFramesValue = callFunctionWithEvalEnabled(function, hadException);
ASSERT(!hadException);
RefPtr<InspectorValue> result = callFramesValue.toInspectorValue(m_injectedScriptObject.scriptState());
if (result->type() == InspectorValue::TypeArray)
return Array<CallFrame>::runtimeCast(result);
return Array<CallFrame>::create();
}
void InjectedScript::getCollectionEntries(ErrorString* errorString, const String& objectId, RefPtr<Array<CollectionEntry> >* result)
{
ScriptFunctionCall function(injectedScriptObject(), "getCollectionEntries");
function.appendArgument(objectId);
RefPtr<JSONValue> resultValue;
makeCall(function, &resultValue);
if (!resultValue || resultValue->type() != JSONValue::TypeArray) {
if (!resultValue->asString(errorString))
*errorString = "Internal error";
return;
}
*result = Array<CollectionEntry>::runtimeCast(resultValue);
}
void InjectedScript::getGeneratorObjectDetails(ErrorString* errorString, const String& objectId, RefPtr<GeneratorObjectDetails>* result)
{
ScriptFunctionCall function(injectedScriptObject(), "getGeneratorObjectDetails");
function.appendArgument(objectId);
RefPtr<JSONValue> resultValue;
makeCall(function, &resultValue);
if (!resultValue || resultValue->type() != JSONValue::TypeObject) {
if (!resultValue->asString(errorString))
*errorString = "Internal error";
return;
}
*result = GeneratorObjectDetails::runtimeCast(resultValue);
}
void InjectedScriptCanvasModule::resourceInfo(ErrorString* errorString, const ResourceId& resourceId, RefPtr<ResourceInfo>* result)
{
Deprecated::ScriptFunctionCall function(injectedScriptObject(), "resourceInfo", WebCore::functionCallHandlerFromAnyThread);
function.appendArgument(resourceId);
RefPtr<InspectorValue> resultValue;
makeCall(function, &resultValue);
if (!resultValue || resultValue->type() != InspectorValue::TypeObject) {
if (!resultValue->asString(errorString))
*errorString = "Internal error: resourceInfo";
return;
}
*result = ResourceInfo::runtimeCast(resultValue);
}
void InjectedScript::getFunctionDetails(ErrorString* errorString, const String& functionId, RefPtr<FunctionDetails>* result)
{
ScriptFunctionCall function(m_injectedScriptObject, "getFunctionDetails");
function.appendArgument(functionId);
RefPtr<InspectorValue> resultValue;
makeCall(function, &resultValue);
if (!resultValue || resultValue->type() != InspectorValue::TypeObject) {
if (!resultValue->asString(errorString))
*errorString = "Internal error";
return;
}
*result = FunctionDetails::runtimeCast(resultValue);
}
static void generateIndexKeysForValue(DOMRequestState* requestState, const IDBIndexMetadata& indexMetadata, const ScriptValue& objectValue, IDBObjectStore::IndexKeys* indexKeys)
{
ASSERT(indexKeys);
RefPtr<IDBKey> indexKey = createIDBKeyFromScriptValueAndKeyPath(requestState, objectValue, indexMetadata.keyPath);
if (!indexKey)
return;
if (!indexMetadata.multiEntry || indexKey->type() != IDBKey::ArrayType) {
if (!indexKey->isValid())
return;
indexKeys->append(indexKey);
} else {
ASSERT(indexMetadata.multiEntry);
ASSERT(indexKey->type() == IDBKey::ArrayType);
indexKey = IDBKey::createMultiEntryArray(indexKey->array());
for (size_t i = 0; i < indexKey->array().size(); ++i)
indexKeys->append(indexKey->array()[i]);
}
}
