MutationRecord.cpp [plain text]
#include "config.h"
#include "MutationRecord.h"
#include "CharacterData.h"
#include "StaticNodeList.h"
#include <wtf/StdLibExtras.h>
namespace WebCore {
namespace {
class ChildListRecord : public MutationRecord {
public:
ChildListRecord(ContainerNode& target, PassRefPtr<NodeList> added, PassRefPtr<NodeList> removed, PassRefPtr<Node> previousSibling, PassRefPtr<Node> nextSibling)
: m_target(target)
, m_addedNodes(added)
, m_removedNodes(removed)
, m_previousSibling(previousSibling)
, m_nextSibling(nextSibling)
{
}
private:
virtual const AtomicString& type() override;
virtual Node* target() override { return m_target.ptr(); }
virtual NodeList* addedNodes() override { return m_addedNodes.get(); }
virtual NodeList* removedNodes() override { return m_removedNodes.get(); }
virtual Node* previousSibling() override { return m_previousSibling.get(); }
virtual Node* nextSibling() override { return m_nextSibling.get(); }
Ref<ContainerNode> m_target;
RefPtr<NodeList> m_addedNodes;
RefPtr<NodeList> m_removedNodes;
RefPtr<Node> m_previousSibling;
RefPtr<Node> m_nextSibling;
};
class RecordWithEmptyNodeLists : public MutationRecord {
public:
RecordWithEmptyNodeLists(Node& target, const String& oldValue)
: m_target(target)
, m_oldValue(oldValue)
{
}
private:
virtual Node* target() override { return m_target.ptr(); }
virtual String oldValue() override { return m_oldValue; }
virtual NodeList* addedNodes() override { return lazilyInitializeEmptyNodeList(m_addedNodes); }
virtual NodeList* removedNodes() override { return lazilyInitializeEmptyNodeList(m_removedNodes); }
static NodeList* lazilyInitializeEmptyNodeList(RefPtr<NodeList>& nodeList)
{
if (!nodeList)
nodeList = StaticNodeList::createEmpty();
return nodeList.get();
}
Ref<Node> m_target;
String m_oldValue;
RefPtr<NodeList> m_addedNodes;
RefPtr<NodeList> m_removedNodes;
};
class AttributesRecord : public RecordWithEmptyNodeLists {
public:
AttributesRecord(Element& target, const QualifiedName& name, const AtomicString& oldValue)
: RecordWithEmptyNodeLists(target, oldValue)
, m_attributeName(name.localName())
, m_attributeNamespace(name.namespaceURI())
{
}
private:
virtual const AtomicString& type() override;
virtual const AtomicString& attributeName() override { return m_attributeName; }
virtual const AtomicString& attributeNamespace() override { return m_attributeNamespace; }
AtomicString m_attributeName;
AtomicString m_attributeNamespace;
};
class CharacterDataRecord : public RecordWithEmptyNodeLists {
public:
CharacterDataRecord(CharacterData& target, const String& oldValue)
: RecordWithEmptyNodeLists(target, oldValue)
{
}
private:
virtual const AtomicString& type() override;
};
class MutationRecordWithNullOldValue : public MutationRecord {
public:
MutationRecordWithNullOldValue(PassRefPtr<MutationRecord> record)
: m_record(record)
{
}
private:
virtual const AtomicString& type() override { return m_record->type(); }
virtual Node* target() override { return m_record->target(); }
virtual NodeList* addedNodes() override { return m_record->addedNodes(); }
virtual NodeList* removedNodes() override { return m_record->removedNodes(); }
virtual Node* previousSibling() override { return m_record->previousSibling(); }
virtual Node* nextSibling() override { return m_record->nextSibling(); }
virtual const AtomicString& attributeName() override { return m_record->attributeName(); }
virtual const AtomicString& attributeNamespace() override { return m_record->attributeNamespace(); }
virtual String oldValue() override { return String(); }
RefPtr<MutationRecord> m_record;
};
const AtomicString& ChildListRecord::type()
{
DEPRECATED_DEFINE_STATIC_LOCAL(AtomicString, childList, ("childList", AtomicString::ConstructFromLiteral));
return childList;
}
const AtomicString& AttributesRecord::type()
{
DEPRECATED_DEFINE_STATIC_LOCAL(AtomicString, attributes, ("attributes", AtomicString::ConstructFromLiteral));
return attributes;
}
const AtomicString& CharacterDataRecord::type()
{
DEPRECATED_DEFINE_STATIC_LOCAL(AtomicString, characterData, ("characterData", AtomicString::ConstructFromLiteral));
return characterData;
}
}
PassRefPtr<MutationRecord> MutationRecord::createChildList(ContainerNode& target, PassRefPtr<NodeList> added, PassRefPtr<NodeList> removed, PassRefPtr<Node> previousSibling, PassRefPtr<Node> nextSibling)
{
return adoptRef(static_cast<MutationRecord*>(new ChildListRecord(target, added, removed, previousSibling, nextSibling)));
}
PassRefPtr<MutationRecord> MutationRecord::createAttributes(Element& target, const QualifiedName& name, const AtomicString& oldValue)
{
return adoptRef(static_cast<MutationRecord*>(new AttributesRecord(target, name, oldValue)));
}
PassRefPtr<MutationRecord> MutationRecord::createCharacterData(CharacterData& target, const String& oldValue)
{
return adoptRef(static_cast<MutationRecord*>(new CharacterDataRecord(target, oldValue)));
}
PassRefPtr<MutationRecord> MutationRecord::createWithNullOldValue(PassRefPtr<MutationRecord> record)
{
return adoptRef(static_cast<MutationRecord*>(new MutationRecordWithNullOldValue(record)));
}
MutationRecord::~MutationRecord()
{
}
}