https://bugs.webkit.org/show_bug.cgi?id=87220
Reviewed by Geoffrey Garen.
It's better to use a more specific type; in some cases we even generate
more efficient code if we have a more specific type. Also, we want any
type casts to be as close as possible to the corresponding type checks,
so eliminating these uses of toContainerNode is a plus, also.
* dom/ContainerNodeAlgorithms.h: Changed insertionPoint to be a ContainerNode
instead of a Node. Fixed spelling error "inseretions". Changed
(WebCore::ChildFrameDisconnector::Target::Target): Changed type of frame owner
element to HTMLFrameOwnerElement from Node.
* dom/DocumentType.cpp:
(WebCore::DocumentType::insertedInto):
(WebCore::DocumentType::removedFrom):
* dom/DocumentType.h:
* dom/Element.cpp:
(WebCore::Element::insertedInto):
(WebCore::Element::removedFrom):
* dom/Element.h:
* dom/Node.cpp:
(WebCore::Node::insertedInto):
(WebCore::Node::removedFrom):
* dom/Node.h:
* dom/ProcessingInstruction.cpp:
(WebCore::ProcessingInstruction::insertedInto):
(WebCore::ProcessingInstruction::removedFrom):
* dom/ProcessingInstruction.h:
* dom/ScriptElement.cpp:
(WebCore::ScriptElement::insertedInto):
* dom/ScriptElement.h:
* html/FormAssociatedElement.cpp:
(WebCore::FormAssociatedElement::insertedInto):
(WebCore::FormAssociatedElement::removedFrom):
* html/FormAssociatedElement.h:
* html/HTMLBaseElement.cpp:
(WebCore::HTMLBaseElement::insertedInto):
(WebCore::HTMLBaseElement::removedFrom):
* html/HTMLBaseElement.h:
* html/HTMLBodyElement.cpp:
(WebCore::HTMLBodyElement::insertedInto):
(WebCore::HTMLBodyElement::didNotifyDescendantInsertions):
* html/HTMLBodyElement.h:
* html/HTMLFormControlElement.cpp:
(WebCore::HTMLFormControlElement::insertedInto):
(WebCore::HTMLFormControlElement::removedFrom):
* html/HTMLFormControlElement.h:
* html/HTMLFormElement.cpp:
(WebCore::HTMLFormElement::insertedInto):
(WebCore::HTMLFormElement::didNotifyDescendantInsertions):
(WebCore::HTMLFormElement::removedFrom):
* html/HTMLFormElement.h:
* html/HTMLFrameElementBase.cpp:
(WebCore::HTMLFrameElementBase::insertedInto):
(WebCore::HTMLFrameElementBase::didNotifyDescendantInsertions):
* html/HTMLFrameElementBase.h:
* html/HTMLFrameSetElement.cpp:
(WebCore::HTMLFrameSetElement::insertedInto):
(WebCore::HTMLFrameSetElement::removedFrom):
* html/HTMLFrameSetElement.h:
* html/HTMLIFrameElement.cpp:
(WebCore::HTMLIFrameElement::insertedInto):
(WebCore::HTMLIFrameElement::removedFrom):
* html/HTMLIFrameElement.h:
* html/HTMLImageElement.cpp:
(WebCore::HTMLImageElement::insertedInto):
(WebCore::HTMLImageElement::removedFrom):
* html/HTMLImageElement.h:
* html/HTMLInputElement.cpp:
(WebCore::HTMLInputElement::insertedInto):
(WebCore::HTMLInputElement::removedFrom):
* html/HTMLInputElement.h:
* html/HTMLLinkElement.cpp:
(WebCore::HTMLLinkElement::insertedInto):
(WebCore::HTMLLinkElement::removedFrom):
* html/HTMLLinkElement.h:
* html/HTMLMapElement.cpp:
(WebCore::HTMLMapElement::insertedInto):
(WebCore::HTMLMapElement::removedFrom):
* html/HTMLMapElement.h:
* html/HTMLMediaElement.cpp:
(WebCore::HTMLMediaElement::insertedInto):
(WebCore::HTMLMediaElement::removedFrom):
* html/HTMLMediaElement.h:
* html/HTMLMetaElement.cpp:
(WebCore::HTMLMetaElement::insertedInto):
* html/HTMLMetaElement.h:
* html/HTMLObjectElement.cpp:
(WebCore::HTMLObjectElement::insertedInto):
(WebCore::HTMLObjectElement::removedFrom):
* html/HTMLObjectElement.h:
* html/HTMLOptionElement.cpp:
(WebCore::HTMLOptionElement::insertedInto):
* html/HTMLOptionElement.h:
* html/HTMLQuoteElement.cpp:
(WebCore::HTMLQuoteElement::insertedInto):
* html/HTMLQuoteElement.h:
* html/HTMLScriptElement.cpp:
(WebCore::HTMLScriptElement::insertedInto):
* html/HTMLScriptElement.h:
* html/HTMLSelectElement.cpp:
(WebCore::HTMLSelectElement::insertedInto):
* html/HTMLSelectElement.h:
* html/HTMLSourceElement.cpp:
(WebCore::HTMLSourceElement::insertedInto):
(WebCore::HTMLSourceElement::removedFrom):
* html/HTMLSourceElement.h:
* html/HTMLStyleElement.cpp:
(WebCore::HTMLStyleElement::insertedInto):
(WebCore::HTMLStyleElement::removedFrom):
* html/HTMLStyleElement.h:
* html/HTMLTextFormControlElement.cpp:
(WebCore::HTMLTextFormControlElement::insertedInto):
* html/HTMLTextFormControlElement.h:
* html/HTMLTitleElement.cpp:
(WebCore::HTMLTitleElement::insertedInto):
(WebCore::HTMLTitleElement::removedFrom):
* html/HTMLTitleElement.h:
* html/HTMLTrackElement.cpp:
(WebCore::HTMLTrackElement::insertedInto):
(WebCore::HTMLTrackElement::removedFrom):
* html/HTMLTrackElement.h:
* mathml/MathMLMathElement.cpp:
(WebCore::MathMLMathElement::insertedInto):
* mathml/MathMLMathElement.h:
* svg/SVGElement.cpp:
(WebCore::SVGElement::removedFrom):
* svg/SVGElement.h:
* svg/SVGFEImageElement.cpp:
(WebCore::SVGFEImageElement::insertedInto):
(WebCore::SVGFEImageElement::removedFrom):
* svg/SVGFEImageElement.h:
* svg/SVGFontFaceElement.cpp:
(WebCore::SVGFontFaceElement::insertedInto):
(WebCore::SVGFontFaceElement::removedFrom):
* svg/SVGFontFaceElement.h:
* svg/SVGFontFaceUriElement.cpp:
(WebCore::SVGFontFaceUriElement::insertedInto):
* svg/SVGFontFaceUriElement.h:
* svg/SVGGlyphElement.cpp:
(WebCore::SVGGlyphElement::insertedInto):
(WebCore::SVGGlyphElement::removedFrom):
* svg/SVGGlyphElement.h:
* svg/SVGHKernElement.cpp:
(WebCore::SVGHKernElement::insertedInto):
(WebCore::SVGHKernElement::removedFrom):
* svg/SVGHKernElement.h:
* svg/SVGImageElement.cpp:
(WebCore::SVGImageElement::insertedInto):
* svg/SVGImageElement.h:
* svg/SVGSVGElement.cpp:
(WebCore::SVGSVGElement::insertedInto):
(WebCore::SVGSVGElement::removedFrom):
* svg/SVGSVGElement.h:
* svg/SVGScriptElement.cpp:
(WebCore::SVGScriptElement::insertedInto):
* svg/SVGScriptElement.h:
* svg/SVGStyleElement.cpp:
(WebCore::SVGStyleElement::insertedInto):
(WebCore::SVGStyleElement::removedFrom):
* svg/SVGStyleElement.h:
* svg/SVGStyledElement.cpp:
(WebCore::SVGStyledElement::insertedInto):
(WebCore::SVGStyledElement::removedFrom):
* svg/SVGStyledElement.h:
* svg/SVGTRefElement.cpp:
(WebCore::SVGTRefElement::insertedInto):
(WebCore::SVGTRefElement::removedFrom):
* svg/SVGTRefElement.h:
* svg/SVGTextPathElement.cpp:
(WebCore::SVGTextPathElement::insertedInto):
* svg/SVGTextPathElement.h:
* svg/SVGTitleElement.cpp:
(WebCore::SVGTitleElement::insertedInto):
(WebCore::SVGTitleElement::removedFrom):
* svg/SVGTitleElement.h:
* svg/SVGUseElement.cpp:
(WebCore::SVGUseElement::insertedInto):
(WebCore::SVGUseElement::removedFrom):
* svg/SVGUseElement.h:
* svg/SVGVKernElement.cpp:
(WebCore::SVGVKernElement::insertedInto):
(WebCore::SVGVKernElement::removedFrom):
* svg/SVGVKernElement.h:
* svg/animation/SVGSMILElement.cpp:
(WebCore::SVGSMILElement::insertedInto):
(WebCore::SVGSMILElement::removedFrom):
* svg/animation/SVGSMILElement.h:
Changed arguments of insertedInto and removedFrom to ContainerNode instead of Node.
Did the same with didNotifyDescendantInsertions, while fixing the typo in its name.
* editing/ReplaceSelectionCommand.cpp:
(WebCore::ReplaceSelectionCommand::doApply): Put a typecast toHTMLElement here.
The check for isListElement and isLegacyAppleStyleSpan takes care of the type checking.
(WebCore::ReplaceSelectionCommand::insertAsListItems): Changed this function to take
an HTMLElement instead of a Node, then we can drop use of the toContainerNode function.
* editing/ReplaceSelectionCommand.h:
* editing/TextIterator.cpp: Fixed a typo in a comment.
git-svn-id: https://svn.webkit.org/repository/webkit/trunk@118192
268f45cc-cd09-0410-ab3c-
d52691b4dbfc
+2012-05-23 Darin Adler <darin@apple.com>
+
+ Use ContainerNode instead of Node where possible
+ https://bugs.webkit.org/show_bug.cgi?id=87220
+
+ Reviewed by Geoffrey Garen.
+
+ It's better to use a more specific type; in some cases we even generate
+ more efficient code if we have a more specific type. Also, we want any
+ type casts to be as close as possible to the corresponding type checks,
+ so eliminating these uses of toContainerNode is a plus, also.
+
+ * dom/ContainerNodeAlgorithms.h: Changed insertionPoint to be a ContainerNode
+ instead of a Node. Fixed spelling error "inseretions". Changed
+ (WebCore::ChildFrameDisconnector::Target::Target): Changed type of frame owner
+ element to HTMLFrameOwnerElement from Node.
+
+ * dom/DocumentType.cpp:
+ (WebCore::DocumentType::insertedInto):
+ (WebCore::DocumentType::removedFrom):
+ * dom/DocumentType.h:
+ * dom/Element.cpp:
+ (WebCore::Element::insertedInto):
+ (WebCore::Element::removedFrom):
+ * dom/Element.h:
+ * dom/Node.cpp:
+ (WebCore::Node::insertedInto):
+ (WebCore::Node::removedFrom):
+ * dom/Node.h:
+ * dom/ProcessingInstruction.cpp:
+ (WebCore::ProcessingInstruction::insertedInto):
+ (WebCore::ProcessingInstruction::removedFrom):
+ * dom/ProcessingInstruction.h:
+ * dom/ScriptElement.cpp:
+ (WebCore::ScriptElement::insertedInto):
+ * dom/ScriptElement.h:
+ * html/FormAssociatedElement.cpp:
+ (WebCore::FormAssociatedElement::insertedInto):
+ (WebCore::FormAssociatedElement::removedFrom):
+ * html/FormAssociatedElement.h:
+ * html/HTMLBaseElement.cpp:
+ (WebCore::HTMLBaseElement::insertedInto):
+ (WebCore::HTMLBaseElement::removedFrom):
+ * html/HTMLBaseElement.h:
+ * html/HTMLBodyElement.cpp:
+ (WebCore::HTMLBodyElement::insertedInto):
+ (WebCore::HTMLBodyElement::didNotifyDescendantInsertions):
+ * html/HTMLBodyElement.h:
+ * html/HTMLFormControlElement.cpp:
+ (WebCore::HTMLFormControlElement::insertedInto):
+ (WebCore::HTMLFormControlElement::removedFrom):
+ * html/HTMLFormControlElement.h:
+ * html/HTMLFormElement.cpp:
+ (WebCore::HTMLFormElement::insertedInto):
+ (WebCore::HTMLFormElement::didNotifyDescendantInsertions):
+ (WebCore::HTMLFormElement::removedFrom):
+ * html/HTMLFormElement.h:
+ * html/HTMLFrameElementBase.cpp:
+ (WebCore::HTMLFrameElementBase::insertedInto):
+ (WebCore::HTMLFrameElementBase::didNotifyDescendantInsertions):
+ * html/HTMLFrameElementBase.h:
+ * html/HTMLFrameSetElement.cpp:
+ (WebCore::HTMLFrameSetElement::insertedInto):
+ (WebCore::HTMLFrameSetElement::removedFrom):
+ * html/HTMLFrameSetElement.h:
+ * html/HTMLIFrameElement.cpp:
+ (WebCore::HTMLIFrameElement::insertedInto):
+ (WebCore::HTMLIFrameElement::removedFrom):
+ * html/HTMLIFrameElement.h:
+ * html/HTMLImageElement.cpp:
+ (WebCore::HTMLImageElement::insertedInto):
+ (WebCore::HTMLImageElement::removedFrom):
+ * html/HTMLImageElement.h:
+ * html/HTMLInputElement.cpp:
+ (WebCore::HTMLInputElement::insertedInto):
+ (WebCore::HTMLInputElement::removedFrom):
+ * html/HTMLInputElement.h:
+ * html/HTMLLinkElement.cpp:
+ (WebCore::HTMLLinkElement::insertedInto):
+ (WebCore::HTMLLinkElement::removedFrom):
+ * html/HTMLLinkElement.h:
+ * html/HTMLMapElement.cpp:
+ (WebCore::HTMLMapElement::insertedInto):
+ (WebCore::HTMLMapElement::removedFrom):
+ * html/HTMLMapElement.h:
+ * html/HTMLMediaElement.cpp:
+ (WebCore::HTMLMediaElement::insertedInto):
+ (WebCore::HTMLMediaElement::removedFrom):
+ * html/HTMLMediaElement.h:
+ * html/HTMLMetaElement.cpp:
+ (WebCore::HTMLMetaElement::insertedInto):
+ * html/HTMLMetaElement.h:
+ * html/HTMLObjectElement.cpp:
+ (WebCore::HTMLObjectElement::insertedInto):
+ (WebCore::HTMLObjectElement::removedFrom):
+ * html/HTMLObjectElement.h:
+ * html/HTMLOptionElement.cpp:
+ (WebCore::HTMLOptionElement::insertedInto):
+ * html/HTMLOptionElement.h:
+ * html/HTMLQuoteElement.cpp:
+ (WebCore::HTMLQuoteElement::insertedInto):
+ * html/HTMLQuoteElement.h:
+ * html/HTMLScriptElement.cpp:
+ (WebCore::HTMLScriptElement::insertedInto):
+ * html/HTMLScriptElement.h:
+ * html/HTMLSelectElement.cpp:
+ (WebCore::HTMLSelectElement::insertedInto):
+ * html/HTMLSelectElement.h:
+ * html/HTMLSourceElement.cpp:
+ (WebCore::HTMLSourceElement::insertedInto):
+ (WebCore::HTMLSourceElement::removedFrom):
+ * html/HTMLSourceElement.h:
+ * html/HTMLStyleElement.cpp:
+ (WebCore::HTMLStyleElement::insertedInto):
+ (WebCore::HTMLStyleElement::removedFrom):
+ * html/HTMLStyleElement.h:
+ * html/HTMLTextFormControlElement.cpp:
+ (WebCore::HTMLTextFormControlElement::insertedInto):
+ * html/HTMLTextFormControlElement.h:
+ * html/HTMLTitleElement.cpp:
+ (WebCore::HTMLTitleElement::insertedInto):
+ (WebCore::HTMLTitleElement::removedFrom):
+ * html/HTMLTitleElement.h:
+ * html/HTMLTrackElement.cpp:
+ (WebCore::HTMLTrackElement::insertedInto):
+ (WebCore::HTMLTrackElement::removedFrom):
+ * html/HTMLTrackElement.h:
+ * mathml/MathMLMathElement.cpp:
+ (WebCore::MathMLMathElement::insertedInto):
+ * mathml/MathMLMathElement.h:
+ * svg/SVGElement.cpp:
+ (WebCore::SVGElement::removedFrom):
+ * svg/SVGElement.h:
+ * svg/SVGFEImageElement.cpp:
+ (WebCore::SVGFEImageElement::insertedInto):
+ (WebCore::SVGFEImageElement::removedFrom):
+ * svg/SVGFEImageElement.h:
+ * svg/SVGFontFaceElement.cpp:
+ (WebCore::SVGFontFaceElement::insertedInto):
+ (WebCore::SVGFontFaceElement::removedFrom):
+ * svg/SVGFontFaceElement.h:
+ * svg/SVGFontFaceUriElement.cpp:
+ (WebCore::SVGFontFaceUriElement::insertedInto):
+ * svg/SVGFontFaceUriElement.h:
+ * svg/SVGGlyphElement.cpp:
+ (WebCore::SVGGlyphElement::insertedInto):
+ (WebCore::SVGGlyphElement::removedFrom):
+ * svg/SVGGlyphElement.h:
+ * svg/SVGHKernElement.cpp:
+ (WebCore::SVGHKernElement::insertedInto):
+ (WebCore::SVGHKernElement::removedFrom):
+ * svg/SVGHKernElement.h:
+ * svg/SVGImageElement.cpp:
+ (WebCore::SVGImageElement::insertedInto):
+ * svg/SVGImageElement.h:
+ * svg/SVGSVGElement.cpp:
+ (WebCore::SVGSVGElement::insertedInto):
+ (WebCore::SVGSVGElement::removedFrom):
+ * svg/SVGSVGElement.h:
+ * svg/SVGScriptElement.cpp:
+ (WebCore::SVGScriptElement::insertedInto):
+ * svg/SVGScriptElement.h:
+ * svg/SVGStyleElement.cpp:
+ (WebCore::SVGStyleElement::insertedInto):
+ (WebCore::SVGStyleElement::removedFrom):
+ * svg/SVGStyleElement.h:
+ * svg/SVGStyledElement.cpp:
+ (WebCore::SVGStyledElement::insertedInto):
+ (WebCore::SVGStyledElement::removedFrom):
+ * svg/SVGStyledElement.h:
+ * svg/SVGTRefElement.cpp:
+ (WebCore::SVGTRefElement::insertedInto):
+ (WebCore::SVGTRefElement::removedFrom):
+ * svg/SVGTRefElement.h:
+ * svg/SVGTextPathElement.cpp:
+ (WebCore::SVGTextPathElement::insertedInto):
+ * svg/SVGTextPathElement.h:
+ * svg/SVGTitleElement.cpp:
+ (WebCore::SVGTitleElement::insertedInto):
+ (WebCore::SVGTitleElement::removedFrom):
+ * svg/SVGTitleElement.h:
+ * svg/SVGUseElement.cpp:
+ (WebCore::SVGUseElement::insertedInto):
+ (WebCore::SVGUseElement::removedFrom):
+ * svg/SVGUseElement.h:
+ * svg/SVGVKernElement.cpp:
+ (WebCore::SVGVKernElement::insertedInto):
+ (WebCore::SVGVKernElement::removedFrom):
+ * svg/SVGVKernElement.h:
+ * svg/animation/SVGSMILElement.cpp:
+ (WebCore::SVGSMILElement::insertedInto):
+ (WebCore::SVGSMILElement::removedFrom):
+ * svg/animation/SVGSMILElement.h:
+ Changed arguments of insertedInto and removedFrom to ContainerNode instead of Node.
+ Did the same with didNotifyDescendantInsertions, while fixing the typo in its name.
+
+ * editing/ReplaceSelectionCommand.cpp:
+ (WebCore::ReplaceSelectionCommand::doApply): Put a typecast toHTMLElement here.
+ The check for isListElement and isLegacyAppleStyleSpan takes care of the type checking.
+ (WebCore::ReplaceSelectionCommand::insertAsListItems): Changed this function to take
+ an HTMLElement instead of a Node, then we can drop use of the toContainerNode function.
+ * editing/ReplaceSelectionCommand.h:
+
+ * editing/TextIterator.cpp: Fixed a typo in a comment.
+
2012-05-23 Alexei Filippov <alexeif@chromium.org>
Web Inspector: filter out debugging stuff from the heap class view
#define ContainerNodeAlgorithms_h
#include "Document.h"
+#include "HTMLFrameOwnerElement.h"
#include "InspectorInstrumentation.h"
#include <wtf/Assertions.h>
namespace WebCore {
-class Node;
-
class ChildNodeInsertionNotifier {
public:
- explicit ChildNodeInsertionNotifier(Node* insertionPoint)
+ explicit ChildNodeInsertionNotifier(ContainerNode* insertionPoint)
: m_insertionPoint(insertionPoint)
- { }
+ {
+ }
void notifyInsertedIntoDocument(Node*);
void notify(Node*);
void notifyNodeInsertedIntoDocument(Node*);
void notifyNodeInsertedIntoTree(ContainerNode*);
- Node* m_insertionPoint;
+ ContainerNode* m_insertionPoint;
};
class ChildNodeRemovalNotifier {
public:
- explicit ChildNodeRemovalNotifier(Node* insertionPoint)
+ explicit ChildNodeRemovalNotifier(ContainerNode* insertionPoint)
: m_insertionPoint(insertionPoint)
- { }
+ {
+ }
void notify(Node*);
void notifyNodeRemovedFromDocument(Node*);
void notifyNodeRemovedFromTree(ContainerNode*);
- Node* m_insertionPoint;
+ ContainerNode* m_insertionPoint;
};
namespace Private {
template<class GenericNode, class GenericNodeContainer>
- void addChildNodesToDeletionQueue(GenericNode*& head, GenericNode*& tail, GenericNodeContainer* container);
+ void addChildNodesToDeletionQueue(GenericNode*& head, GenericNode*& tail, GenericNodeContainer*);
-};
+}
// Helper functions for TreeShared-derived classes, which have a 'Node' style interface
// This applies to 'ContainerNode' and 'SVGElementInstance'
if (node->isContainerNode())
notifyDescendantInsertedIntoDocument(toContainerNode(node));
- if (request == Node::InsertionShouldCallDidNotifyDescendantInseretions)
- node->didNotifyDescendantInseretions(m_insertionPoint);
+ if (request == Node::InsertionShouldCallDidNotifyDescendantInsertions)
+ node->didNotifyDescendantInsertions(m_insertionPoint);
}
inline void ChildNodeInsertionNotifier::notifyNodeInsertedIntoTree(ContainerNode* node)
Node::InsertionNotificationRequest request = node->insertedInto(m_insertionPoint);
notifyDescendantInsertedIntoTree(node);
- if (request == Node::InsertionShouldCallDidNotifyDescendantInseretions)
- node->didNotifyDescendantInseretions(m_insertionPoint);
+ if (request == Node::InsertionShouldCallDidNotifyDescendantInsertions)
+ node->didNotifyDescendantInsertions(m_insertionPoint);
allowEventDispatch();
}
class Target {
public:
- Target(Node* element)
+ Target(HTMLFrameOwnerElement* element)
: m_owner(element)
, m_ownerParent(element->parentNode())
- { }
+ {
+ }
bool isValid() const { return m_owner->parentNode() == m_ownerParent; }
void disconnect();
private:
- RefPtr<Node> m_owner;
- Node* m_ownerParent;
+ RefPtr<HTMLFrameOwnerElement> m_owner;
+ ContainerNode* m_ownerParent;
};
Vector<Target, 10> m_list;
continue;
Element* element = toElement(node);
if (element->hasCustomCallbacks() && element->isFrameOwnerElement())
- m_list.append(node);
+ m_list.append(toFrameOwnerElement(element));
if (ElementShadow* shadow = element->shadow())
collectDescendant(shadow);
}
Target& target = m_list[i];
if (target.isValid())
target.disconnect();
- };
+ }
}
} // namespace WebCore
return create(document(), m_name, m_publicId, m_systemId);
}
-Node::InsertionNotificationRequest DocumentType::insertedInto(Node* insertionPoint)
+Node::InsertionNotificationRequest DocumentType::insertedInto(ContainerNode* insertionPoint)
{
Node::insertedInto(insertionPoint);
if (!insertionPoint->inDocument())
return InsertionDone;
}
-void DocumentType::removedFrom(Node* insertionPoint)
+void DocumentType::removedFrom(ContainerNode* insertionPoint)
{
if (insertionPoint->inDocument() && document() && document()->doctype() == this)
document()->setDocType(0);
virtual NodeType nodeType() const;
virtual PassRefPtr<Node> cloneNode(bool deep);
- virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
- virtual void removedFrom(Node*) OVERRIDE;
+ virtual InsertionNotificationRequest insertedInto(ContainerNode*) OVERRIDE;
+ virtual void removedFrom(ContainerNode*) OVERRIDE;
OwnPtr<NamedNodeMap> m_entities;
OwnPtr<NamedNodeMap> m_notations;
{
}
-Node::InsertionNotificationRequest Element::insertedInto(Node* insertionPoint)
+Node::InsertionNotificationRequest Element::insertedInto(ContainerNode* insertionPoint)
{
// need to do superclass processing first so inDocument() is true
// by the time we reach updateId
return InsertionDone;
}
-void Element::removedFrom(Node* insertionPoint)
+void Element::removedFrom(ContainerNode* insertionPoint)
{
#if ENABLE(FULLSCREEN_API)
if (containsFullScreenElement())
{
}
- virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
- virtual void removedFrom(Node*) OVERRIDE;
+ virtual InsertionNotificationRequest insertedInto(ContainerNode*) OVERRIDE;
+ virtual void removedFrom(ContainerNode*) OVERRIDE;
virtual void childrenChanged(bool changedByParser = false, Node* beforeChange = 0, Node* afterChange = 0, int childCountDelta = 0);
virtual bool willRecalcStyle(StyleChange);
return document();
}
-Node::InsertionNotificationRequest Node::insertedInto(Node* insertionPoint)
+Node::InsertionNotificationRequest Node::insertedInto(ContainerNode* insertionPoint)
{
ASSERT(insertionPoint->inDocument() || isContainerNode());
if (insertionPoint->inDocument())
return InsertionDone;
}
-void Node::removedFrom(Node* insertionPoint)
+void Node::removedFrom(ContainerNode* insertionPoint)
{
ASSERT(insertionPoint->inDocument() || isContainerNode());
if (insertionPoint->inDocument())
// This is similar to the DOMNodeInsertedIntoDocument DOM event, but does not require the overhead of event
// dispatching.
//
- // Webkit notifies this callback regardless if the subtree of the node is a document tree or a floating subtree.
+ // WebKit notifies this callback regardless if the subtree of the node is a document tree or a floating subtree.
// Implementation can determine the type of subtree by seeing insertionPoint->inDocument().
// For a performance reason, notifications are delivered only to ContainerNode subclasses if the insertionPoint is out of document.
//
- // There are another callback named didNotifyDescendantInseretions(), which is called after all the descendant is notified.
- // Only a few subclasses actually need this. To utilize this, the node should return InsertionShouldCallDidNotifyDescendantInseretions
+ // There are another callback named didNotifyDescendantInsertions(), which is called after all the descendant is notified.
+ // Only a few subclasses actually need this. To utilize this, the node should return InsertionShouldCallDidNotifyDescendantInsertions
// from insrtedInto().
//
enum InsertionNotificationRequest {
InsertionDone,
- InsertionShouldCallDidNotifyDescendantInseretions
+ InsertionShouldCallDidNotifyDescendantInsertions
};
- virtual InsertionNotificationRequest insertedInto(Node* insertionPoint);
- virtual void didNotifyDescendantInseretions(Node*) { }
+ virtual InsertionNotificationRequest insertedInto(ContainerNode* insertionPoint);
+ virtual void didNotifyDescendantInsertions(ContainerNode*) { }
// Notifies the node that it is no longer part of the tree.
//
// This is a dual of insertedInto(), and is similar to the DOMNodeRemovedFromDocument DOM event, but does not require the overhead of event
// dispatching, and is called _after_ the node is removed from the tree.
//
- virtual void removedFrom(Node* insertionPoint);
+ virtual void removedFrom(ContainerNode* insertionPoint);
#ifndef NDEBUG
virtual void formatForDebugger(char* buffer, unsigned length) const;
addSubresourceURL(urls, sheet()->baseURL());
}
-Node::InsertionNotificationRequest ProcessingInstruction::insertedInto(Node* insertionPoint)
+Node::InsertionNotificationRequest ProcessingInstruction::insertedInto(ContainerNode* insertionPoint)
{
Node::insertedInto(insertionPoint);
if (!insertionPoint->inDocument())
return InsertionDone;
}
-void ProcessingInstruction::removedFrom(Node* insertionPoint)
+void ProcessingInstruction::removedFrom(ContainerNode* insertionPoint)
{
Node::removedFrom(insertionPoint);
if (!insertionPoint->inDocument())
virtual bool offsetInCharacters() const;
virtual int maxCharacterOffset() const;
- virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
- virtual void removedFrom(Node*) OVERRIDE;
+ virtual InsertionNotificationRequest insertedInto(ContainerNode*) OVERRIDE;
+ virtual void removedFrom(ContainerNode*) OVERRIDE;
void checkStyleSheet();
virtual void setCSSStyleSheet(const String& href, const KURL& baseURL, const String& charset, const CachedCSSStyleSheet*);
stopLoadRequest();
}
-void ScriptElement::insertedInto(Node* insertionPoint)
+void ScriptElement::insertedInto(ContainerNode* insertionPoint)
{
if (insertionPoint->inDocument() && !m_parserInserted)
prepareScript(); // FIXME: Provide a real starting line number here.
namespace WebCore {
class CachedScript;
+class ContainerNode;
class Element;
-class Node;
class ScriptElement;
class ScriptSourceCode;
bool forceAsync() const { return m_forceAsync; }
// Helper functions used by our parent classes.
- void insertedInto(Node*);
+ void insertedInto(ContainerNode*);
void childrenChanged();
void handleSourceAttribute(const String& sourceUrl);
void handleAsyncAttribute();
Node* blockStart = enclosingBlock(insertionPos.deprecatedNode());
if ((isListElement(refNode.get()) || (isLegacyAppleStyleSpan(refNode.get()) && isListElement(refNode->firstChild())))
&& blockStart && blockStart->renderer()->isListItem())
- refNode = insertAsListItems(refNode, blockStart, insertionPos, insertedNodes);
+ refNode = insertAsListItems(toHTMLElement(refNode.get()), blockStart, insertionPos, insertedNodes);
else {
insertNodeAt(refNode, insertionPos);
insertedNodes.respondToNodeInsertion(refNode.get());
// If the user is inserting a list into an existing list, instead of nesting the list,
// we put the list items into the existing list.
-Node* ReplaceSelectionCommand::insertAsListItems(PassRefPtr<Node> prpListElement, Node* insertionBlock, const Position& insertPos, InsertedNodes& insertedNodes)
+Node* ReplaceSelectionCommand::insertAsListItems(PassRefPtr<HTMLElement> prpListElement, Node* insertionBlock, const Position& insertPos, InsertedNodes& insertedNodes)
{
- RefPtr<Node> listElement = prpListElement;
+ RefPtr<HTMLElement> listElement = prpListElement;
while (listElement->hasChildNodes() && isListElement(listElement->firstChild()) && listElement->childNodeCount() == 1)
- listElement = listElement->firstChild();
+ listElement = toHTMLElement(listElement->firstChild());
bool isStart = isStartOfParagraph(insertPos);
bool isEnd = isEndOfParagraph(insertPos);
while (RefPtr<Node> listItem = listElement->firstChild()) {
ExceptionCode ec = 0;
- toContainerNode(listElement.get())->removeChild(listItem.get(), ec);
+ listElement->removeChild(listItem.get(), ec);
ASSERT(!ec);
if (isStart || isMiddle) {
insertNodeBefore(listItem, lastNode);
namespace WebCore {
class DocumentFragment;
-class EditingStyle;
-class Node;
class ReplacementFragment;
-class StylePropertySet;
class ReplaceSelectionCommand : public CompositeEditCommand {
public:
RefPtr<Node> m_lastNodeInserted;
};
- Node* insertAsListItems(PassRefPtr<Node>, Node* insertionNode, const Position&, InsertedNodes&);
+ Node* insertAsListItems(PassRefPtr<HTMLElement> listElement, Node* insertionNode, const Position&, InsertedNodes&);
void updateNodesInserted(Node*);
bool shouldRemoveEndBR(Node*, const VisiblePosition&);
// ICU's search ignores the distinction between small kana letters and ones
// that are not small, and also characters that differ only in the voicing
-// marks when considering only primary collation strength diffrences.
+// marks when considering only primary collation strength differences.
// This is not helpful for end users, since these differences make words
// distinct, so for our purposes we need these to be considered.
// The Unicode folks do not think the collation algorithm should be
oldDocument->unregisterFormElementWithFormAttribute(this);
}
-void FormAssociatedElement::insertedInto(Node* insertionPoint)
+void FormAssociatedElement::insertedInto(ContainerNode* insertionPoint)
{
resetFormOwner();
if (!insertionPoint->inDocument())
element->document()->registerFormElementWithFormAttribute(this);
}
-void FormAssociatedElement::removedFrom(Node* insertionPoint)
+void FormAssociatedElement::removedFrom(ContainerNode* insertionPoint)
{
HTMLElement* element = toHTMLElement(this);
if (insertionPoint->inDocument() && element->fastHasAttribute(formAttr))
protected:
FormAssociatedElement();
- void insertedInto(Node*);
- void removedFrom(Node*);
+ void insertedInto(ContainerNode*);
+ void removedFrom(ContainerNode*);
void didMoveToNewDocument(Document* oldDocument);
void setForm(HTMLFormElement*);
HTMLElement::parseAttribute(attribute);
}
-Node::InsertionNotificationRequest HTMLBaseElement::insertedInto(Node* insertionPoint)
+Node::InsertionNotificationRequest HTMLBaseElement::insertedInto(ContainerNode* insertionPoint)
{
HTMLElement::insertedInto(insertionPoint);
if (insertionPoint->inDocument())
return InsertionDone;
}
-void HTMLBaseElement::removedFrom(Node* insertionPoint)
+void HTMLBaseElement::removedFrom(ContainerNode* insertionPoint)
{
HTMLElement::removedFrom(insertionPoint);
if (insertionPoint->inDocument())
virtual String target() const;
virtual bool isURLAttribute(const Attribute&) const OVERRIDE;
virtual void parseAttribute(const Attribute&) OVERRIDE;
- virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
- virtual void removedFrom(Node*) OVERRIDE;
+ virtual InsertionNotificationRequest insertedInto(ContainerNode*) OVERRIDE;
+ virtual void removedFrom(ContainerNode*) OVERRIDE;
};
} // namespace
HTMLElement::parseAttribute(attribute);
}
-Node::InsertionNotificationRequest HTMLBodyElement::insertedInto(Node* insertionPoint)
+Node::InsertionNotificationRequest HTMLBodyElement::insertedInto(ContainerNode* insertionPoint)
{
HTMLElement::insertedInto(insertionPoint);
if (insertionPoint->inDocument())
- return InsertionShouldCallDidNotifyDescendantInseretions;
+ return InsertionShouldCallDidNotifyDescendantInsertions;
return InsertionDone;
}
-void HTMLBodyElement::didNotifyDescendantInseretions(Node* insertionPoint)
+void HTMLBodyElement::didNotifyDescendantInsertions(ContainerNode* insertionPoint)
{
ASSERT_UNUSED(insertionPoint, insertionPoint->inDocument());
ASSERT(document());
virtual bool isPresentationAttribute(const QualifiedName&) const OVERRIDE;
virtual void collectStyleForAttribute(const Attribute&, StylePropertySet*) OVERRIDE;
- virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
- virtual void didNotifyDescendantInseretions(Node*) OVERRIDE;
+ virtual InsertionNotificationRequest insertedInto(ContainerNode*) OVERRIDE;
+ virtual void didNotifyDescendantInsertions(ContainerNode*) OVERRIDE;
virtual bool isURLAttribute(const Attribute&) const OVERRIDE;
HTMLElement::didMoveToNewDocument(oldDocument);
}
-Node::InsertionNotificationRequest HTMLFormControlElement::insertedInto(Node* insertionPoint)
+Node::InsertionNotificationRequest HTMLFormControlElement::insertedInto(ContainerNode* insertionPoint)
{
m_dataListAncestorState = Unknown;
setNeedsWillValidateCheck();
return InsertionDone;
}
-void HTMLFormControlElement::removedFrom(Node* insertionPoint)
+void HTMLFormControlElement::removedFrom(ContainerNode* insertionPoint)
{
m_fieldSetAncestorValid = false;
m_dataListAncestorState = Unknown;
virtual void requiredAttributeChanged();
virtual void disabledAttributeChanged();
virtual void attach();
- virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
- virtual void removedFrom(Node*) OVERRIDE;
+ virtual InsertionNotificationRequest insertedInto(ContainerNode*) OVERRIDE;
+ virtual void removedFrom(ContainerNode*) OVERRIDE;
virtual void didMoveToNewDocument(Document* oldDocument) OVERRIDE;
virtual bool supportsFocus() const;
return formIsTablePart;
}
-Node::InsertionNotificationRequest HTMLFormElement::insertedInto(Node* insertionPoint)
+Node::InsertionNotificationRequest HTMLFormElement::insertedInto(ContainerNode* insertionPoint)
{
HTMLElement::insertedInto(insertionPoint);
if (insertionPoint->inDocument())
- return InsertionShouldCallDidNotifyDescendantInseretions;
+ return InsertionShouldCallDidNotifyDescendantInsertions;
return InsertionDone;
}
-void HTMLFormElement::didNotifyDescendantInseretions(Node* insertionPoint)
+void HTMLFormElement::didNotifyDescendantInsertions(ContainerNode* insertionPoint)
{
ASSERT(insertionPoint->inDocument());
- HTMLElement::didNotifyDescendantInseretions(insertionPoint);
+ HTMLElement::didNotifyDescendantInsertions(insertionPoint);
if (hasID())
document()->resetFormElementsOwner();
}
return root;
}
-void HTMLFormElement::removedFrom(Node* insertionPoint)
+void HTMLFormElement::removedFrom(ContainerNode* insertionPoint)
{
Node* root = findRoot(this);
Vector<FormAssociatedElement*> associatedElements(m_associatedElements);
HTMLFormElement(const QualifiedName&, Document*);
virtual bool rendererIsNeeded(const NodeRenderingContext&);
- virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
- virtual void didNotifyDescendantInseretions(Node*) OVERRIDE;
- virtual void removedFrom(Node*) OVERRIDE;
+ virtual InsertionNotificationRequest insertedInto(ContainerNode*) OVERRIDE;
+ virtual void didNotifyDescendantInsertions(ContainerNode*) OVERRIDE;
+ virtual void removedFrom(ContainerNode*) OVERRIDE;
virtual void handleLocalEvents(Event*);
openURL();
}
-Node::InsertionNotificationRequest HTMLFrameElementBase::insertedInto(Node* insertionPoint)
+Node::InsertionNotificationRequest HTMLFrameElementBase::insertedInto(ContainerNode* insertionPoint)
{
HTMLFrameOwnerElement::insertedInto(insertionPoint);
if (insertionPoint->inDocument())
- return InsertionShouldCallDidNotifyDescendantInseretions;
+ return InsertionShouldCallDidNotifyDescendantInsertions;
return InsertionDone;
}
-void HTMLFrameElementBase::didNotifyDescendantInseretions(Node* insertionPoint)
+void HTMLFrameElementBase::didNotifyDescendantInsertions(ContainerNode* insertionPoint)
{
ASSERT_UNUSED(insertionPoint, insertionPoint->inDocument());
bool isURLAllowed() const;
virtual void parseAttribute(const Attribute&) OVERRIDE;
- virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
- virtual void didNotifyDescendantInseretions(Node*) OVERRIDE;
+ virtual InsertionNotificationRequest insertedInto(ContainerNode*) OVERRIDE;
+ virtual void didNotifyDescendantInsertions(ContainerNode*) OVERRIDE;
virtual void attach();
private:
return true;
}
-Node::InsertionNotificationRequest HTMLFrameSetElement::insertedInto(Node* insertionPoint)
+Node::InsertionNotificationRequest HTMLFrameSetElement::insertedInto(ContainerNode* insertionPoint)
{
HTMLElement::insertedInto(insertionPoint);
if (insertionPoint->inDocument()) {
return InsertionDone;
}
-void HTMLFrameSetElement::removedFrom(Node* insertionPoint)
+void HTMLFrameSetElement::removedFrom(ContainerNode* insertionPoint)
{
HTMLElement::removedFrom(insertionPoint);
if (insertionPoint->inDocument()) {
virtual bool willRecalcStyle(StyleChange);
- virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
- virtual void removedFrom(Node*) OVERRIDE;
+ virtual InsertionNotificationRequest insertedInto(ContainerNode*) OVERRIDE;
+ virtual void removedFrom(ContainerNode*) OVERRIDE;
OwnArrayPtr<Length> m_rowLengths;
OwnArrayPtr<Length> m_colLengths;
return new (arena) RenderIFrame(this);
}
-Node::InsertionNotificationRequest HTMLIFrameElement::insertedInto(Node* insertionPoint)
+Node::InsertionNotificationRequest HTMLIFrameElement::insertedInto(ContainerNode* insertionPoint)
{
InsertionNotificationRequest result = HTMLFrameElementBase::insertedInto(insertionPoint);
if (insertionPoint->inDocument() && document()->isHTMLDocument())
return result;
}
-void HTMLIFrameElement::removedFrom(Node* insertionPoint)
+void HTMLIFrameElement::removedFrom(ContainerNode* insertionPoint)
{
HTMLFrameElementBase::removedFrom(insertionPoint);
if (insertionPoint->inDocument() && document()->isHTMLDocument())
virtual bool isPresentationAttribute(const QualifiedName&) const OVERRIDE;
virtual void collectStyleForAttribute(const Attribute&, StylePropertySet*) OVERRIDE;
- virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
- virtual void removedFrom(Node*) OVERRIDE;
+ virtual InsertionNotificationRequest insertedInto(ContainerNode*) OVERRIDE;
+ virtual void removedFrom(ContainerNode*) OVERRIDE;
virtual bool rendererIsNeeded(const NodeRenderingContext&);
virtual RenderObject* createRenderer(RenderArena*, RenderStyle*);
}
}
-Node::InsertionNotificationRequest HTMLImageElement::insertedInto(Node* insertionPoint)
+Node::InsertionNotificationRequest HTMLImageElement::insertedInto(ContainerNode* insertionPoint)
{
if (!m_form) {
// m_form can be non-null if it was set in constructor.
return HTMLElement::insertedInto(insertionPoint);
}
-void HTMLImageElement::removedFrom(Node* insertionPoint)
+void HTMLImageElement::removedFrom(ContainerNode* insertionPoint)
{
if (m_form)
m_form->removeImgElement(this);
virtual void addSubresourceAttributeURLs(ListHashSet<KURL>&) const;
- virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
- virtual void removedFrom(Node*) OVERRIDE;
+ virtual InsertionNotificationRequest insertedInto(ContainerNode*) OVERRIDE;
+ virtual void removedFrom(ContainerNode*) OVERRIDE;
virtual bool shouldRegisterAsNamedItem() const OVERRIDE { return true; }
virtual bool shouldRegisterAsExtraNamedItem() const OVERRIDE { return true; }
addToRadioButtonGroup();
}
-Node::InsertionNotificationRequest HTMLInputElement::insertedInto(Node* insertionPoint)
+Node::InsertionNotificationRequest HTMLInputElement::insertedInto(ContainerNode* insertionPoint)
{
HTMLTextFormControlElement::insertedInto(insertionPoint);
if (!insertionPoint->inDocument())
return InsertionDone;
}
-void HTMLInputElement::removedFrom(Node* insertionPoint)
+void HTMLInputElement::removedFrom(ContainerNode* insertionPoint)
{
if (insertionPoint->inDocument())
removeFromRadioButtonGroup();
virtual void willChangeForm() OVERRIDE;
virtual void didChangeForm() OVERRIDE;
- virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
- virtual void removedFrom(Node*) OVERRIDE;
+ virtual InsertionNotificationRequest insertedInto(ContainerNode*) OVERRIDE;
+ virtual void removedFrom(ContainerNode*) OVERRIDE;
virtual void didMoveToNewDocument(Document* oldDocument) OVERRIDE;
virtual bool isKeyboardFocusable(KeyboardEvent*) const;
m_sheet = 0;
}
-Node::InsertionNotificationRequest HTMLLinkElement::insertedInto(Node* insertionPoint)
+Node::InsertionNotificationRequest HTMLLinkElement::insertedInto(ContainerNode* insertionPoint)
{
HTMLElement::insertedInto(insertionPoint);
if (!insertionPoint->inDocument())
return InsertionDone;
}
-void HTMLLinkElement::removedFrom(Node* insertionPoint)
+void HTMLLinkElement::removedFrom(ContainerNode* insertionPoint)
{
HTMLElement::removedFrom(insertionPoint);
if (!insertionPoint->inDocument())
static void processCallback(Node*);
void clearSheet();
- virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
- virtual void removedFrom(Node*) OVERRIDE;
+ virtual InsertionNotificationRequest insertedInto(ContainerNode*) OVERRIDE;
+ virtual void removedFrom(ContainerNode*) OVERRIDE;
// from CachedResourceClient
virtual void setCSSStyleSheet(const String& href, const KURL& baseURL, const String& charset, const CachedCSSStyleSheet* sheet);
return ensureCachedHTMLCollection(MapAreas);
}
-Node::InsertionNotificationRequest HTMLMapElement::insertedInto(Node* insertionPoint)
+Node::InsertionNotificationRequest HTMLMapElement::insertedInto(ContainerNode* insertionPoint)
{
if (insertionPoint->inDocument())
treeScope()->addImageMap(this);
return HTMLElement::insertedInto(insertionPoint);
}
-void HTMLMapElement::removedFrom(Node* insertionPoint)
+void HTMLMapElement::removedFrom(ContainerNode* insertionPoint)
{
if (insertionPoint->inDocument())
treeScope()->removeImageMap(this);
virtual void parseAttribute(const Attribute&) OVERRIDE;
- virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
- virtual void removedFrom(Node*) OVERRIDE;
+ virtual InsertionNotificationRequest insertedInto(ContainerNode*) OVERRIDE;
+ virtual void removedFrom(ContainerNode*) OVERRIDE;
AtomicString m_name;
};
return childContext.isOnUpperEncapsulationBoundary() && HTMLElement::childShouldCreateRenderer(childContext);
}
-Node::InsertionNotificationRequest HTMLMediaElement::insertedInto(Node* insertionPoint)
+Node::InsertionNotificationRequest HTMLMediaElement::insertedInto(ContainerNode* insertionPoint)
{
LOG(Media, "HTMLMediaElement::insertedInto");
HTMLElement::insertedInto(insertionPoint);
return InsertionDone;
}
-void HTMLMediaElement::removedFrom(Node* insertionPoint)
+void HTMLMediaElement::removedFrom(ContainerNode* insertionPoint)
{
if (insertionPoint->inDocument()) {
LOG(Media, "HTMLMediaElement::removedFromDocument");
virtual bool rendererIsNeeded(const NodeRenderingContext&);
virtual RenderObject* createRenderer(RenderArena*, RenderStyle*);
virtual bool childShouldCreateRenderer(const NodeRenderingContext&) const OVERRIDE;
- virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
- virtual void removedFrom(Node*) OVERRIDE;
+ virtual InsertionNotificationRequest insertedInto(ContainerNode*) OVERRIDE;
+ virtual void removedFrom(ContainerNode*) OVERRIDE;
virtual void didRecalcStyle(StyleChange);
virtual void defaultEventHandler(Event*);
HTMLElement::parseAttribute(attribute);
}
-Node::InsertionNotificationRequest HTMLMetaElement::insertedInto(Node* insertionPoint)
+Node::InsertionNotificationRequest HTMLMetaElement::insertedInto(ContainerNode* insertionPoint)
{
HTMLElement::insertedInto(insertionPoint);
if (insertionPoint->inDocument())
HTMLMetaElement(const QualifiedName&, Document*);
virtual void parseAttribute(const Attribute&) OVERRIDE;
- virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
+ virtual InsertionNotificationRequest insertedInto(ContainerNode*) OVERRIDE;
void process();
return HTMLPlugInImageElement::rendererIsNeeded(context);
}
-Node::InsertionNotificationRequest HTMLObjectElement::insertedInto(Node* insertionPoint)
+Node::InsertionNotificationRequest HTMLObjectElement::insertedInto(ContainerNode* insertionPoint)
{
HTMLPlugInImageElement::insertedInto(insertionPoint);
FormAssociatedElement::insertedInto(insertionPoint);
return InsertionDone;
}
-void HTMLObjectElement::removedFrom(Node* insertionPoint)
+void HTMLObjectElement::removedFrom(ContainerNode* insertionPoint)
{
HTMLPlugInImageElement::removedFrom(insertionPoint);
FormAssociatedElement::removedFrom(insertionPoint);
virtual bool isPresentationAttribute(const QualifiedName&) const OVERRIDE;
virtual void collectStyleForAttribute(const Attribute&, StylePropertySet*) OVERRIDE;
- virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
- virtual void removedFrom(Node*) OVERRIDE;
+ virtual InsertionNotificationRequest insertedInto(ContainerNode*) OVERRIDE;
+ virtual void removedFrom(ContainerNode*) OVERRIDE;
virtual bool rendererIsNeeded(const NodeRenderingContext&);
virtual void didMoveToNewDocument(Document* oldDocument) OVERRIDE;
return ownElementDisabled() || (parentNode() && parentNode()->isHTMLElement() && static_cast<HTMLElement*>(parentNode())->disabled());
}
-Node::InsertionNotificationRequest HTMLOptionElement::insertedInto(Node* insertionPoint)
+Node::InsertionNotificationRequest HTMLOptionElement::insertedInto(ContainerNode* insertionPoint)
{
if (HTMLSelectElement* select = ownerSelectElement()) {
select->setRecalcListItems();
virtual void parseAttribute(const Attribute&) OVERRIDE;
- virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
+ virtual InsertionNotificationRequest insertedInto(ContainerNode*) OVERRIDE;
virtual void accessKeyAction(bool);
virtual void childrenChanged(bool changedByParser = false, Node* beforeChange = 0, Node* afterChange = 0, int childCountDelta = 0);
return adoptRef(new HTMLQuoteElement(tagName, document));
}
-Node::InsertionNotificationRequest HTMLQuoteElement::insertedInto(Node* insertionPoint)
+Node::InsertionNotificationRequest HTMLQuoteElement::insertedInto(ContainerNode* insertionPoint)
{
if (hasTagName(qTag))
document()->setUsesBeforeAfterRules(true);
private:
HTMLQuoteElement(const QualifiedName&, Document*);
- virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
+ virtual InsertionNotificationRequest insertedInto(ContainerNode*) OVERRIDE;
virtual bool isURLAttribute(const Attribute&) const OVERRIDE;
};
HTMLElement::parseAttribute(attribute);
}
-Node::InsertionNotificationRequest HTMLScriptElement::insertedInto(Node* insertionPoint)
+Node::InsertionNotificationRequest HTMLScriptElement::insertedInto(ContainerNode* insertionPoint)
{
HTMLElement::insertedInto(insertionPoint);
ScriptElement::insertedInto(insertionPoint);
HTMLScriptElement(const QualifiedName&, Document*, bool wasInsertedByParser, bool alreadyStarted);
virtual void parseAttribute(const Attribute&) OVERRIDE;
- virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
+ virtual InsertionNotificationRequest insertedInto(ContainerNode*) OVERRIDE;
virtual void childrenChanged(bool changedByParser = false, Node* beforeChange = 0, Node* afterChange = 0, int childCountDelta = 0);
virtual bool isURLAttribute(const Attribute&) const OVERRIDE;
}
}
-Node::InsertionNotificationRequest HTMLSelectElement::insertedInto(Node* insertionPoint)
+Node::InsertionNotificationRequest HTMLSelectElement::insertedInto(ContainerNode* insertionPoint)
{
// When the element is created during document parsing, it won't have any
// items yet - but for innerHTML and related methods, this method is called
void typeAheadFind(KeyboardEvent*);
void saveLastSelection();
- virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
+ virtual InsertionNotificationRequest insertedInto(ContainerNode*) OVERRIDE;
virtual bool isOptionalFormControl() const { return !isRequiredFormControl(); }
virtual bool isRequiredFormControl() const;
return adoptRef(new HTMLSourceElement(tagName, document));
}
-Node::InsertionNotificationRequest HTMLSourceElement::insertedInto(Node* insertionPoint)
+Node::InsertionNotificationRequest HTMLSourceElement::insertedInto(ContainerNode* insertionPoint)
{
HTMLElement::insertedInto(insertionPoint);
Element* parent = parentElement();
return InsertionDone;
}
-void HTMLSourceElement::removedFrom(Node* removalRoot)
+void HTMLSourceElement::removedFrom(ContainerNode* removalRoot)
{
Element* parent = parentElement();
if (!parent && removalRoot->isElementNode())
private:
HTMLSourceElement(const QualifiedName&, Document*);
- virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
- virtual void removedFrom(Node*) OVERRIDE;
+ virtual InsertionNotificationRequest insertedInto(ContainerNode*) OVERRIDE;
+ virtual void removedFrom(ContainerNode*) OVERRIDE;
virtual bool isURLAttribute(const Attribute&) const OVERRIDE;
void errorEventTimerFired(Timer<HTMLSourceElement>*);
}
#endif
-Node::InsertionNotificationRequest HTMLStyleElement::insertedInto(Node* insertionPoint)
+Node::InsertionNotificationRequest HTMLStyleElement::insertedInto(ContainerNode* insertionPoint)
{
HTMLElement::insertedInto(insertionPoint);
if (insertionPoint->inDocument()) {
return InsertionDone;
}
-void HTMLStyleElement::removedFrom(Node* insertionPoint)
+void HTMLStyleElement::removedFrom(ContainerNode* insertionPoint)
{
HTMLElement::removedFrom(insertionPoint);
// That is, because willRemove() is also called if an ancestor is removed from the document.
// Now, if we want to register <style scoped> even if it's not inDocument,
// we'd need to find a way to discern whether that is the case, or whether <style scoped> itself is about to be removed.
- if (m_isRegisteredWithScopingNode) {
- Node* scope = parentNode() ? parentNode() : insertionPoint;
- unregisterWithScopingNode(toContainerNode(scope));
- }
+ if (m_isRegisteredWithScopingNode)
+ unregisterWithScopingNode(parentNode() ? parentNode() : insertionPoint);
#endif
if (insertionPoint->inDocument())
// overload from HTMLElement
virtual void parseAttribute(const Attribute&) OVERRIDE;
- virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
- virtual void removedFrom(Node*) OVERRIDE;
+ virtual InsertionNotificationRequest insertedInto(ContainerNode*) OVERRIDE;
+ virtual void removedFrom(ContainerNode*) OVERRIDE;
virtual void childrenChanged(bool changedByParser = false, Node* beforeChange = 0, Node* afterChange = 0, int childCountDelta = 0);
virtual void finishParsingChildren();
return childContext.isOnEncapsulationBoundary() && HTMLFormControlElementWithState::childShouldCreateRenderer(childContext);
}
-Node::InsertionNotificationRequest HTMLTextFormControlElement::insertedInto(Node* insertionPoint)
+Node::InsertionNotificationRequest HTMLTextFormControlElement::insertedInto(ContainerNode* insertionPoint)
{
HTMLFormControlElement::insertedInto(insertionPoint);
if (!insertionPoint->inDocument())
void forwardEvent(Event*);
- virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
+ virtual InsertionNotificationRequest insertedInto(ContainerNode*) OVERRIDE;
// The derived class should return true if placeholder processing is needed.
virtual bool supportsPlaceholder() const = 0;
return adoptRef(new HTMLTitleElement(tagName, document));
}
-Node::InsertionNotificationRequest HTMLTitleElement::insertedInto(Node* insertionPoint)
+Node::InsertionNotificationRequest HTMLTitleElement::insertedInto(ContainerNode* insertionPoint)
{
HTMLElement::insertedInto(insertionPoint);
if (insertionPoint->inDocument())
return InsertionDone;
}
-void HTMLTitleElement::removedFrom(Node* insertionPoint)
+void HTMLTitleElement::removedFrom(ContainerNode* insertionPoint)
{
HTMLElement::removedFrom(insertionPoint);
if (insertionPoint->inDocument())
private:
HTMLTitleElement(const QualifiedName&, Document*);
- virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
- virtual void removedFrom(Node*) OVERRIDE;
+ virtual InsertionNotificationRequest insertedInto(ContainerNode*) OVERRIDE;
+ virtual void removedFrom(ContainerNode*) OVERRIDE;
virtual void childrenChanged(bool changedByParser = false, Node* beforeChange = 0, Node* afterChange = 0, int childCountDelta = 0);
StringWithDirection m_title;
return adoptRef(new HTMLTrackElement(tagName, document));
}
-Node::InsertionNotificationRequest HTMLTrackElement::insertedInto(Node* insertionPoint)
+Node::InsertionNotificationRequest HTMLTrackElement::insertedInto(ContainerNode* insertionPoint)
{
HTMLElement::insertedInto(insertionPoint);
if (insertionPoint->inDocument()) {
return InsertionDone;
}
-void HTMLTrackElement::removedFrom(Node* insertionPoint)
+void HTMLTrackElement::removedFrom(ContainerNode* insertionPoint)
{
HTMLMediaElement* parent = mediaElement();
if (!parent && WebCore::isMediaElement(insertionPoint))
virtual void parseAttribute(const Attribute&) OVERRIDE;
- virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
+ virtual InsertionNotificationRequest insertedInto(ContainerNode*) OVERRIDE;
- virtual void removedFrom(Node*) OVERRIDE;
+ virtual void removedFrom(ContainerNode*) OVERRIDE;
virtual bool isURLAttribute(const Attribute&) const OVERRIDE;
#if ENABLE(MICRODATA)
return adoptRef(new MathMLMathElement(tagName, document));
}
-Node::InsertionNotificationRequest MathMLMathElement::insertedInto(Node* insertionPoint)
+Node::InsertionNotificationRequest MathMLMathElement::insertedInto(ContainerNode* insertionPoint)
{
// There are sibling rules in the MathML default style.
if (insertionPoint->inDocument())
private:
MathMLMathElement(const QualifiedName& tagName, Document*);
- virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
+ virtual InsertionNotificationRequest insertedInto(ContainerNode*) OVERRIDE;
virtual RenderObject* createRenderer(RenderArena*, RenderStyle*);
};
setAttribute(XMLNames::baseAttr, value);
}
-void SVGElement::removedFrom(Node* rootParent)
+void SVGElement::removedFrom(ContainerNode* rootParent)
{
if (rootParent->inDocument()) {
document()->accessSVGExtensions()->removeAllAnimationElementsFromTarget(this);
virtual void attributeChanged(const Attribute&) OVERRIDE;
virtual bool childShouldCreateRenderer(const NodeRenderingContext&) const OVERRIDE;
- virtual void removedFrom(Node*) OVERRIDE;
+ virtual void removedFrom(ContainerNode*) OVERRIDE;
SVGElementRareData* rareSVGData() const;
SVGElementRareData* ensureRareSVGData();
ASSERT_NOT_REACHED();
}
-Node::InsertionNotificationRequest SVGFEImageElement::insertedInto(Node* rootParent)
+Node::InsertionNotificationRequest SVGFEImageElement::insertedInto(ContainerNode* rootParent)
{
SVGFilterPrimitiveStandardAttributes::insertedInto(rootParent);
buildPendingResource();
return InsertionDone;
}
-void SVGFEImageElement::removedFrom(Node* rootParent)
+void SVGFEImageElement::removedFrom(ContainerNode* rootParent)
{
SVGFilterPrimitiveStandardAttributes::removedFrom(rootParent);
if (rootParent->inDocument())
void requestImageResource();
virtual void buildPendingResource();
- virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
- virtual void removedFrom(Node*) OVERRIDE;
+ virtual InsertionNotificationRequest insertedInto(ContainerNode*) OVERRIDE;
+ virtual void removedFrom(ContainerNode*) OVERRIDE;
BEGIN_DECLARE_ANIMATED_PROPERTIES(SVGFEImageElement)
DECLARE_ANIMATED_PRESERVEASPECTRATIO(PreserveAspectRatio, preserveAspectRatio)
document()->styleResolverChanged(DeferRecalcStyle);
}
-Node::InsertionNotificationRequest SVGFontFaceElement::insertedInto(Node* rootParent)
+Node::InsertionNotificationRequest SVGFontFaceElement::insertedInto(ContainerNode* rootParent)
{
SVGElement::insertedInto(rootParent);
if (!rootParent->inDocument())
return InsertionDone;
}
-void SVGFontFaceElement::removedFrom(Node* rootParent)
+void SVGFontFaceElement::removedFrom(ContainerNode* rootParent)
{
SVGElement::removedFrom(rootParent);
virtual void parseAttribute(const Attribute&) OVERRIDE;
virtual void childrenChanged(bool changedByParser = false, Node* beforeChange = 0, Node* afterChange = 0, int childCountDelta = 0);
- virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
- virtual void removedFrom(Node*) OVERRIDE;
+ virtual InsertionNotificationRequest insertedInto(ContainerNode*) OVERRIDE;
+ virtual void removedFrom(ContainerNode*) OVERRIDE;
RefPtr<StyleRuleFontFace> m_fontFaceRule;
RefPtr<SVGFontElement> m_fontElement;
static_cast<SVGFontFaceElement*>(grandparent)->rebuildFontFace();
}
-Node::InsertionNotificationRequest SVGFontFaceUriElement::insertedInto(Node* rootParent)
+Node::InsertionNotificationRequest SVGFontFaceUriElement::insertedInto(ContainerNode* rootParent)
{
loadFont();
return SVGElement::insertedInto(rootParent);
virtual void parseAttribute(const Attribute&) OVERRIDE;
virtual void childrenChanged(bool changedByParser = false, Node* beforeChange = 0, Node* afterChange = 0, int childCountDelta = 0);
- virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
+ virtual InsertionNotificationRequest insertedInto(ContainerNode*) OVERRIDE;
void loadFont();
SVGStyledElement::parseAttribute(attribute);
}
-Node::InsertionNotificationRequest SVGGlyphElement::insertedInto(Node* rootParent)
+Node::InsertionNotificationRequest SVGGlyphElement::insertedInto(ContainerNode* rootParent)
{
invalidateGlyphCache();
return SVGStyledElement::insertedInto(rootParent);
}
-void SVGGlyphElement::removedFrom(Node* rootParent)
+void SVGGlyphElement::removedFrom(ContainerNode* rootParent)
{
if (rootParent->inDocument())
invalidateGlyphCache();
// FIXME: svgAttributeChanged missing.
virtual void parseAttribute(const Attribute&) OVERRIDE;
- virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
- virtual void removedFrom(Node*) OVERRIDE;
+ virtual InsertionNotificationRequest insertedInto(ContainerNode*) OVERRIDE;
+ virtual void removedFrom(ContainerNode*) OVERRIDE;
virtual bool rendererIsNeeded(const NodeRenderingContext&) { return false; }
return adoptRef(new SVGHKernElement(tagName, document));
}
-Node::InsertionNotificationRequest SVGHKernElement::insertedInto(Node* rootParent)
+Node::InsertionNotificationRequest SVGHKernElement::insertedInto(ContainerNode* rootParent)
{
ContainerNode* fontNode = parentNode();
if (fontNode && fontNode->hasTagName(SVGNames::fontTag)) {
return SVGElement::insertedInto(rootParent);
}
-void SVGHKernElement::removedFrom(Node* rootParent)
+void SVGHKernElement::removedFrom(ContainerNode* rootParent)
{
ContainerNode* fontNode = parentNode();
if (fontNode && fontNode->hasTagName(SVGNames::fontTag)) {
private:
SVGHKernElement(const QualifiedName&, Document*);
- virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
- virtual void removedFrom(Node*) OVERRIDE;
+ virtual InsertionNotificationRequest insertedInto(ContainerNode*) OVERRIDE;
+ virtual void removedFrom(ContainerNode*) OVERRIDE;
virtual bool rendererIsNeeded(const NodeRenderingContext&) { return false; }
};
}
}
-Node::InsertionNotificationRequest SVGImageElement::insertedInto(Node* rootParent)
+Node::InsertionNotificationRequest SVGImageElement::insertedInto(ContainerNode* rootParent)
{
SVGStyledTransformableElement::insertedInto(rootParent);
if (!rootParent->inDocument())
virtual void svgAttributeChanged(const QualifiedName&);
virtual void attach();
- virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
+ virtual InsertionNotificationRequest insertedInto(ContainerNode*) OVERRIDE;
virtual RenderObject* createRenderer(RenderArena*, RenderStyle*);
return new (arena) RenderSVGViewportContainer(this);
}
-Node::InsertionNotificationRequest SVGSVGElement::insertedInto(Node* rootParent)
+Node::InsertionNotificationRequest SVGSVGElement::insertedInto(ContainerNode* rootParent)
{
if (rootParent->inDocument())
document()->accessSVGExtensions()->addTimeContainer(this);
return SVGStyledLocatableElement::insertedInto(rootParent);
}
-void SVGSVGElement::removedFrom(Node* rootParent)
+void SVGSVGElement::removedFrom(ContainerNode* rootParent)
{
if (rootParent->inDocument())
document()->accessSVGExtensions()->removeTimeContainer(this);
virtual bool rendererIsNeeded(const NodeRenderingContext& context) { return StyledElement::rendererIsNeeded(context); }
virtual RenderObject* createRenderer(RenderArena*, RenderStyle*);
- virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
- virtual void removedFrom(Node*) OVERRIDE;
+ virtual InsertionNotificationRequest insertedInto(ContainerNode*) OVERRIDE;
+ virtual void removedFrom(ContainerNode*) OVERRIDE;
virtual void svgAttributeChanged(const QualifiedName&);
ASSERT_NOT_REACHED();
}
-Node::InsertionNotificationRequest SVGScriptElement::insertedInto(Node* rootParent)
+Node::InsertionNotificationRequest SVGScriptElement::insertedInto(ContainerNode* rootParent)
{
SVGElement::insertedInto(rootParent);
ScriptElement::insertedInto(rootParent);
bool isSupportedAttribute(const QualifiedName&);
virtual void parseAttribute(const Attribute&) OVERRIDE;
- virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
+ virtual InsertionNotificationRequest insertedInto(ContainerNode*) OVERRIDE;
virtual void childrenChanged(bool changedByParser = false, Node* beforeChange = 0, Node* afterChange = 0, int childCountDelta = 0);
virtual void svgAttributeChanged(const QualifiedName&);
SVGElement::finishParsingChildren();
}
-Node::InsertionNotificationRequest SVGStyleElement::insertedInto(Node* rootParent)
+Node::InsertionNotificationRequest SVGStyleElement::insertedInto(ContainerNode* rootParent)
{
SVGElement::insertedInto(rootParent);
if (rootParent->inDocument())
return InsertionDone;
}
-void SVGStyleElement::removedFrom(Node* rootParent)
+void SVGStyleElement::removedFrom(ContainerNode* rootParent)
{
SVGElement::removedFrom(rootParent);
if (rootParent->inDocument())
bool isSupportedAttribute(const QualifiedName&);
virtual void parseAttribute(const Attribute&) OVERRIDE;
- virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
- virtual void removedFrom(Node*) OVERRIDE;
+ virtual InsertionNotificationRequest insertedInto(ContainerNode*) OVERRIDE;
+ virtual void removedFrom(ContainerNode*) OVERRIDE;
virtual void childrenChanged(bool changedByParser = false, Node* beforeChange = 0, Node* afterChange = 0, int childCountDelta = 0);
virtual void finishParsingChildren();
object->updateFromElement();
}
-Node::InsertionNotificationRequest SVGStyledElement::insertedInto(Node* rootParent)
+Node::InsertionNotificationRequest SVGStyledElement::insertedInto(ContainerNode* rootParent)
{
SVGElement::insertedInto(rootParent);
updateRelativeLengthsInformation();
}
}
-void SVGStyledElement::removedFrom(Node* rootParent)
+void SVGStyledElement::removedFrom(ContainerNode* rootParent)
{
if (rootParent->inDocument())
updateRelativeLengthsInformation(false, this);
virtual void svgAttributeChanged(const QualifiedName&);
virtual void attach();
- virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
- virtual void removedFrom(Node*) OVERRIDE;
+ virtual InsertionNotificationRequest insertedInto(ContainerNode*) OVERRIDE;
+ virtual void removedFrom(ContainerNode*) OVERRIDE;
virtual void childrenChanged(bool changedByParser = false, Node* beforeChange = 0, Node* afterChange = 0, int childCountDelta = 0);
static CSSPropertyID cssPropertyIdForSVGAttributeName(const QualifiedName&);
}
}
-Node::InsertionNotificationRequest SVGTRefElement::insertedInto(Node* rootParent)
+Node::InsertionNotificationRequest SVGTRefElement::insertedInto(ContainerNode* rootParent)
{
SVGStyledElement::insertedInto(rootParent);
if (rootParent->inDocument())
return InsertionDone;
}
-void SVGTRefElement::removedFrom(Node* rootParent)
+void SVGTRefElement::removedFrom(ContainerNode* rootParent)
{
SVGStyledElement::removedFrom(rootParent);
if (rootParent->inDocument())
virtual bool childShouldCreateRenderer(const NodeRenderingContext&) const;
virtual bool rendererIsNeeded(const NodeRenderingContext&);
- virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
- virtual void removedFrom(Node*) OVERRIDE;
+ virtual InsertionNotificationRequest insertedInto(ContainerNode*) OVERRIDE;
+ virtual void removedFrom(ContainerNode*) OVERRIDE;
void clearEventListener();
return false;
}
-Node::InsertionNotificationRequest SVGTextPathElement::insertedInto(Node* rootParent)
+Node::InsertionNotificationRequest SVGTextPathElement::insertedInto(ContainerNode* rootParent)
{
SVGStyledElement::insertedInto(rootParent);
if (!rootParent->inDocument())
private:
SVGTextPathElement(const QualifiedName&, Document*);
- virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
+ virtual InsertionNotificationRequest insertedInto(ContainerNode*) OVERRIDE;
bool isSupportedAttribute(const QualifiedName&);
virtual void parseAttribute(const Attribute&) OVERRIDE;
return adoptRef(new SVGTitleElement(tagName, document));
}
-Node::InsertionNotificationRequest SVGTitleElement::insertedInto(Node* rootParent)
+Node::InsertionNotificationRequest SVGTitleElement::insertedInto(ContainerNode* rootParent)
{
SVGStyledElement::insertedInto(rootParent);
if (!rootParent->inDocument())
return InsertionDone;
}
-void SVGTitleElement::removedFrom(Node* rootParent)
+void SVGTitleElement::removedFrom(ContainerNode* rootParent)
{
SVGElement::removedFrom(rootParent);
if (rootParent->inDocument())
private:
SVGTitleElement(const QualifiedName&, Document*);
- virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
- virtual void removedFrom(Node*) OVERRIDE;
+ virtual InsertionNotificationRequest insertedInto(ContainerNode*) OVERRIDE;
+ virtual void removedFrom(ContainerNode*) OVERRIDE;
virtual void childrenChanged(bool changedByParser = false, Node* beforeChange = 0, Node* afterChange = 0, int childCountDelta = 0);
virtual bool rendererIsNeeded(const NodeRenderingContext&) { return false; }
return true;
}
-Node::InsertionNotificationRequest SVGUseElement::insertedInto(Node* rootParent)
+Node::InsertionNotificationRequest SVGUseElement::insertedInto(ContainerNode* rootParent)
{
// This functions exists to assure assumptions made in the code regarding SVGElementInstance creation/destruction are satisfied.
SVGStyledTransformableElement::insertedInto(rootParent);
return InsertionDone;
}
-void SVGUseElement::removedFrom(Node* rootParent)
+void SVGUseElement::removedFrom(ContainerNode* rootParent)
{
SVGStyledTransformableElement::removedFrom(rootParent);
if (rootParent->inDocument())
virtual bool isValid() const { return SVGTests::isValid(); }
virtual bool supportsFocus() const { return true; }
- virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
- virtual void removedFrom(Node*) OVERRIDE;
+ virtual InsertionNotificationRequest insertedInto(ContainerNode*) OVERRIDE;
+ virtual void removedFrom(ContainerNode*) OVERRIDE;
virtual void buildPendingResource();
bool isSupportedAttribute(const QualifiedName&);
return adoptRef(new SVGVKernElement(tagName, document));
}
-Node::InsertionNotificationRequest SVGVKernElement::insertedInto(Node* rootParent)
+Node::InsertionNotificationRequest SVGVKernElement::insertedInto(ContainerNode* rootParent)
{
if (rootParent->inDocument()) {
ContainerNode* fontNode = parentNode();
return SVGElement::insertedInto(rootParent);
}
-void SVGVKernElement::removedFrom(Node* rootParent)
+void SVGVKernElement::removedFrom(ContainerNode* rootParent)
{
ContainerNode* fontNode = parentNode();
if (fontNode && fontNode->hasTagName(SVGNames::fontTag)) {
private:
SVGVKernElement(const QualifiedName&, Document*);
- virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
- virtual void removedFrom(Node*) OVERRIDE;
+ virtual InsertionNotificationRequest insertedInto(ContainerNode*) OVERRIDE;
+ virtual void removedFrom(ContainerNode*) OVERRIDE;
virtual bool rendererIsNeeded(const NodeRenderingContext&) { return false; }
};
resolveFirstInterval();
}
-Node::InsertionNotificationRequest SVGSMILElement::insertedInto(Node* rootParent)
+Node::InsertionNotificationRequest SVGSMILElement::insertedInto(ContainerNode* rootParent)
{
SVGElement::insertedInto(rootParent);
if (!rootParent->inDocument())
return InsertionDone;
}
-void SVGSMILElement::removedFrom(Node* rootParent)
+void SVGSMILElement::removedFrom(ContainerNode* rootParent)
{
if (rootParent->inDocument()) {
if (m_timeContainer) {
bool isSupportedAttribute(const QualifiedName&);
virtual void parseAttribute(const Attribute&) OVERRIDE;
virtual void svgAttributeChanged(const QualifiedName&) OVERRIDE;
- virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
- virtual void removedFrom(Node*) OVERRIDE;
+ virtual InsertionNotificationRequest insertedInto(ContainerNode*) OVERRIDE;
+ virtual void removedFrom(ContainerNode*) OVERRIDE;
virtual bool hasValidAttributeType() = 0;
virtual void animationAttributeChanged() = 0;
git://git.webkit.org / WebKit-https.git / commitdiff