RenderSVGResourceMasker* MaskImageOperation::getSVGMasker(RenderElement& renderer)
{
if (image())
return nullptr;
// Identify the element referenced by the fragmentId.
CachedSVGDocumentReference* svgDocumentReference = cachedSVGDocumentReference();
Element* elementForMasking = nullptr;
RenderObject* svgResourceForMasking = nullptr;
if (svgDocumentReference && svgDocumentReference->document()) {
SVGDocument* svgDocument = svgDocumentReference->document()->document();
if (svgDocument && svgDocument->rootElement())
elementForMasking = svgDocument->rootElement()->getElementById(fragment());
} else
elementForMasking = renderer.document().getElementById(fragment());
if (elementForMasking)
svgResourceForMasking = elementForMasking->renderer();
// Check if it's the correct type
if (svgResourceForMasking && svgResourceForMasking->isSVGResourceContainer() && downcast<RenderSVGResourceContainer>(svgResourceForMasking)->resourceType() == MaskerResourceType)
return static_cast<RenderSVGResourceMasker*>(svgResourceForMasking);
return nullptr;
}
void RenderLayer::FilterInfo::updateReferenceFilterClients(const FilterOperations& operations)
{
removeReferenceFilterClients();
for (size_t i = 0, size = operations.size(); i < size; ++i) {
FilterOperation* filterOperation = operations.operations()[i].get();
if (filterOperation->getOperationType() != FilterOperation::REFERENCE)
continue;
ReferenceFilterOperation* referenceFilterOperation = static_cast<ReferenceFilterOperation*>(filterOperation);
CachedSVGDocumentReference* documentReference = referenceFilterOperation->cachedSVGDocumentReference();
CachedSVGDocument* 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 repaint on SVG attribute change.
Element* filter = m_layer.renderer().node()->document().getElementById(referenceFilterOperation->fragment());
if (!filter || !filter->renderer() || !filter->renderer()->isSVGResourceFilter())
continue;
filter->renderer()->toRenderSVGResourceContainer()->addClientRenderLayer(&m_layer);
m_internalSVGReferences.append(filter);
}
}
}
PassRefPtr<FilterEffect> FilterEffectRenderer::buildReferenceFilter(RenderObject* renderer, PassRefPtr<FilterEffect> previousEffect, ReferenceFilterOperation* filterOperation)
{
#if ENABLE(SVG)
if (!renderer)
return 0;
Document* document = &renderer->document();
CachedSVGDocumentReference* cachedSVGDocumentReference = filterOperation->cachedSVGDocumentReference();
CachedSVGDocument* cachedSVGDocument = cachedSVGDocumentReference ? cachedSVGDocumentReference->document() : 0;
// If we have an SVG document, this is an external reference. Otherwise
// we look up the referenced node in the current document.
if (cachedSVGDocument)
document = cachedSVGDocument->document();
if (!document)
return 0;
Element* filter = document->getElementById(filterOperation->fragment());
if (!filter) {
// Although we did not find the referenced filter, it might exist later
// in the document
document->accessSVGExtensions()->addPendingResource(filterOperation->fragment(), toElement(renderer->node()));
return 0;
}
RefPtr<FilterEffect> effect;
// FIXME: Figure out what to do with SourceAlpha. Right now, we're
// using the alpha of the original input layer, which is obviously
// wrong. We should probably be extracting the alpha from the
// previousEffect, but this requires some more processing.
// This may need a spec clarification.
RefPtr<SVGFilterBuilder> builder = SVGFilterBuilder::create(previousEffect, SourceAlpha::create(this));
for (SVGElement* svgElement = Traversal<SVGElement>::firstChild(filter); svgElement; svgElement = Traversal<SVGElement>::nextSibling(svgElement)) {
if (!svgElement->isFilterEffect())
continue;
SVGFilterPrimitiveStandardAttributes* effectElement = static_cast<SVGFilterPrimitiveStandardAttributes*>(svgElement);
effect = effectElement->build(builder.get(), this);
if (!effect)
continue;
effectElement->setStandardAttributes(effect.get());
builder->add(effectElement->result(), effect);
m_effects.append(effect);
}
return effect;
#else
UNUSED_PARAM(renderer);
UNUSED_PARAM(previousEffect);
UNUSED_PARAM(filterOperation);
return 0;
#endif
}
PassRefPtr<FilterEffect> FilterEffectRenderer::buildReferenceFilter(RenderElement* renderer, PassRefPtr<FilterEffect> previousEffect, ReferenceFilterOperation* filterOperation)
{
#if ENABLE(SVG)
if (!renderer)
return 0;
Document* document = &renderer->document();
CachedSVGDocumentReference* cachedSVGDocumentReference = filterOperation->cachedSVGDocumentReference();
CachedSVGDocument* cachedSVGDocument = cachedSVGDocumentReference ? cachedSVGDocumentReference->document() : 0;
// If we have an SVG document, this is an external reference. Otherwise
// we look up the referenced node in the current document.
if (cachedSVGDocument)
document = cachedSVGDocument->document();
if (!document)
return 0;
Element* filter = document->getElementById(filterOperation->fragment());
if (!filter) {
// Although we did not find the referenced filter, it might exist later
// in the document
document->accessSVGExtensions()->addPendingResource(filterOperation->fragment(), renderer->element());
return 0;
}
RefPtr<FilterEffect> effect;
// FIXME: Figure out what to do with SourceAlpha. Right now, we're
// using the alpha of the original input layer, which is obviously
// wrong. We should probably be extracting the alpha from the
// previousEffect, but this requires some more processing.
// This may need a spec clarification.
auto builder = std::make_unique<SVGFilterBuilder>(previousEffect, SourceAlpha::create(this));
auto attributesChildren = childrenOfType<SVGFilterPrimitiveStandardAttributes>(*filter);
for (auto it = attributesChildren.begin(), end = attributesChildren.end(); it != end; ++it) {
SVGFilterPrimitiveStandardAttributes* effectElement = &*it;
effect = effectElement->build(builder.get(), this);
if (!effect)
continue;
effectElement->setStandardAttributes(effect.get());
builder->add(effectElement->result(), effect);
m_effects.append(effect);
}
return effect;
#else
UNUSED_PARAM(renderer);
UNUSED_PARAM(previousEffect);
UNUSED_PARAM(filterOperation);
return 0;
#endif
}
PassRefPtr<FilterEffect> FilterEffectRenderer::buildReferenceFilter(Document* document, PassRefPtr<FilterEffect> previousEffect, ReferenceFilterOperation* filterOperation)
{
#if ENABLE(SVG)
CachedSVGDocumentReference* cachedSVGDocumentReference = filterOperation->cachedSVGDocumentReference();
CachedSVGDocument* cachedSVGDocument = cachedSVGDocumentReference ? cachedSVGDocumentReference->document() : 0;
// If we have an SVG document, this is an external reference. Otherwise
// we look up the referenced node in the current document.
if (cachedSVGDocument)
document = cachedSVGDocument->document();
if (!document)
return 0;
Element* filter = document->getElementById(filterOperation->fragment());
if (!filter)
return 0;
RefPtr<FilterEffect> effect;
// FIXME: Figure out what to do with SourceAlpha. Right now, we're
// using the alpha of the original input layer, which is obviously
// wrong. We should probably be extracting the alpha from the
// previousEffect, but this requires some more processing.
// This may need a spec clarification.
RefPtr<SVGFilterBuilder> builder = SVGFilterBuilder::create(previousEffect, SourceAlpha::create(this));
for (Node* node = filter->firstChild(); node; node = node->nextSibling()) {
if (!node->isSVGElement())
continue;
SVGElement* element = static_cast<SVGElement*>(node);
if (!element->isFilterEffect())
continue;
SVGFilterPrimitiveStandardAttributes* effectElement = static_cast<SVGFilterPrimitiveStandardAttributes*>(element);
effect = effectElement->build(builder.get(), this);
if (!effect)
continue;
effectElement->setStandardAttributes(effect.get());
builder->add(effectElement->result(), effect);
m_effects.append(effect);
}
return effect;
#else
UNUSED_PARAM(document);
UNUSED_PARAM(previousEffect);
UNUSED_PARAM(filterOperation);
return 0;
#endif
}
PassRefPtr<FilterEffect> FilterEffectRenderer::buildReferenceFilter(RenderElement* renderer, PassRefPtr<FilterEffect> previousEffect, ReferenceFilterOperation* filterOperation)
{
if (!renderer)
return 0;
Document* document = &renderer->document();
CachedSVGDocumentReference* cachedSVGDocumentReference = filterOperation->cachedSVGDocumentReference();
CachedSVGDocument* cachedSVGDocument = cachedSVGDocumentReference ? cachedSVGDocumentReference->document() : 0;
// If we have an SVG document, this is an external reference. Otherwise
// we look up the referenced node in the current document.
if (cachedSVGDocument)
document = cachedSVGDocument->document();
if (!document)
return 0;
Element* filter = document->getElementById(filterOperation->fragment());
if (!filter) {
// Although we did not find the referenced filter, it might exist later in the document.
// FIXME: This skips anonymous RenderObjects. <https://webkit.org/b/131085>
if (Element* element = renderer->element())
document->accessSVGExtensions()->addPendingResource(filterOperation->fragment(), element);
return 0;
}
RefPtr<FilterEffect> effect;
// FIXME: Figure out what to do with SourceAlpha. Right now, we're
// using the alpha of the original input layer, which is obviously
// wrong. We should probably be extracting the alpha from the
// previousEffect, but this requires some more processing.
// This may need a spec clarification.
auto builder = std::make_unique<SVGFilterBuilder>(previousEffect, SourceAlpha::create(this));
for (auto& effectElement : childrenOfType<SVGFilterPrimitiveStandardAttributes>(*filter)) {
effect = effectElement.build(builder.get(), this);
if (!effect)
continue;
effectElement.setStandardAttributes(effect.get());
builder->add(effectElement.result(), effect);
m_effects.append(effect);
}
return effect;
}
PassRefPtr<FilterEffect> FilterEffectRenderer::buildReferenceFilter(RenderElement* renderer, PassRefPtr<FilterEffect> previousEffect, ReferenceFilterOperation* filterOperation)
{
if (!renderer)
return nullptr;
Document* document = &renderer->document();
CachedSVGDocumentReference* cachedSVGDocumentReference = filterOperation->cachedSVGDocumentReference();
CachedSVGDocument* cachedSVGDocument = cachedSVGDocumentReference ? cachedSVGDocumentReference->document() : 0;
// If we have an SVG document, this is an external reference. Otherwise
// we look up the referenced node in the current document.
if (cachedSVGDocument)
document = cachedSVGDocument->document();
if (!document)
return nullptr;
Element* filter = document->getElementById(filterOperation->fragment());
if (!filter) {
// Although we did not find the referenced filter, it might exist later in the document.
// FIXME: This skips anonymous RenderObjects. <https://webkit.org/b/131085>
if (Element* element = renderer->element())
document->accessSVGExtensions().addPendingResource(filterOperation->fragment(), element);
return nullptr;
}
RefPtr<FilterEffect> effect;
auto builder = std::make_unique<SVGFilterBuilder>(previousEffect);
for (auto& effectElement : childrenOfType<SVGFilterPrimitiveStandardAttributes>(*filter)) {
effect = effectElement.build(builder.get(), *this);
if (!effect)
continue;
effectElement.setStandardAttributes(effect.get());
builder->add(effectElement.result(), effect);
m_effects.append(effect);
}
return effect;
}
PassRefPtr<FilterEffect> FilterEffectRenderer::buildReferenceFilter(RenderObject* renderer, PassRefPtr<FilterEffect> previousEffect, ReferenceFilterOperation* filterOperation)
{
if (!renderer)
return 0;
Document* document = renderer->document();
ASSERT(document);
CachedSVGDocumentReference* cachedSVGDocumentReference = filterOperation->cachedSVGDocumentReference();
CachedDocument* cachedSVGDocument = cachedSVGDocumentReference ? cachedSVGDocumentReference->document() : 0;
// If we have an SVG document, this is an external reference. Otherwise
// we look up the referenced node in the current document.
if (cachedSVGDocument)
document = cachedSVGDocument->document();
if (!document)
return 0;
Element* filter = document->getElementById(filterOperation->fragment());
if (!filter) {
// Although we did not find the referenced filter, it might exist later
// in the document
document->accessSVGExtensions()->addPendingResource(filterOperation->fragment(), toElement(renderer->node()));
return 0;
}
if (!filter->isSVGElement() || !filter->hasTagName(SVGNames::filterTag))
return 0;
SVGFilterElement* filterElement = toSVGFilterElement(toSVGElement(filter));
RefPtr<FilterEffect> effect;
// FIXME: Figure out what to do with SourceAlpha. Right now, we're
// using the alpha of the original input layer, which is obviously
// wrong. We should probably be extracting the alpha from the
// previousEffect, but this requires some more processing.
// This may need a spec clarification.
RefPtr<SVGFilterBuilder> builder = SVGFilterBuilder::create(previousEffect, SourceAlpha::create(this));
for (Node* node = filterElement->firstChild(); node; node = node->nextSibling()) {
if (!node->isSVGElement())
continue;
SVGElement* element = toSVGElement(node);
if (!element->isFilterEffect())
continue;
SVGFilterPrimitiveStandardAttributes* effectElement = static_cast<SVGFilterPrimitiveStandardAttributes*>(element);
effect = effectElement->build(builder.get(), this);
if (!effect)
continue;
effectElement->setStandardAttributes(effect.get());
effect->setEffectBoundaries(SVGLengthContext::resolveRectangle<SVGFilterPrimitiveStandardAttributes>(effectElement, filterElement->primitiveUnits(), sourceImageRect()));
builder->add(effectElement->result(), effect);
m_effects.append(effect);
}
return effect;
}
