HTMLSlotElement.cpp [plain text]
#include "config.h"
#include "HTMLSlotElement.h"
#include "Event.h"
#include "EventNames.h"
#include "HTMLNames.h"
#include "MutationObserver.h"
#include "ShadowRoot.h"
namespace WebCore {
using namespace HTMLNames;
Ref<HTMLSlotElement> HTMLSlotElement::create(const QualifiedName& tagName, Document& document)
{
return adoptRef(*new HTMLSlotElement(tagName, document));
}
HTMLSlotElement::HTMLSlotElement(const QualifiedName& tagName, Document& document)
: HTMLElement(tagName, document)
{
ASSERT(hasTagName(slotTag));
}
HTMLSlotElement::InsertionNotificationRequest HTMLSlotElement::insertedInto(ContainerNode& insertionPoint)
{
auto insertionResult = HTMLElement::insertedInto(insertionPoint);
ASSERT_UNUSED(insertionResult, insertionResult == InsertionDone);
if (insertionPoint.isInShadowTree() && isInShadowTree() && &insertionPoint.treeScope() == &treeScope()) {
if (auto shadowRoot = containingShadowRoot())
shadowRoot->addSlotElementByName(attributeWithoutSynchronization(nameAttr), *this);
}
return InsertionDone;
}
void HTMLSlotElement::removedFrom(ContainerNode& insertionPoint)
{
if (insertionPoint.isInShadowTree() && isInShadowTree() && &treeScope() == &document()) {
auto* oldShadowRoot = insertionPoint.containingShadowRoot();
ASSERT(oldShadowRoot);
oldShadowRoot->removeSlotElementByName(attributeWithoutSynchronization(nameAttr), *this);
}
HTMLElement::removedFrom(insertionPoint);
}
void HTMLSlotElement::attributeChanged(const QualifiedName& name, const AtomicString& oldValue, const AtomicString& newValue, AttributeModificationReason reason)
{
HTMLElement::attributeChanged(name, oldValue, newValue, reason);
if (isInShadowTree() && name == nameAttr) {
if (auto* shadowRoot = containingShadowRoot()) {
shadowRoot->removeSlotElementByName(oldValue, *this);
shadowRoot->addSlotElementByName(newValue, *this);
}
}
}
const Vector<Node*>* HTMLSlotElement::assignedNodes() const
{
auto* shadowRoot = containingShadowRoot();
if (!shadowRoot)
return nullptr;
return shadowRoot->assignedNodesForSlot(*this);
}
static void flattenAssignedNodes(Vector<Node*>& nodes, const Vector<Node*>& assignedNodes)
{
for (Node* node : assignedNodes) {
if (is<HTMLSlotElement>(*node)) {
if (auto* innerAssignedNodes = downcast<HTMLSlotElement>(*node).assignedNodes())
flattenAssignedNodes(nodes, *innerAssignedNodes);
continue;
}
nodes.append(node);
}
}
Vector<Node*> HTMLSlotElement::assignedNodes(const AssignedNodesOptions& options) const
{
auto* assignedNodes = this->assignedNodes();
if (!assignedNodes)
return { };
if (!options.flatten)
return *assignedNodes;
Vector<Node*> nodes;
flattenAssignedNodes(nodes, *assignedNodes);
return nodes;
}
void HTMLSlotElement::enqueueSlotChangeEvent()
{
if (m_inSignalSlotList)
return;
m_inSignalSlotList = true;
MutationObserver::enqueueSlotChangeEvent(*this);
}
void HTMLSlotElement::dispatchSlotChangeEvent()
{
m_inSignalSlotList = false;
bool bubbles = false;
bool cancelable = false;
Ref<Event> event = Event::create(eventNames().slotchangeEvent, bubbles, cancelable);
event->setTarget(this);
dispatchEvent(event);
}
}