Attachment #137479 for bug #82701

View Details Raw Unified Return to Bug 82701

| Differences between



2012-04-16  Hajime Morrita  <morrita@chromium.org>

        insertedIntoDocument and insertedIntoTree should be unitifed.
        https://bugs.webkit.org/show_bug.cgi?id=82701

        Reviewed by NOBODY (OOPS!).

        Both Node::insertedIntoTree() and Node::insertedIntoDocument() are
        served as lifecycle callbacks which are invoked when a node is
        inserted into its new parent. There are also removedFromTree()
        and removedFromDocument() respectively. Considering that this pair
        of virtual functions are laid onto the hot path, it's worth
        merging them into one, to gain some speedup. Such
        unification could clarify the semantics as well.

        This change makes following change to merge these functions.

        - pulling the tree traversal out from ContainerNode to ChildNodeInsertionNotifier.
        - letting new Node::insertInto() do the job for its own, but not
          for its children and
        - Pass the parent of each insertion root as a parameter of insertedInto().
          This root node can tell inserted node where it is inserted,
          specifically whetehr the insertion is to the document or not.

        Same pattern is also applied to Node::removedFromDocument() and
        Node::removedFromTree(), which are factored to Node::removedFrom()
        and ChildNodeRemovalNotifier respectively.

        Speed up on Dromaeo/dom-modify.html is about 2%.
        Further speed-up by de-virtulization would be possible.

        Caveat:

        There is possible situation where a node need to invoke
        insertedInto() after its children is nofitied, instead of before
        that.  It was represented naturally with previous
        traversal-by-ContainerNode pattern, but is no longer simple with
        this new external traversal. To support this scenario, we
        introduced the InsertionNotificationRequest as a return value of insertedInto()
        and a supplemental hook Node::didNotifyDescendantInseretions(). See for
        example HTMLFormElement.cpp to learn how it works.

        No new tests. Covered by existing tests.

        * CMakeLists.txt:
        * GNUmakefile.list.am:
        * Target.pri:
        * WebCore.gypi:
        * WebCore.xcodeproj/project.pbxproj:
        * dom/ContainerNode.cpp:
        (WebCore::ContainerNode::parserInsertBefore):
        (WebCore::ContainerNode::removeChild):
        (WebCore::ContainerNode::parserRemoveChild):
        (WebCore::ContainerNode::removeChildren):
        (WebCore::ContainerNode::parserAddChild):
        (WebCore::updateTreeAfterInsertion):
        * dom/ContainerNode.h:
        (ContainerNode):
        (WebCore::Node::highestAncestor):
        (WebCore):
        * dom/ContainerNodeAlgorithms.cpp: Added.
        (WebCore):
        (WebCore::ChildNodeInsertionNotifier::notifyDescendantInsertedIntoDocument):
        (WebCore::ChildNodeInsertionNotifier::notifyDescendantInsertedIntoTree):
        (WebCore::ChildNodeRemovalNotifier::notifyDescendantRemovedFromDocument):
        (WebCore::ChildNodeRemovalNotifier::notifyDescendantRemovedFromTree):
        * dom/ContainerNodeAlgorithms.h:
        (ChildNodeInsertionNotifier):
        (WebCore::ChildNodeInsertionNotifier::ChildNodeInsertionNotifier):
        (WebCore):
        (ChildNodeRemovalNotifier):
        (WebCore::ChildNodeRemovalNotifier::ChildNodeRemovalNotifier):
        (WebCore::removeAllChildrenInContainer):
        (WebCore::appendChildToContainer):
        (Private):
        (WebCore::ChildNodeInsertionNotifier::notifyNodeInsertedIntoDocument):
        (WebCore::ChildNodeInsertionNotifier::notifyNodeInsertedIntoTree):
        (WebCore::ChildNodeInsertionNotifier::notifyInsertedIntoDocument):
        (WebCore::ChildNodeInsertionNotifier::notify):
        (WebCore::ChildNodeRemovalNotifier::notifyNodeRemovedFromDocument):
        (WebCore::ChildNodeRemovalNotifier::notifyNodeRemovedFromTree):
        (WebCore::ChildNodeRemovalNotifier::notify):
        * dom/DOMAllInOne.cpp:
        * dom/DocumentType.cpp:
        (WebCore::DocumentType::insertedInto):
        (WebCore::DocumentType::removedFrom):
        * dom/DocumentType.h:
        (DocumentType):
        * dom/Element.cpp:
        (WebCore::Element::insertedInto):
        (WebCore::Element::removedFrom):
        * dom/Element.h:
        (Element):
        * dom/Node.cpp:
        (WebCore::Node::insertedInto):
        (WebCore::Node::removedFrom):
        * dom/Node.h:
        (Node):
        (WebCore::Node::didNotifyDescendantInseretions):
        * dom/ProcessingInstruction.cpp:
        (WebCore::ProcessingInstruction::insertedInto):
        (WebCore::ProcessingInstruction::removedFrom):
        * dom/ProcessingInstruction.h:
        (ProcessingInstruction):
        * dom/ScriptElement.cpp:
        (WebCore::ScriptElement::insertedInto):
        * dom/ScriptElement.h:
        (WebCore):
        (ScriptElement):
        * dom/ShadowTree.cpp:
        (WebCore::ShadowTree::addShadowRoot):
        (WebCore::ShadowTree::removeAllShadowRoots):
        * dom/ShadowTree.h:
        (ShadowTree):
        (ShadowRootVector):
        (WebCore::ShadowRootVector::ShadowRootVector):
        (WebCore):
        * html/FormAssociatedElement.cpp:
        (WebCore::FormAssociatedElement::insertedInto):
        (WebCore::FormAssociatedElement::removedFrom):
        (WebCore::FormAssociatedElement::formRemovedFromTree):
        * html/FormAssociatedElement.h:
        (FormAssociatedElement):
        * html/HTMLBaseElement.cpp:
        (WebCore::HTMLBaseElement::insertedInto):
        (WebCore::HTMLBaseElement::removedFrom):
        * html/HTMLBaseElement.h:
        (HTMLBaseElement):
        * html/HTMLBodyElement.cpp:
        (WebCore::HTMLBodyElement::insertedInto):
        (WebCore::HTMLBodyElement::didNotifyDescendantInseretions):
        * html/HTMLBodyElement.h:
        (HTMLBodyElement):
        * html/HTMLFormControlElement.cpp:
        (WebCore::HTMLFormControlElement::insertedInto):
        (WebCore::HTMLFormControlElement::removedFrom):
        * html/HTMLFormControlElement.h:
        (HTMLFormControlElement):
        * html/HTMLFormElement.cpp:
        (WebCore::HTMLFormElement::insertedInto):
        (WebCore::HTMLFormElement::didNotifyDescendantInseretions):
        (WebCore::HTMLFormElement::removedFrom):
        * html/HTMLFormElement.h:
        (HTMLFormElement):
        * html/HTMLFrameElementBase.cpp:
        (WebCore::HTMLFrameElementBase::insertedInto):
        (WebCore):
        (WebCore::HTMLFrameElementBase::didNotifyDescendantInseretions):
        * html/HTMLFrameElementBase.h:
        (HTMLFrameElementBase):
        * html/HTMLFrameSetElement.cpp:
        (WebCore::HTMLFrameSetElement::insertedInto):
        (WebCore::HTMLFrameSetElement::removedFrom):
        * html/HTMLFrameSetElement.h:
        (HTMLFrameSetElement):
        * html/HTMLIFrameElement.cpp:
        (WebCore::HTMLIFrameElement::insertedInto):
        (WebCore::HTMLIFrameElement::removedFrom):
        * html/HTMLIFrameElement.h:
        (HTMLIFrameElement):
        * html/HTMLImageElement.cpp:
        (WebCore::HTMLImageElement::insertedInto):
        (WebCore::HTMLImageElement::removedFrom):
        * html/HTMLImageElement.h:
        (HTMLImageElement):
        * html/HTMLInputElement.cpp:
        (WebCore::HTMLInputElement::insertedInto):
        (WebCore::HTMLInputElement::removedFrom):
        * html/HTMLInputElement.h:
        * html/HTMLLinkElement.cpp:
        (WebCore::HTMLLinkElement::insertedInto):
        (WebCore::HTMLLinkElement::removedFrom):
        * html/HTMLLinkElement.h:
        (HTMLLinkElement):
        * html/HTMLMapElement.cpp:
        (WebCore::HTMLMapElement::insertedInto):
        (WebCore::HTMLMapElement::removedFrom):
        * html/HTMLMapElement.h:
        (HTMLMapElement):
        * html/HTMLMediaElement.cpp:
        (WebCore::HTMLMediaElement::insertedInto):
        (WebCore::HTMLMediaElement::removedFrom):
        * html/HTMLMediaElement.h:
        (HTMLMediaElement):
        * html/HTMLMetaElement.cpp:
        (WebCore::HTMLMetaElement::insertedInto):
        * html/HTMLMetaElement.h:
        (HTMLMetaElement):
        * html/HTMLObjectElement.cpp:
        (WebCore::HTMLObjectElement::insertedInto):
        (WebCore::HTMLObjectElement::removedFrom):
        * html/HTMLObjectElement.h:
        (HTMLObjectElement):
        * html/HTMLOptionElement.cpp:
        (WebCore::HTMLOptionElement::insertedInto):
        * html/HTMLOptionElement.h:
        (HTMLOptionElement):
        * html/HTMLQuoteElement.cpp:
        (WebCore::HTMLQuoteElement::insertedInto):
        * html/HTMLQuoteElement.h:
        (HTMLQuoteElement):
        * html/HTMLScriptElement.cpp:
        (WebCore::HTMLScriptElement::insertedInto):
        * html/HTMLScriptElement.h:
        (HTMLScriptElement):
        * html/HTMLSelectElement.cpp:
        (WebCore::HTMLSelectElement::insertedInto):
        * html/HTMLSelectElement.h:
        * html/HTMLSourceElement.cpp:
        (WebCore::HTMLSourceElement::insertedInto):
        * html/HTMLSourceElement.h:
        (HTMLSourceElement):
        * html/HTMLStyleElement.cpp:
        (WebCore::HTMLStyleElement::insertedInto):
        (WebCore::HTMLStyleElement::removedFrom):
        * html/HTMLStyleElement.h:
        (HTMLStyleElement):
        * html/HTMLTextFormControlElement.cpp:
        (WebCore::HTMLTextFormControlElement::insertedInto):
        * html/HTMLTextFormControlElement.h:
        * html/HTMLTitleElement.cpp:
        (WebCore::HTMLTitleElement::insertedInto):
        (WebCore::HTMLTitleElement::removedFrom):
        * html/HTMLTitleElement.h:
        (HTMLTitleElement):
        * html/HTMLTrackElement.cpp:
        (WebCore::HTMLTrackElement::insertedInto):
        * html/HTMLTrackElement.h:
        (HTMLTrackElement):
        * mathml/MathMLMathElement.cpp:
        (WebCore::MathMLMathElement::insertedInto):
        * mathml/MathMLMathElement.h:
        (MathMLMathElement):
        * svg/SVGElement.cpp:
        (WebCore::SVGElement::removedFrom):
        * svg/SVGElement.h:
        (SVGElement):
        * svg/SVGFEImageElement.cpp:
        (WebCore::SVGFEImageElement::insertedInto):
        (WebCore::SVGFEImageElement::removedFrom):
        * svg/SVGFEImageElement.h:
        (SVGFEImageElement):
        * svg/SVGFontFaceElement.cpp:
        (WebCore::SVGFontFaceElement::insertedInto):
        (WebCore::SVGFontFaceElement::removedFrom):
        * svg/SVGFontFaceElement.h:
        (SVGFontFaceElement):
        * svg/SVGFontFaceUriElement.cpp:
        (WebCore::SVGFontFaceUriElement::insertedInto):
        * svg/SVGFontFaceUriElement.h:
        (SVGFontFaceUriElement):
        * svg/SVGGlyphElement.cpp:
        (WebCore::SVGGlyphElement::insertedInto):
        (WebCore::SVGGlyphElement::removedFrom):
        * svg/SVGGlyphElement.h:
        (SVGGlyphElement):
        * svg/SVGHKernElement.cpp:
        (WebCore::SVGHKernElement::insertedInto):
        (WebCore::SVGHKernElement::removedFrom):
        * svg/SVGHKernElement.h:
        (SVGHKernElement):
        * svg/SVGImageElement.cpp:
        (WebCore::SVGImageElement::insertedInto):
        * svg/SVGImageElement.h:
        (SVGImageElement):
        * svg/SVGSVGElement.cpp:
        (WebCore::SVGSVGElement::insertedInto):
        (WebCore::SVGSVGElement::removedFrom):
        * svg/SVGSVGElement.h:
        (SVGSVGElement):
        * svg/SVGScriptElement.cpp:
        (WebCore::SVGScriptElement::insertedInto):
        * svg/SVGScriptElement.h:
        (SVGScriptElement):
        * svg/SVGStyleElement.cpp:
        (WebCore::SVGStyleElement::insertedInto):
        (WebCore::SVGStyleElement::removedFrom):
        * svg/SVGStyleElement.h:
        (SVGStyleElement):
        * svg/SVGStyledElement.cpp:
        (WebCore::SVGStyledElement::insertedInto):
        (WebCore::SVGStyledElement::removedFrom):
        (WebCore::SVGStyledElement::updateRelativeLengthsInformation):
        * svg/SVGStyledElement.h:
        (SVGStyledElement):
        * svg/SVGTRefElement.cpp:
        (WebCore::SVGTRefElement::buildPendingResource):
        (WebCore::SVGTRefElement::insertedInto):
        (WebCore::SVGTRefElement::removedFrom):
        * svg/SVGTRefElement.h:
        (SVGTRefElement):
        * svg/SVGTextPathElement.cpp:
        (WebCore::SVGTextPathElement::insertedInto):
        * svg/SVGTextPathElement.h:
        * svg/SVGTitleElement.cpp:
        (WebCore::SVGTitleElement::insertedInto):
        (WebCore::SVGTitleElement::removedFrom):
        * svg/SVGTitleElement.h:
        (SVGTitleElement):
        * svg/SVGUseElement.cpp:
        (WebCore::SVGUseElement::insertedInto):
        (WebCore::SVGUseElement::removedFrom):
        * svg/SVGUseElement.h:
        (SVGUseElement):
        * svg/SVGVKernElement.cpp:
        (WebCore::SVGVKernElement::insertedInto):
        (WebCore::SVGVKernElement::removedFrom):
        * svg/SVGVKernElement.h:
        (SVGVKernElement):
        * svg/animation/SVGSMILElement.cpp:
        (WebCore::SVGSMILElement::insertedInto):
        (WebCore::SVGSMILElement::removedFrom):
        * svg/animation/SVGSMILElement.h:
        (SVGSMILElement):

2012-04-14  Emil A Eklund  <eae@chromium.org>

        Fix pixelSnapping for CalendarPicker, MediaControl and ScrollbarPart

Lines 539-544 SET(WebCore_SOURCES a/Source/WebCore/CMakeLists.txt_sec1
- a/Source/WebCore/CMakeLists.txt +1 lines
539	dom/ComposedShadowTreeWalker.cpp	539	dom/ComposedShadowTreeWalker.cpp
540	dom/CompositionEvent.cpp	540	dom/CompositionEvent.cpp
541	dom/ContainerNode.cpp	541	dom/ContainerNode.cpp
		542	dom/ContainerNodeAlgorithms.cpp
542	dom/ContextDestructionObserver.cpp	543	dom/ContextDestructionObserver.cpp
543	dom/CustomEvent.cpp	544	dom/CustomEvent.cpp
544	dom/DatasetDOMStringMap.cpp	545	dom/DatasetDOMStringMap.cpp

Lines 1759-1764 webcore_sources += \ a/Source/WebCore/GNUmakefile.list.am_sec1
- a/Source/WebCore/GNUmakefile.list.am +1 lines
1759	Source/WebCore/dom/CompositionEvent.cpp \	1759	Source/WebCore/dom/CompositionEvent.cpp \
1760	Source/WebCore/dom/CompositionEvent.h \	1760	Source/WebCore/dom/CompositionEvent.h \
1761	Source/WebCore/dom/ContainerNodeAlgorithms.h \	1761	Source/WebCore/dom/ContainerNodeAlgorithms.h \
		1762	Source/WebCore/dom/ContainerNodeAlgorithms.cpp \
1762	Source/WebCore/dom/ContainerNode.cpp \	1763	Source/WebCore/dom/ContainerNode.cpp \
1763	Source/WebCore/dom/ContainerNode.h \	1764	Source/WebCore/dom/ContainerNode.h \
1764	Source/WebCore/dom/ContextDestructionObserver.cpp \	1765	Source/WebCore/dom/ContextDestructionObserver.cpp \



    dom/ComposedShadowTreeWalker.cpp \
    dom/CompositionEvent.cpp \
    dom/ContainerNode.cpp \
    dom/ContainerNodeAlgorithms.cpp \
    dom/ContextDestructionObserver.cpp \
    dom/CustomEvent.cpp \
    dom/DecodedDataDocumentParser.cpp \

    dom/Comment.h \
    dom/ComposedShadowTreeWalker.h \
    dom/ContainerNode.h \
    dom/ContainerNodeAlgorithms.h \
    dom/CustomEvent.h \
    dom/default/PlatformMessagePortChannel.h \
    dom/DeviceMotionClient.h \

Lines 5149-5154 a/Source/WebCore/WebCore.gypi_sec1
- a/Source/WebCore/WebCore.gypi +1 lines
5149	'dom/CompositionEvent.h',	5149	'dom/CompositionEvent.h',
5150	'dom/ContainerNode.cpp',	5150	'dom/ContainerNode.cpp',
5151	'dom/ContainerNodeAlgorithms.h',	5151	'dom/ContainerNodeAlgorithms.h',
		5152	'dom/ContainerNodeAlgorithms.cpp',
5152	'dom/ContextDestructionObserver.cpp',	5153	'dom/ContextDestructionObserver.cpp',
5153	'dom/CrossThreadTask.h',	5154	'dom/CrossThreadTask.h',
5154	'dom/CustomEvent.cpp',	5155	'dom/CustomEvent.cpp',



		A78FE13C12366B1000ACE8D0 /* SpellChecker.h in Headers */ = {isa = PBXBuildFile; fileRef = A78FE13A12366B1000ACE8D0 /* SpellChecker.h */; settings = {ATTRIBUTES = (Private, ); }; };
		A795463E0B5C4C80007B438F /* DragDataMac.mm in Sources */ = {isa = PBXBuildFile; fileRef = A795463D0B5C4C80007B438F /* DragDataMac.mm */; };
		A79546430B5C4CB4007B438F /* DragData.cpp in Sources */ = {isa = PBXBuildFile; fileRef = A79546420B5C4CB4007B438F /* DragData.cpp */; };
		A7A78CD51532BA62006C21E4 /* ContainerNodeAlgorithms.cpp in Sources */ = {isa = PBXBuildFile; fileRef = A7A78CD41532BA62006C21E4 /* ContainerNodeAlgorithms.cpp */; };
		A7AD2F870EC89D07008AB002 /* LinkHash.cpp in Sources */ = {isa = PBXBuildFile; fileRef = A7AD2F850EC89D07008AB002 /* LinkHash.cpp */; };
		A7AD2F880EC89D07008AB002 /* LinkHash.h in Headers */ = {isa = PBXBuildFile; fileRef = A7AD2F860EC89D07008AB002 /* LinkHash.h */; settings = {ATTRIBUTES = (Private, ); }; };
		A7B070D2130A409C00A3763C /* FrameActionScheduler.cpp in Sources */ = {isa = PBXBuildFile; fileRef = A7B070D0130A409C00A3763C /* FrameActionScheduler.cpp */; };

		A78FE13A12366B1000ACE8D0 /* SpellChecker.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; path = SpellChecker.h; sourceTree = "<group>"; };
		A795463D0B5C4C80007B438F /* DragDataMac.mm */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.objcpp; path = DragDataMac.mm; sourceTree = "<group>"; };
		A79546420B5C4CB4007B438F /* DragData.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = DragData.cpp; sourceTree = "<group>"; };
		A7A78CD41532BA62006C21E4 /* ContainerNodeAlgorithms.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ContainerNodeAlgorithms.cpp; sourceTree = "<group>"; };
		A7AD2F850EC89D07008AB002 /* LinkHash.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = LinkHash.cpp; sourceTree = "<group>"; };
		A7AD2F860EC89D07008AB002 /* LinkHash.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LinkHash.h; sourceTree = "<group>"; };
		A7B070D0130A409C00A3763C /* FrameActionScheduler.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = FrameActionScheduler.cpp; sourceTree = "<group>"; };

				79F2F5A01091939A000D87CB /* CompositionEvent.idl */,
				A81872140977D3C0005826D9 /* ContainerNode.cpp */,
				A81872110977D3C0005826D9 /* ContainerNode.h */,
				A7A78CD41532BA62006C21E4 /* ContainerNodeAlgorithms.cpp */,
				E1A1470711102B1500EEC0F3 /* ContainerNodeAlgorithms.h */,
				97627B8B14FB3CEE002CDCA1 /* ContextDestructionObserver.cpp */,
				97627B8C14FB3CEE002CDCA1 /* ContextDestructionObserver.h */,

				BC0B36A40CD3C67C00AC7EB5 /* Console.cpp in Sources */,
				41F0618F0F5F069800A07EAC /* ConsoleMessage.cpp in Sources */,
				A818721F0977D3C0005826D9 /* ContainerNode.cpp in Sources */,
				A7A78CD51532BA62006C21E4 /* ContainerNodeAlgorithms.cpp in Sources */,
				BC5EB9800E82072500B25965 /* ContentData.cpp in Sources */,
				59102FBB14327D3B003C9D04 /* ContentSearchUtils.cpp in Sources */,
				97C471DB12F925BD0086354B /* ContentSecurityPolicy.cpp in Sources */,




namespace WebCore {

static void notifyChildInserted(Node*);
static void dispatchChildInsertionEvents(Node*);
static void dispatchChildRemovalEvents(Node*);
static void updateTreeAfterInsertion(ContainerNode*, Node*, bool shouldLazyAttach);

        insertBeforeCommon(next.get(), child);

        childrenChanged(true, nextChildPreviousSibling.get(), nextChild, 1);
        ChildNodeInsertionNotifier(this).notify(child);
    }
}



    childrenChanged(false, prev, next, -1);

    ChildNodeRemovalNotifier(this).notify(child.get());
        child->removedFromDocument();
    else if (child->isContainerNode())
        toContainerNode(child.get())->removedFromTree(true);

    dispatchSubtreeModifiedEvent();

    return child;

    removeBetween(prev, next, oldChild);

    childrenChanged(true, prev, next, -1);
    ChildNodeRemovalNotifier(this).notify(oldChild);
        oldChild->removedFromDocument();
    else if (oldChild->isContainerNode())
        toContainerNode(oldChild)->removedFromTree(true);
}

// this differs from other remove functions because it forcibly removes all the children,


    childrenChanged(false, 0, 0, -static_cast<int>(removedChildrenCount));

    for (i = 0; i < removedChildrenCount; ++i)
        ChildNodeRemovalNotifier(this).notify(removedChildren[i].get());
        if (removedChild->inDocument())
            removedChild->removedFromDocument();
        else if (removedChild->isContainerNode())
            toContainerNode(removedChild)->removedFromTree(true);
    }

    allowEventDispatch();
    dispatchSubtreeModifiedEvent();

    
    allowEventDispatch();

    // FIXME: Why doesn't this use notify(newChild.get()) instead?
    if (inDocument())
        ChildNodeInsertionNotifier(this).notifyInsertedIntoDocument(newChild.get());
    childrenChanged(true, last, 0, 1);
}


    Node::detach();
}

void ContainerNode::insertedIntoDocument()
{
    RefPtr<Node> protect(this);

    Node::insertedIntoDocument();
    insertedIntoTree(false);

    NodeVector children;
    getChildNodes(this, children);
    for (size_t i = 0; i < children.size(); ++i) {
        // If we have been removed from the document during this loop, then
        // we don't want to tell the rest of our children that they've been
        // inserted into the document because they haven't.
        if (!inDocument())
            break;
        if (children[i]->parentNode() != this)
            continue;
        children[i]->insertedIntoDocument();
    }
}

void ContainerNode::removedFromDocument()
{
    Node::removedFromDocument();
    if (document()->cssTarget() == this) 
        document()->setCSSTarget(0); 
    removedFromTree(false);

    NodeVector children;
    getChildNodes(this, children);
    for (size_t i = 0; i < children.size(); ++i) {
        // If we have been added to the document during this loop, then we
        // don't want to tell the rest of our children that they've been
        // removed from the document because they haven't.
        if (inDocument())
            break;
        if (children[i]->parentNode() != this)
            continue;
        children[i]->removedFromDocument();
    }
}

void ContainerNode::insertedIntoTree(bool deep)
{
    if (!deep)
        return;
    forbidEventDispatch();
    for (Node* child = m_firstChild; child; child = child->nextSibling()) {
        if (child->isContainerNode())
            toContainerNode(child)->insertedIntoTree(true);
    }
    allowEventDispatch();
}

void ContainerNode::removedFromTree(bool deep)
{
    if (!deep)
        return;
    forbidEventDispatch();
    for (Node* child = m_firstChild; child; child = child->nextSibling()) {
        if (child->isContainerNode())
            toContainerNode(child)->removedFromTree(true);
    }
    allowEventDispatch();
}

void ContainerNode::childrenChanged(bool changedByParser, Node*, Node*, int childCountDelta)
{
    document()->incDOMTreeVersion();

    return n;
}

static void notifyChildInserted(Node* child)
{
    ASSERT(!eventDispatchForbidden());

#if ENABLE(INSPECTOR)
    InspectorInstrumentation::didInsertDOMNode(child->document(), child);
#endif

    RefPtr<Node> c = child;
    RefPtr<Document> document = child->document();

    Node* parentOrHostNode = c->parentOrHostNode();
    if (parentOrHostNode && parentOrHostNode->inDocument())
        c->insertedIntoDocument();
    else if (c->isContainerNode())
        toContainerNode(c.get())->insertedIntoTree(true);
}

static void dispatchChildInsertionEvents(Node* child)
{


    parent->childrenChanged(false, child->previousSibling(), child->nextSibling(), 1);

    ChildNodeInsertionNotifier(parent).notify(child);

    // FIXME: Attachment should be the first operation in this function, but some code
    // (for example, HTMLFormControlElement's autofocus support) requires this ordering.



    virtual void setFocus(bool = true) OVERRIDE;
    virtual void setActive(bool active = true, bool pause = false) OVERRIDE;
    virtual void setHovered(bool = true) OVERRIDE;
    virtual void insertedIntoDocument() OVERRIDE;
    virtual void removedFromDocument() OVERRIDE;
    virtual void scheduleSetNeedsStyleRecalc(StyleChangeType = FullStyleChange) OVERRIDE;

    // -----------------------------------------------------------------------------
    // Notification of document structure changes (see Node.h for more notification methods)

    // These functions are called whenever you are connected or disconnected from a tree. That tree may be the main
    // document tree, or it could be another disconnected tree. Override these functions to do any work that depends
    // on connectedness to some ancestor (e.g., an ancestor <form>).
    virtual void insertedIntoTree(bool deep);
    virtual void removedFromTree(bool deep);

    // Notifies the node that it's list of children have changed (either by adding or removing child nodes), or a child
    // node that is of the type CDATA_SECTION_NODE, TEXT_NODE or COMMENT_NODE has changed its value.
    virtual void childrenChanged(bool createdByParser = false, Node* beforeChange = 0, Node* afterChange = 0, int childCountDelta = 0);

    return toContainerNode(this)->lastChild();
}

inline Node* Node::highestAncestor() const
{
    Node* node = const_cast<Node*>(this);
    Node* highest = node;
    for (; node; node = node->parentNode())
        highest = node;
    return highest;
}

typedef Vector<RefPtr<Node>, 11> NodeVector;

inline void getChildNodes(Node* node, NodeVector& nodes)



/*
 * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
 *           (C) 1999 Antti Koivisto (koivisto@kde.org)
 *           (C) 2001 Dirk Mueller (mueller@kde.org)
 * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
 * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
 * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
 * Copyright (C) 2012 Google Inc. All rights reserved.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public License
 * along with this library; see the file COPYING.LIB.  If not, write to
 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
 */

#include "config.h"
#include "ContainerNodeAlgorithms.h"

#include "Element.h"
#include "ShadowTree.h"

namespace WebCore {

void ChildNodeInsertionNotifier::notifyDescendantInsertedIntoDocument(ContainerNode* node)
{
    NodeVector children;
    getChildNodes(node, children);
    for (size_t i = 0; i < children.size(); ++i) {
        // If we have been removed from the document during this loop, then
        // we don't want to tell the rest of our children that they've been
        // inserted into the document because they haven't.
        if (node->inDocument() && children[i]->parentNode() == node)
            notifyNodeInsertedIntoDocument(children[i].get());
    }
        
    if (!node->isElementNode())
        return;

    if (ShadowTree* tree = toElement(node)->shadowTree()) {
        ShadowRootVector roots(tree);
        for (size_t i = 0; i < roots.size(); ++i)
            notifyNodeInsertedIntoDocument(roots[i].get());
    }
}

void ChildNodeInsertionNotifier::notifyDescendantInsertedIntoTree(ContainerNode* node)
{
    for (Node* child = node->firstChild(); child; child = child->nextSibling()) {
        if (child->isContainerNode())
            notifyNodeInsertedIntoTree(toContainerNode(child));
    }

    if (!node->isElementNode())
        return;

    if (ShadowTree* tree = toElement(node)->shadowTree()) {
        for (ShadowRoot* root = tree->youngestShadowRoot(); root; root = root->olderShadowRoot())
            notifyNodeInsertedIntoTree(root);
    }
}

void ChildNodeRemovalNotifier::notifyDescendantRemovedFromDocument(ContainerNode* node)
{
    NodeVector children;
    getChildNodes(node, children);
    for (size_t i = 0; i < children.size(); ++i) {
        // If we have been added to the document during this loop, then we
        // don't want to tell the rest of our children that they've been
        // removed from the document because they haven't.
        if (!node->inDocument() && children[i]->parentNode() == node)
            notifyNodeRemovedFromDocument(children[i].get());
    }

    if (!node->isElementNode())
        return;

    if (node->document()->cssTarget() == node)
        node->document()->setCSSTarget(0);

    if (ShadowTree* tree = toElement(node)->shadowTree()) {
        ShadowRootVector roots(tree);
        for (size_t i = 0; i < roots.size(); ++i)
            notifyNodeRemovedFromDocument(roots[i].get());
    }
}

void ChildNodeRemovalNotifier::notifyDescendantRemovedFromTree(ContainerNode* node)
{
    for (Node* child = node->firstChild(); child; child = child->nextSibling()) {
        if (child->isContainerNode())
            notifyNodeRemovedFromTree(toContainerNode(child));
    }

    if (!node->isElementNode())
        return;

    if (ShadowTree* tree = toElement(node)->shadowTree()) {
        ShadowRootVector roots(tree);
        for (size_t i = 0; i < roots.size(); ++i)
            notifyNodeRemovedFromTree(roots[i].get());
    }
}

}



#ifndef ContainerNodeAlgorithms_h
#define ContainerNodeAlgorithms_h

#include "Document.h"
#include "InspectorInstrumentation.h"
#include <wtf/Assertions.h>

namespace WebCore {

class Node;

class ChildNodeInsertionNotifier {
public:
    explicit ChildNodeInsertionNotifier(Node* insertionPoint)
        : m_insertionPoint(insertionPoint)
    { }

    void notifyInsertedIntoDocument(Node*);
    void notify(Node*);

private:
    void notifyDescendantInsertedIntoDocument(ContainerNode*);
    void notifyDescendantInsertedIntoTree(ContainerNode*);
    void notifyNodeInsertedIntoDocument(Node*);
    void notifyNodeInsertedIntoTree(ContainerNode*);

    Node* m_insertionPoint;
};

class ChildNodeRemovalNotifier {
public:
    explicit ChildNodeRemovalNotifier(Node* insertionPoint)
        : m_insertionPoint(insertionPoint)
    { }

    void notify(Node*);

private:
    void notifyDescendantRemovedFromDocument(ContainerNode*);
    void notifyDescendantRemovedFromTree(ContainerNode*);
    void notifyNodeRemovedFromDocument(Node*);
    void notifyNodeRemovedFromTree(ContainerNode*);

    Node* m_insertionPoint;
};

namespace Private {

    template<class GenericNode, class GenericNodeContainer>

// Helper functions for TreeShared-derived classes, which have a 'Node' style interface
// This applies to 'ContainerNode' and 'SVGElementInstance'
template<class GenericNode, class GenericNodeContainer>
inline void removeAllChildrenInContainer(GenericNodeContainer* container)
{
    // List of nodes to be deleted.
    GenericNode* head = 0;

}

template<class GenericNode, class GenericNodeContainer>
inline void appendChildToContainer(GenericNode* child, GenericNodeContainer* container)
{
    child->setParent(container);


            if (Document* containerDocument = container->ownerDocument())
                containerDocument->adoptIfNeeded(node);
            if (node->inDocument())
                ChildNodeRemovalNotifier(container).notify(node);
        }
    };


        container->setFirstChild(0);
        container->setLastChild(0);
    }

} // namespace Private

inline void ChildNodeInsertionNotifier::notifyNodeInsertedIntoDocument(Node* node)
{
    ASSERT(m_insertionPoint->inDocument());
    RefPtr<Node> protect(node);
    Node::InsertionNotificationRequest request = node->insertedInto(m_insertionPoint);
    if (node->isContainerNode())
        notifyDescendantInsertedIntoDocument(toContainerNode(node));
    if (request == Node::InsertionShouldCallDidNotifyDescendantInseretions)
        node->didNotifyDescendantInseretions(m_insertionPoint);
}

inline void ChildNodeInsertionNotifier::notifyNodeInsertedIntoTree(ContainerNode* node)
{
    ASSERT(!m_insertionPoint->inDocument());
    forbidEventDispatch();
    Node::InsertionNotificationRequest request = node->insertedInto(m_insertionPoint);
    notifyDescendantInsertedIntoTree(node);
    if (request == Node::InsertionShouldCallDidNotifyDescendantInseretions)
        node->didNotifyDescendantInseretions(m_insertionPoint);
    allowEventDispatch();
}

inline void ChildNodeInsertionNotifier::notifyInsertedIntoDocument(Node* node)
{
    notifyNodeInsertedIntoDocument(node);
}

inline void ChildNodeInsertionNotifier::notify(Node* node)
{
    ASSERT(!eventDispatchForbidden());

#if ENABLE(INSPECTOR)
    InspectorInstrumentation::didInsertDOMNode(node->document(), node);
#endif

    RefPtr<Document> protectDocument(node->document());
    RefPtr<Node> protectNode(node);
    if (m_insertionPoint->inDocument())
        notifyNodeInsertedIntoDocument(node);
    else if (node->isContainerNode())
        notifyNodeInsertedIntoTree(toContainerNode(node));
}


inline void ChildNodeRemovalNotifier::notifyNodeRemovedFromDocument(Node* node)
{
    ASSERT(m_insertionPoint->inDocument());
    node->removedFrom(m_insertionPoint);
    if (node->isContainerNode())
        notifyDescendantRemovedFromDocument(toContainerNode(node));
}

inline void ChildNodeRemovalNotifier::notifyNodeRemovedFromTree(ContainerNode* node)
{
    ASSERT(!m_insertionPoint->inDocument());
    forbidEventDispatch();
    node->removedFrom(m_insertionPoint);
    notifyDescendantRemovedFromTree(node);
    allowEventDispatch();
}

inline void ChildNodeRemovalNotifier::notify(Node* node)
{
    if (node->inDocument())
        notifyNodeRemovedFromDocument(node);
    else if (node->isContainerNode())
        notifyNodeRemovedFromTree(toContainerNode(node));
}

} // namespace WebCore


Lines 43-48 a/Source/WebCore/dom/DOMAllInOne.cpp_sec1
- a/Source/WebCore/dom/DOMAllInOne.cpp +1 lines
43	#include "Comment.cpp"	43	#include "Comment.cpp"
44	#include "CompositionEvent.cpp"	44	#include "CompositionEvent.cpp"
45	#include "ContainerNode.cpp"	45	#include "ContainerNode.cpp"
		46	#include "ContainerNodeAlgorithms.cpp"
46	#include "ContextDestructionObserver.cpp"	47	#include "ContextDestructionObserver.cpp"
47	#include "CustomEvent.cpp"	48	#include "CustomEvent.cpp"
48	#include "DOMCoreException.cpp"	49	#include "DOMCoreException.cpp"



    return create(document(), m_name, m_publicId, m_systemId);
}

Node::InsertionNotificationRequest DocumentType::insertedInto(Node* insertionPoint)
{
    Node::insertedInto(insertionPoint);
    if (!insertionPoint->inDocument())
        return InsertionDone;

    // Our document node can be null if we were created by a DOMImplementation.  We use the parent() instead.
    ASSERT(parentNode() && parentNode()->isDocumentNode());
    if (parentNode() && parentNode()->isDocumentNode()) {

        if (!doc->doctype())
            doc->setDocType(this);
    }

    return InsertionDone;
}

void DocumentType::removedFrom(Node* insertionPoint)
{
    if (insertionPoint->inDocument() && document() && document()->doctype() == this)
        document()->setDocType(0);
    Node::removedFrom(insertionPoint);
}

}



    virtual NodeType nodeType() const;
    virtual PassRefPtr<Node> cloneNode(bool deep);

    virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
    virtual void removedFrom(Node*) OVERRIDE;

    OwnPtr<NamedNodeMap> m_entities;
    OwnPtr<NamedNodeMap> m_notations;

Lines 881-893 void Element::willRemove() a/Source/WebCore/dom/Element.cpp_sec1
- a/Source/WebCore/dom/Element.cpp -41 / +26 lines
881	ContainerNode::willRemove();	881	ContainerNode::willRemove();
882	}	882	}
883		883
884	void Element::insertedIntoDocument()	884	Node::InsertionNotificationRequest Element::insertedInto(Node* insertionPoint)
885	{	885	{
886	// need to do superclass processing first so inDocument() is true	886	// need to do superclass processing first so inDocument() is true
887	// by the time we reach updateId	887	// by the time we reach updateId
888	ContainerNode::insertedIntoDocument();	888	ContainerNode::insertedInto(insertionPoint);
889	if (ShadowTree* tree = shadowTree())	889
890	tree->insertedIntoDocument();	890	#if ENABLE(FULLSCREEN_API)
		891	if (containsFullScreenElement() && parentElement() && !parentElement()->containsFullScreenElement())
		892	setContainsFullScreenElementOnAncestorsCrossingFrameBoundaries(true);
		893	#endif
		894
		895	if (!insertionPoint->inDocument())
		896	return InsertionDone;
891		897
892	if (m_attributeData) {	898	if (m_attributeData) {
893	if (hasID()) {	899	if (hasID()) {
Lines 901-951 void Element::insertedIntoDocument() a/Source/WebCore/dom/Element.cpp_sec2
901	updateName(nullAtom, nameItem->value());	907	updateName(nullAtom, nameItem->value());
902	}	908	}
903	}	909	}
		910
		911	return InsertionDone;
904	}	912	}
905		913
906	void Element::removedFromDocument()	914	void Element::removedFrom(Node* insertionPoint)
907	{	915	{
908	setSavedLayerScrollOffset(IntSize());	916	setSavedLayerScrollOffset(IntSize());
909		917
910	if (m_attributeData) {	918	if (insertionPoint->inDocument()) {
911	if (hasID()) {	919	if (m_attributeData) {
912	Attribute* idItem = getAttributeItem(document()->idAttributeName());	920	if (hasID()) {
913	if (idItem && !idItem->isNull())	921	Attribute* idItem = getAttributeItem(document()->idAttributeName());
914	updateId(idItem->value(), nullAtom);	922	if (idItem && !idItem->isNull())
915	}	923	updateId(idItem->value(), nullAtom);
916	if (hasName()) {	924	}
917	Attribute* nameItem = getAttributeItem(HTMLNames::nameAttr);	925	if (hasName()) {
918	if (nameItem && !nameItem->isNull())	926	Attribute* nameItem = getAttributeItem(HTMLNames::nameAttr);
919	updateName(nameItem->value(), nullAtom);	927	if (nameItem && !nameItem->isNull())
		928	updateName(nameItem->value(), nullAtom);
		929	}
920	}	930	}
921	}	931	}
922		932
923	ContainerNode::removedFromDocument();	933	ContainerNode::removedFrom(insertionPoint);
924	if (ShadowTree* tree = shadowTree())
925	tree->removedFromDocument();
926	}
927
928	void Element::insertedIntoTree(bool deep)
929	{
930	ContainerNode::insertedIntoTree(deep);
931	if (!deep)
932	return;
933	if (ShadowTree* tree = shadowTree())
934	tree->insertedIntoTree(true);
935
936	#if ENABLE(FULLSCREEN_API)
937	if (containsFullScreenElement() && parentElement() && !parentElement()->containsFullScreenElement())
938	setContainsFullScreenElementOnAncestorsCrossingFrameBoundaries(true);
939	#endif
940	}
941
942	void Element::removedFromTree(bool deep)
943	{
944	ContainerNode::removedFromTree(deep);
945	if (!deep)
946	return;
947	if (ShadowTree* tree = shadowTree())
948	tree->removedFromTree(true);
949	}	934	}
950		935
951	void Element::attach()	936	void Element::attach()



    }

    virtual void willRemove();
    virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
    virtual void removedFrom(Node*) OVERRIDE;
    virtual void insertedIntoTree(bool);
    virtual void removedFromTree(bool);
    virtual void childrenChanged(bool changedByParser = false, Node* beforeChange = 0, Node* afterChange = 0, int childCountDelta = 0);
    virtual bool willRecalcStyle(StyleChange) { return true; }
    virtual void didRecalcStyle(StyleChange) { }

Lines 2387-2400 ScriptExecutionContext* Node::scriptExecutionContext() const a/Source/WebCore/dom/Node.cpp_sec1
- a/Source/WebCore/dom/Node.cpp -4 / +9 lines
2387	return document();	2387	return document();
2388	}	2388	}
2389		2389
2390	void Node::insertedIntoDocument()	2390	Node::InsertionNotificationRequest Node::insertedInto(Node* insertionPoint)
2391	{	2391	{
2392	setFlag(InDocumentFlag);	2392	ASSERT(insertionPoint->inDocument() \|\| isContainerNode());
		2393	if (insertionPoint->inDocument())
		2394	setFlag(InDocumentFlag);
		2395	return InsertionDone;
2393	}	2396	}
2394		2397
2395	void Node::removedFromDocument()	2398	void Node::removedFrom(Node* insertionPoint)
2396	{	2399	{
2397	clearFlag(InDocumentFlag);	2400	ASSERT(insertionPoint->inDocument() \|\| isContainerNode());
		2401	if (insertionPoint->inDocument())
		2402	clearFlag(InDocumentFlag);
2398	}	2403	}
2399		2404
2400	void Node::didMoveToNewDocument(Document* oldDocument)	2405	void Node::didMoveToNewDocument(Document* oldDocument)

Lines 226-231 public: a/Source/WebCore/dom/Node.h_sec1
- a/Source/WebCore/dom/Node.h -10 / +24 lines
226	// Node's parent, shadow tree host.	226	// Node's parent, shadow tree host.
227	ContainerNode* parentOrHostNode() const;	227	ContainerNode* parentOrHostNode() const;
228	Element* parentOrHostElement() const;	228	Element* parentOrHostElement() const;
		229	Node* highestAncestor() const;
		230
229	// Use when it's guaranteed to that shadowHost is 0.	231	// Use when it's guaranteed to that shadowHost is 0.
230	ContainerNode* parentNodeGuaranteedHostFree() const;	232	ContainerNode* parentNodeGuaranteedHostFree() const;
231	// Returns the parent node, but 0 if the parent node is a ShadowRoot.	233	// Returns the parent node, but 0 if the parent node is a ShadowRoot.
Lines 505-526 public: a/Source/WebCore/dom/Node.h_sec2
505		507
506	// -----------------------------------------------------------------------------	508	// -----------------------------------------------------------------------------
507	// Notification of document structure changes (see ContainerNode.h for more notification methods)	509	// Notification of document structure changes (see ContainerNode.h for more notification methods)
508
509	// Notifies the node that it has been inserted into the document. This is called during document parsing, and also
510	// when a node is added through the DOM methods insertBefore(), appendChild() or replaceChild(). Note that this only
511	// happens when the node becomes part of the document tree, i.e. only when the document is actually an ancestor of
512	// the node. The call happens _after_ the node has been added to the tree.
513	//	510	//
		511	// At first, WebKit notifies the node that it has been inserted into the document. This is called during document parsing, and also
		512	// when a node is added through the DOM methods insertBefore(), appendChild() or replaceChild(). The call happens _after_ the node has been added to the tree.
514	// This is similar to the DOMNodeInsertedIntoDocument DOM event, but does not require the overhead of event	513	// This is similar to the DOMNodeInsertedIntoDocument DOM event, but does not require the overhead of event
515	// dispatching.	514	// dispatching.
516	virtual void insertedIntoDocument();	515	//
		516	// Webkit notifies this callback regardless if the subtree of the node is a document tree or a floating subtree.
		517	// Implementation can determine the type of subtree by seeing insertionPoint->inDocument().
		518	// For a performance reason, notifications are delivered only to ContainerNode subclasses if the insertionPoint is out of document.
		519	//
		520	// There are another callback named didNotifyDescendantInseretions(), which is called after all the descendant is notified.
		521	// Only a few subclasses actually need this. To utilize this, the node should return InsertionShouldCallDidNotifyDescendantInseretions
		522	// from insrtedInto().
		523	//
		524	enum InsertionNotificationRequest {
		525	InsertionDone,
		526	InsertionShouldCallDidNotifyDescendantInseretions
		527	};
517		528
518	// Notifies the node that it is no longer part of the document tree, i.e. when the document is no longer an ancestor	529	virtual InsertionNotificationRequest insertedInto(Node* insertionPoint);
519	// node.	530	virtual void didNotifyDescendantInseretions(Node*) { }
		531
		532	// Notifies the node that it is no longer part of the tree.
520	//	533	//
521	// This is similar to the DOMNodeRemovedFromDocument DOM event, but does not require the overhead of event	534	// This is a dual of insertedInto(), and is similar to the DOMNodeRemovedFromDocument DOM event, but does not require the overhead of event
522	// dispatching, and is called _after_ the node is removed from the tree.	535	// dispatching, and is called _after_ the node is removed from the tree.
523	virtual void removedFromDocument();	536	//
		537	virtual void removedFrom(Node* insertionPoint);
524		538
525	#ifndef NDEBUG	539	#ifndef NDEBUG
526	virtual void formatForDebugger(char* buffer, unsigned length) const;	540	virtual void formatForDebugger(char* buffer, unsigned length) const;

Lines 282-298 void ProcessingInstruction::addSubresourceAttributeURLs(ListHashSet<KURL>& urls) a/Source/WebCore/dom/ProcessingInstruction.cpp_sec1
- a/Source/WebCore/dom/ProcessingInstruction.cpp -5 / +10 lines
282	addSubresourceURL(urls, sheet()->baseURL());	282	addSubresourceURL(urls, sheet()->baseURL());
283	}	283	}
284		284
285	void ProcessingInstruction::insertedIntoDocument()	285	Node::InsertionNotificationRequest ProcessingInstruction::insertedInto(Node* insertionPoint)
286	{	286	{
287	Node::insertedIntoDocument();	287	Node::insertedInto(insertionPoint);
		288	if (!insertionPoint->inDocument())
		289	return InsertionDone;
288	document()->addStyleSheetCandidateNode(this, m_createdByParser);	290	document()->addStyleSheetCandidateNode(this, m_createdByParser);
289	checkStyleSheet();	291	checkStyleSheet();
		292	return InsertionDone;
290	}	293	}
291		294
292	void ProcessingInstruction::removedFromDocument()	295	void ProcessingInstruction::removedFrom(Node* insertionPoint)
293	{	296	{
294	Node::removedFromDocument();	297	Node::removedFrom(insertionPoint);
295		298	if (!insertionPoint->inDocument())
		299	return;
		300
296	document()->removeStyleSheetCandidateNode(this);	301	document()->removeStyleSheetCandidateNode(this);
297		302
298	if (m_sheet) {	303	if (m_sheet) {



    virtual bool offsetInCharacters() const;
    virtual int maxCharacterOffset() const;

    virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
    virtual void removedFrom(Node*) OVERRIDE;

    void checkStyleSheet();
    virtual void setCSSStyleSheet(const String& href, const KURL& baseURL, const String& charset, const CachedCSSStyleSheet*);



    stopLoadRequest();
}

void ScriptElement::insertedInto(Node* insertionPoint)
{
    if (insertionPoint->inDocument() && !m_parserInserted)
        prepareScript(); // FIXME: Provide a real starting line number here.
}





class CachedScript;
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 childrenChanged();
    void handleSourceAttribute(const String& sourceUrl);
    void handleAsyncAttribute();



#include "ShadowTree.h"

#include "CSSStyleSelector.h"
#include "ContainerNodeAlgorithms.h"
#include "Document.h"
#include "Element.h"
#include "HTMLShadowElement.h"


namespace WebCore {

class ShadowRootVector : public Vector<RefPtr<ShadowRoot> > {
public:
    explicit ShadowRootVector(ShadowTree* tree)
    {
        for (ShadowRoot* root = tree->youngestShadowRoot(); root; root = root->olderShadowRoot())
            append(root);
    }
};

ShadowTree::ShadowTree()
    : m_needsRecalculateContent(false)
{

        return;

    shadowRoot->setShadowHost(shadowHost);
    ChildNodeInsertionNotifier(shadowHost).notify(shadowRoot.get());

    if (shadowHost->inDocument())
        shadowRoot->insertedIntoDocument();
    if (shadowHost->attached()) {
        shadowRoot->lazyAttach();
        detach();

        oldRoot->setPrev(0);
        oldRoot->setNext(0);
        shadowHost->document()->adoptIfNeeded(oldRoot.get());
        ChildNodeRemovalNotifier(shadowHost).notify(oldRoot.get());
            oldRoot->removedFromDocument();
        else
            oldRoot->removedFromTree(true);
    }

    if (shadowHost->attached())
        shadowHost->attachChildrenLazily();
}

void ShadowTree::insertedIntoDocument()
{
    ShadowRootVector roots(this);
    for (size_t i = 0; i < roots.size(); ++i)
        roots[i]->insertedIntoDocument();
}

void ShadowTree::removedFromDocument()
{
    ShadowRootVector roots(this);
    for (size_t i = 0; i < roots.size(); ++i)
        roots[i]->removedFromDocument();
}

void ShadowTree::insertedIntoTree(bool deep)
{
    ShadowRootVector roots(this);
    for (size_t i = 0; i < roots.size(); ++i)
        roots[i]->insertedIntoTree(deep);
}

void ShadowTree::removedFromTree(bool deep)
{
    ShadowRootVector roots(this);
    for (size_t i = 0; i < roots.size(); ++i)
        roots[i]->removedFromTree(deep);
}

void ShadowTree::willRemove()
{
    ShadowRootVector roots(this);



#include <wtf/Noncopyable.h>
#include <wtf/OwnPtr.h>
#include <wtf/PassRefPtr.h>
#include <wtf/Vector.h>

namespace WebCore {


    void addShadowRoot(Element* shadowHost, PassRefPtr<ShadowRoot>, ExceptionCode&);
    void removeAllShadowRoots();

    void insertedIntoDocument();
    void removedFromDocument();
    void insertedIntoTree(bool deep);
    void removedFromTree(bool deep);
    void willRemove();

    void setParentTreeScope(TreeScope*);

    return youngestShadowRoot()->host();
}

class ShadowRootVector : public Vector<RefPtr<ShadowRoot> > {
public:
    explicit ShadowRootVector(ShadowTree* tree)
    {
        for (ShadowRoot* root = tree->youngestShadowRoot(); root; root = root->olderShadowRoot())
            append(root);
    }
};

} // namespace

#endif

Lines 60-77 void FormAssociatedElement::didMoveToNewDocument(Document* oldDocument) a/Source/WebCore/html/FormAssociatedElement.cpp_sec1
- a/Source/WebCore/html/FormAssociatedElement.cpp -27 / +12 lines
60	oldDocument->unregisterFormElementWithFormAttribute(this);	60	oldDocument->unregisterFormElementWithFormAttribute(this);
61	}	61	}
62		62
63	void FormAssociatedElement::insertedIntoDocument()	63	void FormAssociatedElement::insertedInto(Node* insertionPoint)
64	{	64	{
		65	resetFormOwner();
		66	if (!insertionPoint->inDocument())
		67	return;
		68
65	HTMLElement* element = toHTMLElement(this);	69	HTMLElement* element = toHTMLElement(this);
66	if (element->fastHasAttribute(formAttr))	70	if (element->fastHasAttribute(formAttr))
67	element->document()->registerFormElementWithFormAttribute(this);	71	element->document()->registerFormElementWithFormAttribute(this);
68	}	72	}
69		73
70	void FormAssociatedElement::removedFromDocument()	74	void FormAssociatedElement::removedFrom(Node* insertionPoint)
71	{	75	{
72	HTMLElement* element = toHTMLElement(this);	76	HTMLElement* element = toHTMLElement(this);
73	if (element->fastHasAttribute(formAttr))	77	if (insertionPoint->inDocument() && element->fastHasAttribute(formAttr))
74	element->document()->unregisterFormElementWithFormAttribute(this);	78	element->document()->unregisterFormElementWithFormAttribute(this);
		79	// If the form and element are both in the same tree, preserve the connection to the form.
		80	// Otherwise, null out our form and remove ourselves from the form's list of elements.
		81	if (m_form && element->highestAncestor() != m_form->highestAncestor())
		82	setForm(0);
75	}	83	}
76		84
77	HTMLFormElement* FormAssociatedElement::findAssociatedForm(const HTMLElement* element, HTMLFormElement* currentAssociatedForm)	85	HTMLFormElement* FormAssociatedElement::findAssociatedForm(const HTMLElement* element, HTMLFormElement* currentAssociatedForm)
Lines 95-127 HTMLFormElement* FormAssociatedElement::findAssociatedForm(const HTMLElement* el a/Source/WebCore/html/FormAssociatedElement.cpp_sec2
95	return currentAssociatedForm;	103	return currentAssociatedForm;
96	}	104	}
97		105
98	void FormAssociatedElement::insertedIntoTree()
99	{
100	resetFormOwner();
101	}
102
103	static inline Node* findRoot(Node* n)
104	{
105	Node* root = n;
106	for (; n; n = n->parentNode())
107	root = n;
108	return root;
109	}
110
111	void FormAssociatedElement::removedFromTree()
112	{
113	HTMLElement* element = toHTMLElement(this);
114
115	// If the form and element are both in the same tree, preserve the connection to the form.
116	// Otherwise, null out our form and remove ourselves from the form's list of elements.
117	if (m_form && findRoot(element) != findRoot(m_form))
118	setForm(0);
119	}
120
121	void FormAssociatedElement::formRemovedFromTree(const Node* formRoot)	106	void FormAssociatedElement::formRemovedFromTree(const Node* formRoot)
122	{	107	{
123	ASSERT(m_form);	108	ASSERT(m_form);
124	if (findRoot(toHTMLElement(this)) != formRoot)	109	if (toHTMLElement(this)->highestAncestor() != formRoot)
125	setForm(0);	110	setForm(0);
126	}	111	}
127		112



protected:
    FormAssociatedElement();

    void insertedInto(Node*);
    void removedFrom(Node*);
    void insertedIntoDocument();
    void removedFromDocument();
    void didMoveToNewDocument(Document* oldDocument);

    void setForm(HTMLFormElement*);



        HTMLElement::parseAttribute(attribute);
}

Node::InsertionNotificationRequest HTMLBaseElement::insertedInto(Node* insertionPoint)
{
    HTMLElement::insertedInto(insertionPoint);
    if (insertionPoint->inDocument())
        document()->processBaseElement();
    return InsertionDone;
}

void HTMLBaseElement::removedFrom(Node* insertionPoint)
{
    HTMLElement::removedFrom(insertionPoint);
    if (insertionPoint->inDocument())
        document()->processBaseElement();
}

bool HTMLBaseElement::isURLAttribute(Attribute* attribute) const



    virtual String target() const;
    virtual bool isURLAttribute(Attribute*) const;
    virtual void parseAttribute(Attribute*) OVERRIDE;
    virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
    virtual void removedFrom(Node*) OVERRIDE;
};

} // namespace

Lines 152-161 void HTMLBodyElement::parseAttribute(Attribute* attr) a/Source/WebCore/html/HTMLBodyElement.cpp_sec1
- a/Source/WebCore/html/HTMLBodyElement.cpp -2 / +9 lines
152	HTMLElement::parseAttribute(attr);	152	HTMLElement::parseAttribute(attr);
153	}	153	}
154		154
155	void HTMLBodyElement::insertedIntoDocument()	155	Node::InsertionNotificationRequest HTMLBodyElement::insertedInto(Node* insertionPoint)
156	{	156	{
157	HTMLElement::insertedIntoDocument();	157	HTMLElement::insertedInto(insertionPoint);
		158	if (insertionPoint->inDocument())
		159	return InsertionShouldCallDidNotifyDescendantInseretions;
		160	return InsertionDone;
		161	}
158		162
		163	void HTMLBodyElement::didNotifyDescendantInseretions(Node* insertionPoint)
		164	{
		165	ASSERT_UNUSED(insertionPoint, insertionPoint->inDocument());
159	ASSERT(document());	166	ASSERT(document());
160		167
161	// FIXME: Perhaps this code should be in attach() instead of here.	168	// FIXME: Perhaps this code should be in attach() instead of here.



    virtual bool isPresentationAttribute(const QualifiedName&) const OVERRIDE;
    virtual void collectStyleForAttribute(Attribute*, StylePropertySet*) OVERRIDE;

    virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
    virtual void didNotifyDescendantInseretions(Node*) OVERRIDE;
    
    virtual bool isURLAttribute(Attribute*) const;
    



    HTMLElement::didMoveToNewDocument(oldDocument);
}

Node::InsertionNotificationRequest HTMLFormControlElement::insertedInto(Node* insertionPoint)
{
    HTMLElement::insertedInto(insertionPoint);
    FormAssociatedElement::insertedInto(insertionPoint);
    return InsertionDone;
}

void HTMLFormControlElement::removedFrom(Node* insertionPoint)
{
    m_fieldSetAncestorValid = false;
    HTMLElement::removedFrom(insertionPoint);
    FormAssociatedElement::removedFrom(insertionPoint);
}

void HTMLFormControlElement::insertedIntoDocument()
{
    HTMLElement::insertedIntoDocument();
    FormAssociatedElement::insertedIntoDocument();
}

void HTMLFormControlElement::removedFromDocument()
{
    HTMLElement::removedFromDocument();
    FormAssociatedElement::removedFromDocument();
}

const AtomicString& HTMLFormControlElement::formControlName() const



    virtual void requiredAttributeChanged();
    virtual void disabledAttributeChanged();
    virtual void attach();
    virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
    virtual void removedFrom(Node*) OVERRIDE;
    virtual void insertedIntoDocument();
    virtual void removedFromDocument();
    virtual void didMoveToNewDocument(Document* oldDocument) OVERRIDE;

    virtual bool supportsFocus() const;



    return formIsTablePart;
}

Node::InsertionNotificationRequest HTMLFormElement::insertedInto(Node* insertionPoint)
{
    HTMLElement::insertedInto(insertionPoint);
    if (insertionPoint->inDocument())
        return InsertionShouldCallDidNotifyDescendantInseretions;
    return InsertionDone;
}

void HTMLFormElement::didNotifyDescendantInseretions(Node* insertionPoint)
{
    ASSERT(insertionPoint->inDocument());
    HTMLElement::didNotifyDescendantInseretions(insertionPoint);
    if (hasID())
        document()->resetFormElementsOwner();
}

    return root;
}

void HTMLFormElement::removedFrom(Node* insertionPoint)
{
    Node* root = findRoot(this);
    Vector<FormAssociatedElement*> associatedElements(m_associatedElements);
    for (unsigned i = 0; i < associatedElements.size(); ++i)
        associatedElements[i]->formRemovedFromTree(root);
    HTMLElement::removedFrom(insertionPoint);
    if (insertionPoint->inDocument() && hasID())
        document()->resetFormElementsOwner();
}

void HTMLFormElement::handleLocalEvents(Event* event)



    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 void handleLocalEvents(Event*);




    openURL();
}

Node::InsertionNotificationRequest HTMLFrameElementBase::insertedInto(Node* insertionPoint)
{
    HTMLFrameOwnerElement::insertedInto(insertionPoint);
    if (insertionPoint->inDocument())
        return InsertionShouldCallDidNotifyDescendantInseretions;
    return InsertionDone;
}

void HTMLFrameElementBase::didNotifyDescendantInseretions(Node* insertionPoint)
{
    ASSERT_UNUSED(insertionPoint, insertionPoint->inDocument());

    // DocumentFragments don't kick of any loads.
    if (!document()->frame())

    // during attribute parsing *before* the normal parser machinery would
    // attach the element. To support this, we lazyAttach here, but only
    // if we don't already have a renderer (if we're inserted
    // as part of a DocumentFragment, insertedInto from an earlier element
    // could have forced a style resolve and already attached us).
    if (!renderer())
        lazyAttach(DoNotSetAttached);



    bool isURLAllowed() const;

    virtual void parseAttribute(Attribute*) OVERRIDE;
    virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
    virtual void didNotifyDescendantInseretions(Node*) OVERRIDE;
    virtual void attach();

private:

Lines 210-227 bool HTMLFrameSetElement::willRecalcStyle(StyleChange) a/Source/WebCore/html/HTMLFrameSetElement.cpp_sec1
- a/Source/WebCore/html/HTMLFrameSetElement.cpp -8 / +14 lines
210	return true;	210	return true;
211	}	211	}
212		212
213	void HTMLFrameSetElement::insertedIntoDocument()	213	Node::InsertionNotificationRequest HTMLFrameSetElement::insertedInto(Node* insertionPoint)
214	{	214	{
215	HTMLElement::insertedIntoDocument();	215	HTMLElement::insertedInto(insertionPoint);
216	if (Frame* frame = document()->frame())	216	if (insertionPoint->inDocument()) {
217	frame->loader()->client()->dispatchDidBecomeFrameset(document()->isFrameSet());	217	if (Frame* frame = document()->frame())
		218	frame->loader()->client()->dispatchDidBecomeFrameset(document()->isFrameSet());
		219	}
		220
		221	return InsertionDone;
218	}	222	}
219		223
220	void HTMLFrameSetElement::removedFromDocument()	224	void HTMLFrameSetElement::removedFrom(Node* insertionPoint)
221	{	225	{
222	HTMLElement::removedFromDocument();	226	HTMLElement::removedFrom(insertionPoint);
223	if (Frame* frame = document()->frame())	227	if (insertionPoint->inDocument()) {
224	frame->loader()->client()->dispatchDidBecomeFrameset(document()->isFrameSet());	228	if (Frame* frame = document()->frame())
		229	frame->loader()->client()->dispatchDidBecomeFrameset(document()->isFrameSet());
		230	}
225	}	231	}
226		232
227	} // namespace WebCore	233	} // namespace WebCore




    virtual bool willRecalcStyle(StyleChange);

    virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
    virtual void removedFrom(Node*) OVERRIDE;

    OwnArrayPtr<Length> m_rowLengths;
    OwnArrayPtr<Length> m_colLengths;



    return new (arena) RenderIFrame(this);
}

Node::InsertionNotificationRequest HTMLIFrameElement::insertedInto(Node* insertionPoint)
{
    InsertionNotificationRequest result = HTMLFrameElementBase::insertedInto(insertionPoint);
    if (insertionPoint->inDocument() && document()->isHTMLDocument())
        static_cast<HTMLDocument*>(document())->addExtraNamedItem(m_name);
    return result;
    HTMLFrameElementBase::insertedIntoDocument();
}

void HTMLIFrameElement::removedFrom(Node* insertionPoint)
{
    HTMLFrameElementBase::removedFrom(insertionPoint);
    if (insertionPoint->inDocument() && document()->isHTMLDocument())
        static_cast<HTMLDocument*>(document())->removeExtraNamedItem(m_name);

    HTMLFrameElementBase::removedFromDocument();
}

#if ENABLE(MICRODATA)



    virtual bool isPresentationAttribute(const QualifiedName&) const OVERRIDE;
    virtual void collectStyleForAttribute(Attribute*, StylePropertySet*) OVERRIDE;

    virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
    virtual void removedFrom(Node*) OVERRIDE;
    
    virtual bool rendererIsNeeded(const NodeRenderingContext&);
    virtual RenderObject* createRenderer(RenderArena*, RenderStyle*);



    }
}

Node::InsertionNotificationRequest HTMLImageElement::insertedInto(Node* insertionPoint)
{
    // If we have been inserted from a renderer-less document,
    // our loader may have not fetched the image, so do it now.
    if (!m_imageLoader.image())
        m_imageLoader.updateFromElement();

    HTMLElement::insertedIntoDocument();
}

void HTMLImageElement::insertedIntoTree(bool deep)
{
    if (!m_form) {
        // m_form can be non-null if it was set in constructor.

        }
    }

    // If we have been inserted from a renderer-less document,
    // our loader may have not fetched the image, so do it now.
    if (insertionPoint->inDocument() && !m_imageLoader.image())
        m_imageLoader.updateFromElement();

    return HTMLElement::insertedInto(insertionPoint);
}

void HTMLImageElement::removedFrom(Node* insertionPoint)
{
    if (m_form)
        m_form->removeImgElement(this);
    m_form = 0;
    HTMLElement::removedFrom(insertionPoint);
}

int HTMLImageElement::width(bool ignorePendingStylesheets)




    virtual void addSubresourceAttributeURLs(ListHashSet<KURL>&) const;

    virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
    virtual void removedFrom(Node*) OVERRIDE;
    virtual void removedFromTree(bool deep);

    virtual bool shouldRegisterAsNamedItem() const OVERRIDE { return true; }
    virtual bool shouldRegisterAsExtraNamedItem() const OVERRIDE { return true; }




    addToRadioButtonGroup();
}

Node::InsertionNotificationRequest HTMLInputElement::insertedInto(Node* insertionPoint)
{
    HTMLTextFormControlElement::insertedInto(insertionPoint);
    if (!insertionPoint->inDocument())
        return InsertionDone;
    ASSERT(inDocument());
    addToRadioButtonGroup();
    return InsertionDone;
}

void HTMLInputElement::removedFrom(Node* insertionPoint)
{
    if (insertionPoint->inDocument())
        removeFromRadioButtonGroup();
    HTMLTextFormControlElement::removedFrom(insertionPoint);
}

void HTMLInputElement::didMoveToNewDocument(Document* oldDocument)




    virtual void willChangeForm() OVERRIDE;
    virtual void didChangeForm() OVERRIDE;
    virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
    virtual void removedFrom(Node*) OVERRIDE;
    virtual void didMoveToNewDocument(Document* oldDocument) OVERRIDE;

    virtual bool isKeyboardFocusable(KeyboardEvent*) const;

Lines 243-264 void HTMLLinkElement::clearSheet() a/Source/WebCore/html/HTMLLinkElement.cpp_sec1
- a/Source/WebCore/html/HTMLLinkElement.cpp -5 / +10 lines
243	m_sheet = 0;	243	m_sheet = 0;
244	}	244	}
245		245
246	void HTMLLinkElement::insertedIntoDocument()	246	Node::InsertionNotificationRequest HTMLLinkElement::insertedInto(Node* insertionPoint)
247	{	247	{
248	HTMLElement::insertedIntoDocument();	248	HTMLElement::insertedInto(insertionPoint);
		249	if (!insertionPoint->inDocument())
		250	return InsertionDone;
249		251
250	m_isInShadowTree = isInShadowTree();	252	m_isInShadowTree = isInShadowTree();
251	if (m_isInShadowTree)	253	if (m_isInShadowTree)
252	return;	254	return InsertionDone;
253		255
254	document()->addStyleSheetCandidateNode(this, m_createdByParser);	256	document()->addStyleSheetCandidateNode(this, m_createdByParser);
255		257
256	process();	258	process();
		259	return InsertionDone;
257	}	260	}
258		261
259	void HTMLLinkElement::removedFromDocument()	262	void HTMLLinkElement::removedFrom(Node* insertionPoint)
260	{	263	{
261	HTMLElement::removedFromDocument();	264	HTMLElement::removedFrom(insertionPoint);
		265	if (!insertionPoint->inDocument())
		266	return;
262		267
263	if (m_isInShadowTree) {	268	if (m_isInShadowTree) {
264	ASSERT(!m_sheet);	269	ASSERT(!m_sheet);



    static void processCallback(Node*);
    void clearSheet();

    virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
    virtual void removedFrom(Node*) 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)
{
    if (insertionPoint->inDocument())
        treeScope()->addImageMap(this);
    return HTMLElement::insertedInto(insertionPoint);
}

void HTMLMapElement::removedFrom(Node* insertionPoint)
{
    if (insertionPoint->inDocument())
        treeScope()->removeImageMap(this);
    HTMLElement::removedFrom(insertionPoint);
}

}




    virtual void parseAttribute(Attribute*) OVERRIDE;

    virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
    virtual void removedFrom(Node*) OVERRIDE;

    AtomicString m_name;
};



    return childContext.isOnUpperEncapsulationBoundary() && HTMLElement::childShouldCreateRenderer(childContext);
}

Node::InsertionNotificationRequest HTMLMediaElement::insertedInto(Node* insertionPoint)
{
    LOG(Media, "HTMLMediaElement::insertedInto");
    HTMLElement::insertedInto(insertionPoint);
    if (insertionPoint->inDocument() && !getAttribute(srcAttr).isEmpty() && m_networkState == NETWORK_EMPTY)
        scheduleLoad(MediaResource);
    return InsertionDone;
}

void HTMLMediaElement::removedFrom(Node* insertionPoint)
{
    if (insertionPoint->inDocument()) {
        LOG(Media, "HTMLMediaElement::removedFromDocument");
        if (m_networkState > NETWORK_EMPTY)
            pause();
        if (m_isFullscreen)
            exitFullscreen();
    }

    HTMLElement::removedFrom(insertionPoint);
}

void HTMLMediaElement::attach()



    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 void didRecalcStyle(StyleChange);
    
    virtual void defaultEventHandler(Event*);

Lines 54-63 void HTMLMetaElement::parseAttribute(Attribute* attr) a/Source/WebCore/html/HTMLMetaElement.cpp_sec1
- a/Source/WebCore/html/HTMLMetaElement.cpp -3 / +5 lines
54	HTMLElement::parseAttribute(attr);	54	HTMLElement::parseAttribute(attr);
55	}	55	}
56		56
57	void HTMLMetaElement::insertedIntoDocument()	57	Node::InsertionNotificationRequest HTMLMetaElement::insertedInto(Node* insertionPoint)
58	{	58	{
59	HTMLElement::insertedIntoDocument();	59	HTMLElement::insertedInto(insertionPoint);
60	process();	60	if (insertionPoint->inDocument())
		61	process();
		62	return InsertionDone;
61	}	63	}
62		64
63	void HTMLMetaElement::process()	65	void HTMLMetaElement::process()

Lines 39-45 private: a/Source/WebCore/html/HTMLMetaElement.h_sec1
- a/Source/WebCore/html/HTMLMetaElement.h -1 / +1 lines
39	HTMLMetaElement(const QualifiedName&, Document*);	39	HTMLMetaElement(const QualifiedName&, Document*);
40		40
41	virtual void parseAttribute(Attribute*) OVERRIDE;	41	virtual void parseAttribute(Attribute*) OVERRIDE;
42	virtual void insertedIntoDocument();	42	virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
43		43
44	void process();	44	void process();
45		45



    return HTMLPlugInImageElement::rendererIsNeeded(context);
}

Node::InsertionNotificationRequest HTMLObjectElement::insertedInto(Node* insertionPoint)
{
    HTMLPlugInImageElement::insertedInto(insertionPoint);
    FormAssociatedElement::insertedInto(insertionPoint);
    return InsertionDone;
}

void HTMLObjectElement::removedFrom(Node* insertionPoint)
{
    HTMLPlugInImageElement::removedFrom(insertionPoint);
    FormAssociatedElement::removedFrom(insertionPoint);
}

void HTMLObjectElement::childrenChanged(bool changedByParser, Node* beforeChange, Node* afterChange, int childCountDelta)

    HTMLPlugInImageElement::didMoveToNewDocument(oldDocument);
}

void HTMLObjectElement::insertedIntoTree(bool deep)
{
    FormAssociatedElement::insertedIntoTree();
    HTMLPlugInImageElement::insertedIntoTree(deep);
}

void HTMLObjectElement::removedFromTree(bool deep)
{
    FormAssociatedElement::removedFromTree();
    HTMLPlugInImageElement::removedFromTree(deep);
}

bool HTMLObjectElement::appendFormData(FormDataList& encoding, bool)
{
    if (name().isEmpty())



    virtual bool isPresentationAttribute(const QualifiedName&) const OVERRIDE;
    virtual void collectStyleForAttribute(Attribute*, StylePropertySet*) OVERRIDE;

    virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
    virtual void removedFrom(Node*) OVERRIDE;

    virtual bool rendererIsNeeded(const NodeRenderingContext&);
    virtual void insertedIntoDocument();
    virtual void removedFromDocument();
    virtual void didMoveToNewDocument(Document* oldDocument) OVERRIDE;

    virtual void childrenChanged(bool changedByParser = false, Node* beforeChange = 0, Node* afterChange = 0, int childCountDelta = 0);



    return ownElementDisabled() || (parentNode() && parentNode()->isHTMLElement() && static_cast<HTMLElement*>(parentNode())->disabled());
}

Node::InsertionNotificationRequest HTMLOptionElement::insertedInto(Node* insertionPoint)
{
    if (HTMLSelectElement* select = ownerSelectElement()) {
        select->setRecalcListItems();

        select->scrollToSelection();
    }

    return HTMLElement::insertedInto(insertionPoint);
}

String HTMLOptionElement::collectOptionInnerText() const

Lines 75-81 private: a/Source/WebCore/html/HTMLOptionElement.h_sec1
- a/Source/WebCore/html/HTMLOptionElement.h -1 / +1 lines
75		75
76	virtual void parseAttribute(Attribute*) OVERRIDE;	76	virtual void parseAttribute(Attribute*) OVERRIDE;
77		77
78	virtual void insertedIntoTree(bool);	78	virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
79	virtual void accessKeyAction(bool);	79	virtual void accessKeyAction(bool);
80		80
81	virtual void childrenChanged(bool changedByParser = false, Node* beforeChange = 0, Node* afterChange = 0, int childCountDelta = 0);	81	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)
{
    if (hasTagName(qTag))
        document()->setUsesBeforeAfterRules(true);

    return HTMLElement::insertedInto(insertionPoint);
}

bool HTMLQuoteElement::isURLAttribute(Attribute* attribute) const

Lines 36-42 public: a/Source/WebCore/html/HTMLQuoteElement.h_sec1
- a/Source/WebCore/html/HTMLQuoteElement.h -1 / +1 lines
36	private:	36	private:
37	HTMLQuoteElement(const QualifiedName&, Document*);	37	HTMLQuoteElement(const QualifiedName&, Document*);
38		38
39	virtual void insertedIntoDocument();	39	virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
40	virtual bool isURLAttribute(Attribute*) const;	40	virtual bool isURLAttribute(Attribute*) const;
41	};	41	};
42		42



        HTMLElement::parseAttribute(attr);
}

Node::InsertionNotificationRequest HTMLScriptElement::insertedInto(Node* insertionPoint)
{
    HTMLElement::insertedInto(insertionPoint);
    ScriptElement::insertedInto(insertionPoint);
    return InsertionDone;
}

void HTMLScriptElement::setText(const String &value)

Lines 45-51 private: a/Source/WebCore/html/HTMLScriptElement.h_sec1
- a/Source/WebCore/html/HTMLScriptElement.h -1 / +1 lines
45	HTMLScriptElement(const QualifiedName&, Document*, bool wasInsertedByParser, bool alreadyStarted);	45	HTMLScriptElement(const QualifiedName&, Document*, bool wasInsertedByParser, bool alreadyStarted);
46		46
47	virtual void parseAttribute(Attribute*) OVERRIDE;	47	virtual void parseAttribute(Attribute*) OVERRIDE;
48	virtual void insertedIntoDocument();	48	virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
49	virtual void childrenChanged(bool changedByParser = false, Node* beforeChange = 0, Node* afterChange = 0, int childCountDelta = 0);	49	virtual void childrenChanged(bool changedByParser = false, Node* beforeChange = 0, Node* afterChange = 0, int childCountDelta = 0);
50		50
51	virtual bool isURLAttribute(Attribute*) const;	51	virtual bool isURLAttribute(Attribute*) const;



    }
}

Node::InsertionNotificationRequest HTMLSelectElement::insertedInto(Node* 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
    // after the whole subtree is constructed.
    recalcListItems();
    HTMLFormControlElementWithState::insertedInto(insertionPoint);
    return InsertionDone;
}

void HTMLSelectElement::accessKeySetSelectedIndex(int index)

Lines 142-148 private: a/Source/WebCore/html/HTMLSelectElement.h_sec1
- a/Source/WebCore/html/HTMLSelectElement.h -1 / +1 lines
142	void typeAheadFind(KeyboardEvent*);	142	void typeAheadFind(KeyboardEvent*);
143	void saveLastSelection();	143	void saveLastSelection();
144		144
145	virtual void insertedIntoTree(bool);	145	virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
146		146
147	virtual bool isOptionalFormControl() const { return !isRequiredFormControl(); }	147	virtual bool isOptionalFormControl() const { return !isRequiredFormControl(); }
148	virtual bool isRequiredFormControl() const;	148	virtual bool isRequiredFormControl() const;



    return adoptRef(new HTMLSourceElement(tagName, document));
}

Node::InsertionNotificationRequest HTMLSourceElement::insertedInto(Node* insertionPoint)
{
    HTMLElement::insertedInto(insertionPoint);
    Element* parent = parentElement();
    if (parent && parent->isMediaElement())
        static_cast<HTMLMediaElement*>(parentNode())->sourceWasAdded(this);
    return InsertionDone;
}

void HTMLSourceElement::willRemove()

Lines 49-55 public: a/Source/WebCore/html/HTMLSourceElement.h_sec1
- a/Source/WebCore/html/HTMLSourceElement.h -1 / +1 lines
49	private:	49	private:
50	HTMLSourceElement(const QualifiedName&, Document*);	50	HTMLSourceElement(const QualifiedName&, Document*);
51		51
52	virtual void insertedIntoTree(bool);	52	virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
53	virtual void willRemove();	53	virtual void willRemove();
54	virtual bool isURLAttribute(Attribute*) const;	54	virtual bool isURLAttribute(Attribute*) const;
55		55



}
#endif

Node::InsertionNotificationRequest HTMLStyleElement::insertedInto(Node* insertionPoint)
{
    HTMLElement::insertedInto(insertionPoint);
    if (insertionPoint->inDocument())
        StyleElement::insertedIntoDocument(document(), this);
#if ENABLE(STYLE_SCOPED)
    if (scoped() && !m_isRegisteredWithScopingNode)
        registerWithScopingNode();
#endif
    return InsertionDone;
}

void HTMLStyleElement::removedFrom(Node* insertionPoint)
{
    HTMLElement::removedFrom(insertionPoint);

    if (insertionPoint->inDocument()) {
#if ENABLE(STYLE_SCOPED)
        // In come cases on teardown willRemove is not called - test here for unregistering again
        // FIXME: Do we need to bother?
        if (m_isRegisteredWithScopingNode)
            unregisterWithScopingNode();
#endif
        StyleElement::removedFromDocument(document(), this);
    }
}






    // overload from HTMLElement
    virtual void parseAttribute(Attribute*) OVERRIDE;
    virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
    virtual void removedFrom(Node*) OVERRIDE;
#if ENABLE(STYLE_SCOPED)
    virtual void willRemove();
#endif

Lines 70-80 bool HTMLTextFormControlElement::childShouldCreateRenderer(const NodeRenderingCo a/Source/WebCore/html/HTMLTextFormControlElement.cpp_sec1
- a/Source/WebCore/html/HTMLTextFormControlElement.cpp -2 / +5 lines
70	return childContext.isOnEncapsulationBoundary() && HTMLFormControlElementWithState::childShouldCreateRenderer(childContext);	70	return childContext.isOnEncapsulationBoundary() && HTMLFormControlElementWithState::childShouldCreateRenderer(childContext);
71	}	71	}
72		72
73	void HTMLTextFormControlElement::insertedIntoDocument()	73	Node::InsertionNotificationRequest HTMLTextFormControlElement::insertedInto(Node* insertionPoint)
74	{	74	{
75	HTMLFormControlElement::insertedIntoDocument();	75	HTMLFormControlElement::insertedInto(insertionPoint);
		76	if (!insertionPoint->inDocument())
		77	return InsertionDone;
76	String initialValue = value();	78	String initialValue = value();
77	setTextAsOfLastFormControlChangeEvent(initialValue.isNull() ? emptyString() : initialValue);	79	setTextAsOfLastFormControlChangeEvent(initialValue.isNull() ? emptyString() : initialValue);
		80	return InsertionDone;
78	}	81	}
79		82
80	void HTMLTextFormControlElement::dispatchFocusEvent(PassRefPtr<Node> oldFocusedNode)	83	void HTMLTextFormControlElement::dispatchFocusEvent(PassRefPtr<Node> oldFocusedNode)




    void forwardEvent(Event*);


    virtual InsertionNotificationRequest insertedInto(Node*) 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)
{
    HTMLElement::insertedInto(insertionPoint);
    if (insertionPoint->inDocument())
        document()->setTitleElement(m_title, this);
    return InsertionDone;
}

void HTMLTitleElement::removedFrom(Node* insertionPoint)
{
    HTMLElement::removedFrom(insertionPoint);
    if (insertionPoint->inDocument())
        document()->removeTitle(this);
}

void HTMLTitleElement::childrenChanged(bool changedByParser, Node* beforeChange, Node* afterChange, int childCountDelta)



private:
    HTMLTitleElement(const QualifiedName&, Document*);

    virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
    virtual void removedFrom(Node*) 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)
{
    HTMLElement::insertedInto(insertionPoint);

    if (HTMLMediaElement* parent = mediaElement())
        parent->didAddTrack(this);
    return InsertionDone;
}

void HTMLTrackElement::willRemove()

Lines 77-83 private: a/Source/WebCore/html/HTMLTrackElement.h_sec1
- a/Source/WebCore/html/HTMLTrackElement.h -1 / +1 lines
77		77
78	virtual void parseAttribute(Attribute*) OVERRIDE;	78	virtual void parseAttribute(Attribute*) OVERRIDE;
79		79
80	virtual void insertedIntoTree(bool) OVERRIDE;	80	virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
81	virtual void willRemove() OVERRIDE;	81	virtual void willRemove() OVERRIDE;
82	virtual bool isURLAttribute(Attribute*) const;	82	virtual bool isURLAttribute(Attribute*) const;
83		83



#if ENABLE(MATHML)

#include "MathMLMathElement.h"

#include "RenderMathMLMath.h"

namespace WebCore {

    return adoptRef(new MathMLMathElement(tagName, document));
}

Node::InsertionNotificationRequest MathMLMathElement::insertedInto(Node* insertionPoint)
{
    // There are sibling rules in the MathML default style.
    if (insertionPoint->inDocument())
        document()->setUsesSiblingRules(true);
    return MathMLInlineContainerElement::insertedInto(insertionPoint);
}

RenderObject* MathMLMathElement::createRenderer(RenderArena* arena, RenderStyle*)

Lines 39-45 public: a/Source/WebCore/mathml/MathMLMathElement.h_sec1
- a/Source/WebCore/mathml/MathMLMathElement.h -1 / +1 lines
39	private:	39	private:
40	MathMLMathElement(const QualifiedName& tagName, Document*);	40	MathMLMathElement(const QualifiedName& tagName, Document*);
41		41
42	virtual void insertedIntoDocument();	42	virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
43	virtual RenderObject* createRenderer(RenderArena, RenderStyle);	43	virtual RenderObject* createRenderer(RenderArena, RenderStyle);
44	};	44	};
45		45

Lines 169-179 void SVGElement::setXmlbase(const String& value, ExceptionCode&) a/Source/WebCore/svg/SVGElement.cpp_sec1
- a/Source/WebCore/svg/SVGElement.cpp -4 / +7 lines
169	setAttribute(XMLNames::baseAttr, value);	169	setAttribute(XMLNames::baseAttr, value);
170	}	170	}
171		171
172	void SVGElement::removedFromDocument()	172	void SVGElement::removedFrom(Node* rootParent)
173	{	173	{
174	document()->accessSVGExtensions()->removeAllAnimationElementsFromTarget(this);	174	if (rootParent->inDocument()) {
175	document()->accessSVGExtensions()->removeAllElementReferencesForTarget(this);	175	document()->accessSVGExtensions()->removeAllAnimationElementsFromTarget(this);
176	StyledElement::removedFromDocument();	176	document()->accessSVGExtensions()->removeAllElementReferencesForTarget(this);
		177	}
		178
		179	StyledElement::removedFrom(rootParent);
177	}	180	}
178		181
179	SVGSVGElement* SVGElement::ownerSVGElement() const	182	SVGSVGElement* SVGElement::ownerSVGElement() const

Lines 121-127 protected: a/Source/WebCore/svg/SVGElement.h_sec1
- a/Source/WebCore/svg/SVGElement.h -1 / +1 lines
121	virtual void attributeChanged(Attribute*) OVERRIDE;	121	virtual void attributeChanged(Attribute*) OVERRIDE;
122	virtual bool childShouldCreateRenderer(const NodeRenderingContext&) const;	122	virtual bool childShouldCreateRenderer(const NodeRenderingContext&) const;
123		123
124	virtual void removedFromDocument();	124	virtual void removedFrom(Node*) OVERRIDE;
125		125
126	SVGElementRareData* rareSVGData() const;	126	SVGElementRareData* rareSVGData() const;
127	SVGElementRareData* ensureRareSVGData();	127	SVGElementRareData* ensureRareSVGData();



    ASSERT_NOT_REACHED();
}

Node::InsertionNotificationRequest SVGFEImageElement::insertedInto(Node* rootParent)
{
    SVGFilterPrimitiveStandardAttributes::insertedInto(rootParent);
    buildPendingResource();
    return InsertionDone;
}

void SVGFEImageElement::removedFrom(Node* rootParent)
{
    SVGFilterPrimitiveStandardAttributes::removedFrom(rootParent);
    if (rootParent->inDocument())
        clearResourceReferences();
}

void SVGFEImageElement::notifyFinished(CachedResource*)



    void requestImageResource();

    virtual void buildPendingResource();
    virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
    virtual void removedFrom(Node*) OVERRIDE;

    BEGIN_DECLARE_ANIMATED_PROPERTIES(SVGFEImageElement)
        DECLARE_ANIMATED_PRESERVEASPECTRATIO(PreserveAspectRatio, preserveAspectRatio)



    document()->styleSelectorChanged(DeferRecalcStyle);
}

Node::InsertionNotificationRequest SVGFontFaceElement::insertedInto(Node* rootParent)
{
    SVGElement::insertedInto(rootParent);
    if (!rootParent->inDocument())
        return InsertionDone;
    document()->accessSVGExtensions()->registerSVGFontFaceElement(this);

    rebuildFontFace();
    return InsertionDone;
}

void SVGFontFaceElement::removedFrom(Node* rootParent)
{
    SVGElement::removedFrom(rootParent);

    if (rootParent->inDocument()) {
        document()->accessSVGExtensions()->unregisterSVGFontFaceElement(this);
        m_fontFaceRule->properties()->parseDeclaration(emptyString(), 0);

        document()->styleSelectorChanged(DeferRecalcStyle);
    }
}

void SVGFontFaceElement::childrenChanged(bool changedByParser, Node* beforeChange, Node* afterChange, int childCountDelta)



    virtual void parseAttribute(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;

    RefPtr<StyleRuleFontFace> m_fontFaceRule;
    RefPtr<SVGFontElement> m_fontElement;



        static_cast<SVGFontFaceElement*>(grandparent)->rebuildFontFace();
}

Node::InsertionNotificationRequest SVGFontFaceUriElement::insertedInto(Node* rootParent)
{
    loadFont();
    return SVGElement::insertedInto(rootParent);
}

void SVGFontFaceUriElement::loadFont()

Lines 42-48 private: a/Source/WebCore/svg/SVGFontFaceUriElement.h_sec1
- a/Source/WebCore/svg/SVGFontFaceUriElement.h -1 / +1 lines
42		42
43	virtual void parseAttribute(Attribute*) OVERRIDE;	43	virtual void parseAttribute(Attribute*) OVERRIDE;
44	virtual void childrenChanged(bool changedByParser = false, Node* beforeChange = 0, Node* afterChange = 0, int childCountDelta = 0);	44	virtual void childrenChanged(bool changedByParser = false, Node* beforeChange = 0, Node* afterChange = 0, int childCountDelta = 0);
45	virtual void insertedIntoDocument();	45	virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
46		46
47	void loadFont();	47	void loadFont();
48		48



        SVGStyledElement::parseAttribute(attr);
}

Node::InsertionNotificationRequest SVGGlyphElement::insertedInto(Node* rootParent)
{
    invalidateGlyphCache();
    return SVGStyledElement::insertedInto(rootParent);
}

void SVGGlyphElement::removedFrom(Node* rootParent)
{
    if (rootParent->inDocument())
        invalidateGlyphCache();
    SVGStyledElement::removedFrom(rootParent);
}

static inline SVGGlyph::ArabicForm parseArabicForm(const AtomicString& value)



    // FIXME: svgAttributeChanged missing.
    virtual void parseAttribute(Attribute*) OVERRIDE;

    virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
    virtual void removedFrom(Node*) OVERRIDE;

    virtual bool rendererIsNeeded(const NodeRenderingContext&) { return false; }




    return adoptRef(new SVGHKernElement(tagName, document));
}

Node::InsertionNotificationRequest SVGHKernElement::insertedInto(Node* rootParent)
{
    ContainerNode* fontNode = parentNode();
    if (fontNode && fontNode->hasTagName(SVGNames::fontTag)) {
        if (SVGFontElement* element = static_cast<SVGFontElement*>(fontNode))
            element->invalidateGlyphCache();
    }

    return SVGElement::insertedInto(rootParent);
}

void SVGHKernElement::removedFrom(Node* rootParent)
{
    ContainerNode* fontNode = parentNode();
    if (fontNode && fontNode->hasTagName(SVGNames::fontTag)) {
        if (SVGFontElement* element = static_cast<SVGFontElement*>(fontNode))
            element->invalidateGlyphCache();
    }

    SVGElement::removedFrom(rootParent);
}

void SVGHKernElement::buildHorizontalKerningPair(KerningPairVector& kerningPairs)



private:
    SVGHKernElement(const QualifiedName&, Document*);

    virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
    virtual void removedFrom(Node*) OVERRIDE;

    virtual bool rendererIsNeeded(const NodeRenderingContext&) { return false; }
};



    }
}

Node::InsertionNotificationRequest SVGImageElement::insertedInto(Node* rootParent)
{
    SVGStyledTransformableElement::insertedInto(rootParent);
    if (!rootParent->inDocument())
        return InsertionDone;
    // Update image loader, as soon as we're living in the tree.
    // We can only resolve base URIs properly, after that!
    m_imageLoader.updateFromElement();
    return InsertionDone;
}

const QualifiedName& SVGImageElement::imageSourceAttributeName() const

Lines 55-61 private: a/Source/WebCore/svg/SVGImageElement.h_sec1
- a/Source/WebCore/svg/SVGImageElement.h -1 / +1 lines
55	virtual void svgAttributeChanged(const QualifiedName&);	55	virtual void svgAttributeChanged(const QualifiedName&);
56		56
57	virtual void attach();	57	virtual void attach();
58	virtual void insertedIntoDocument();	58	virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
59		59
60	virtual RenderObject* createRenderer(RenderArena, RenderStyle);	60	virtual RenderObject* createRenderer(RenderArena, RenderStyle);
61		61



    return new (arena) RenderSVGViewportContainer(this);
}

Node::InsertionNotificationRequest SVGSVGElement::insertedInto(Node* rootParent)
{
    if (rootParent->inDocument())
        document()->accessSVGExtensions()->addTimeContainer(this);
    return SVGStyledLocatableElement::insertedInto(rootParent);
}

void SVGSVGElement::removedFrom(Node* rootParent)
{
    if (rootParent->inDocument())
        document()->accessSVGExtensions()->removeTimeContainer(this);
    SVGStyledLocatableElement::removedFrom(rootParent);
}

void SVGSVGElement::pauseAnimations()



    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 void svgAttributeChanged(const QualifiedName&);


Lines 117-127 void SVGScriptElement::svgAttributeChanged(const QualifiedName& attrName) a/Source/WebCore/svg/SVGScriptElement.cpp_sec1
- a/Source/WebCore/svg/SVGScriptElement.cpp -4 / +6 lines
117	ASSERT_NOT_REACHED();	117	ASSERT_NOT_REACHED();
118	}	118	}
119		119
120	void SVGScriptElement::insertedIntoDocument()	120	Node::InsertionNotificationRequest SVGScriptElement::insertedInto(Node* rootParent)
121	{	121	{
122	SVGElement::insertedIntoDocument();	122	SVGElement::insertedInto(rootParent);
123	ScriptElement::insertedIntoDocument();	123	ScriptElement::insertedInto(rootParent);
124	SVGExternalResourcesRequired::insertedIntoDocument(this);	124	if (rootParent->inDocument())
		125	SVGExternalResourcesRequired::insertedIntoDocument(this);
		126	return InsertionDone;
125	}	127	}
126		128
127	void SVGScriptElement::childrenChanged(bool changedByParser, Node* beforeChange, Node* afterChange, int childCountDelta)	129	void SVGScriptElement::childrenChanged(bool changedByParser, Node* beforeChange, Node* afterChange, int childCountDelta)

Lines 46-52 private: a/Source/WebCore/svg/SVGScriptElement.h_sec1
- a/Source/WebCore/svg/SVGScriptElement.h -1 / +1 lines
46		46
47	bool isSupportedAttribute(const QualifiedName&);	47	bool isSupportedAttribute(const QualifiedName&);
48	virtual void parseAttribute(Attribute*) OVERRIDE;	48	virtual void parseAttribute(Attribute*) OVERRIDE;
49	virtual void insertedIntoDocument();	49	virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
50	virtual void childrenChanged(bool changedByParser = false, Node* beforeChange = 0, Node* afterChange = 0, int childCountDelta = 0);	50	virtual void childrenChanged(bool changedByParser = false, Node* beforeChange = 0, Node* afterChange = 0, int childCountDelta = 0);
51		51
52	virtual void svgAttributeChanged(const QualifiedName&);	52	virtual void svgAttributeChanged(const QualifiedName&);



    SVGElement::finishParsingChildren();
}

Node::InsertionNotificationRequest SVGStyleElement::insertedInto(Node* rootParent)
{
    SVGElement::insertedInto(rootParent);
    if (rootParent->inDocument())
        StyleElement::insertedIntoDocument(document(), this);
    return InsertionDone;
}

void SVGStyleElement::removedFrom(Node* rootParent)
{
    SVGElement::removedFrom(rootParent);
    if (rootParent->inDocument())
        StyleElement::removedFromDocument(document(), this);
}

void SVGStyleElement::childrenChanged(bool changedByParser, Node* beforeChange, Node* afterChange, int childCountDelta)




    bool isSupportedAttribute(const QualifiedName&);
    virtual void parseAttribute(Attribute*) OVERRIDE;
    virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
    virtual void removedFrom(Node*) 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)
{
    SVGElement::insertedInto(rootParent);
    updateRelativeLengthsInformation();
    buildPendingResourcesIfNeeded();
    return InsertionDone;
}

void SVGStyledElement::buildPendingResourcesIfNeeded()

    }
}

void SVGStyledElement::removedFrom(Node* rootParent)
{
    if (rootParent->inDocument())
        updateRelativeLengthsInformation(false, this);
    SVGElement::removedFrom(rootParent);
    SVGElementInstance::invalidateAllInstancesOfElement(this);

    Document* document = this->document();
    if (!rootParent->inDocument() || !needsPendingResourceHandling() || !document)
        return;

    document->accessSVGExtensions()->removeElementFromPendingResources(this);


void SVGStyledElement::updateRelativeLengthsInformation(bool hasRelativeLengths, SVGStyledElement* element)
{
    // If we're not yet in a document, this function will be called again from insertedInto(). Do nothing now.
    if (!inDocument())
        return;




    virtual void svgAttributeChanged(const QualifiedName&);

    virtual void attach();
    virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
    virtual void removedFrom(Node*) OVERRIDE;
    virtual void childrenChanged(bool changedByParser = false, Node* beforeChange = 0, Node* afterChange = 0, int childCountDelta = 0);

    static CSSPropertyID cssPropertyIdForSVGAttributeName(const QualifiedName&);



    // Remove any existing event listener.
    clearEventListener();

    // If we're not yet in a document, this function will be called again from insertedInto().
    if (!inDocument())
        return;


    target->addEventListener(eventNames().DOMNodeRemovedFromDocumentEvent, m_eventListener.get(), false);
}

Node::InsertionNotificationRequest SVGTRefElement::insertedInto(Node* rootParent)
{
    SVGStyledElement::insertedInto(rootParent);
    if (rootParent->inDocument())
        buildPendingResource();
    return InsertionDone;
}

void SVGTRefElement::removedFrom(Node* rootParent)
{
    SVGStyledElement::removedFrom(rootParent);
    if (rootParent->inDocument())
        clearEventListener();
}

void SVGTRefElement::clearEventListener()



    virtual bool childShouldCreateRenderer(const NodeRenderingContext&) const;
    virtual bool rendererIsNeeded(const NodeRenderingContext&);

    virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
    virtual void removedFrom(Node*) OVERRIDE;

    void clearEventListener();


Lines 139-159 bool SVGTextPathElement::rendererIsNeeded(const NodeRenderingContext& context) a/Source/WebCore/svg/SVGTextPathElement.cpp_sec1
- a/Source/WebCore/svg/SVGTextPathElement.cpp -4 / +7 lines
139	return false;	139	return false;
140	}	140	}
141		141
142	void SVGTextPathElement::insertedIntoDocument()	142	Node::InsertionNotificationRequest SVGTextPathElement::insertedInto(Node* rootParent)
143	{	143	{
144	SVGStyledElement::insertedIntoDocument();	144	SVGStyledElement::insertedInto(rootParent);
		145	if (!rootParent->inDocument())
		146	return InsertionDone;
145		147
146	String id;	148	String id;
147	Element* targetElement = SVGURIReference::targetElementFromIRIString(href(), document(), &id);	149	Element* targetElement = SVGURIReference::targetElementFromIRIString(href(), document(), &id);
148	if (!targetElement) {	150	if (!targetElement) {
149	if (hasPendingResources() \|\| id.isEmpty())	151	if (hasPendingResources() \|\| id.isEmpty())
150	return;	152	return InsertionDone;
151		153
152	ASSERT(!hasPendingResources());	154	ASSERT(!hasPendingResources());
153	document()->accessSVGExtensions()->addPendingResource(id, this);	155	document()->accessSVGExtensions()->addPendingResource(id, this);
154	ASSERT(hasPendingResources());	156	ASSERT(hasPendingResources());
155	return;
156	}	157	}
		158
		159	return InsertionDone;
157	}	160	}
158		161
159	bool SVGTextPathElement::selfHasRelativeLengths() const	162	bool SVGTextPathElement::selfHasRelativeLengths() const

Lines 115-121 public: a/Source/WebCore/svg/SVGTextPathElement.h_sec1
- a/Source/WebCore/svg/SVGTextPathElement.h -1 / +1 lines
115	private:	115	private:
116	SVGTextPathElement(const QualifiedName&, Document*);	116	SVGTextPathElement(const QualifiedName&, Document*);
117		117
118	virtual void insertedIntoDocument();	118	virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
119		119
120	bool isSupportedAttribute(const QualifiedName&);	120	bool isSupportedAttribute(const QualifiedName&);
121	virtual void parseAttribute(Attribute*) OVERRIDE;	121	virtual void parseAttribute(Attribute*) OVERRIDE;



#include "config.h"
#if ENABLE(SVG)
#include "SVGTitleElement.h"
#include "SVGNames.h"

#include "Document.h"
#include "SVGNames.h"

namespace WebCore {


    return adoptRef(new SVGTitleElement(tagName, document));
}

Node::InsertionNotificationRequest SVGTitleElement::insertedInto(Node* rootParent)
{
    SVGStyledElement::insertedInto(rootParent);
    if (!rootParent->inDocument())
        return InsertionDone;
    if (firstChild())
        // FIXME: does SVG have a title text direction?
        document()->setTitleElement(StringWithDirection(textContent(), LTR), this);
    return InsertionDone;
}

void SVGTitleElement::removedFrom(Node* rootParent)
{
    SVGElement::removedFrom(rootParent);
    if (rootParent->inDocument())
        document()->removeTitle(this);
}

void SVGTitleElement::childrenChanged(bool changedByParser, Node* beforeChange, Node* afterChange, int childCountDelta)



private:
    SVGTitleElement(const QualifiedName&, Document*);

    virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
    virtual void removedFrom(Node*) 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)
{
    // This functions exists to assure assumptions made in the code regarding SVGElementInstance creation/destruction are satisfied.
    SVGStyledTransformableElement::insertedInto(rootParent);
    if (!rootParent->inDocument())
        return InsertionDone;
    ASSERT(!m_targetElementInstance || !isWellFormedDocument(document()));
    ASSERT(!hasPendingResources() || !isWellFormedDocument(document()));
    if (!m_wasInsertedByParser)
        buildPendingResource();
    SVGExternalResourcesRequired::insertedIntoDocument(this);
    return InsertionDone;
}

void SVGUseElement::removedFrom(Node* rootParent)
{
    SVGStyledTransformableElement::removedFrom(rootParent);
    if (rootParent->inDocument())
        clearResourceReferences();
}

Document* SVGUseElement::referencedDocument() const



    virtual bool isValid() const { return SVGTests::isValid(); }
    virtual bool supportsFocus() const { return true; }

    virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
    virtual void removedFrom(Node*) OVERRIDE;
    virtual void buildPendingResource();

    bool isSupportedAttribute(const QualifiedName&);



    return adoptRef(new SVGVKernElement(tagName, document));
}

Node::InsertionNotificationRequest SVGVKernElement::insertedInto(Node* rootParent)
{
    if (rootParent->inDocument()) {
        ContainerNode* fontNode = parentNode();
        if (fontNode && fontNode->hasTagName(SVGNames::fontTag)) {
            if (SVGFontElement* element = static_cast<SVGFontElement*>(fontNode))
                element->invalidateGlyphCache();
        }
    }

    return SVGElement::insertedInto(rootParent);
}

void SVGVKernElement::removedFrom(Node* rootParent)
{
    ContainerNode* fontNode = parentNode();
    if (fontNode && fontNode->hasTagName(SVGNames::fontTag)) {
        if (SVGFontElement* element = static_cast<SVGFontElement*>(fontNode))
            element->invalidateGlyphCache();
    }
    SVGElement::removedFrom(rootParent);
}

void SVGVKernElement::buildVerticalKerningPair(KerningPairVector& kerningPairs)



private:
    SVGVKernElement(const QualifiedName&, Document*);

    virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
    virtual void removedFrom(Node*) OVERRIDE;

    virtual bool rendererIsNeeded(const NodeRenderingContext&) { return false; }
};

Lines 189-197 void SVGSMILElement::reset() a/Source/WebCore/svg/animation/SVGSMILElement.cpp_sec1
- a/Source/WebCore/svg/animation/SVGSMILElement.cpp -19 / +26 lines
189	resolveFirstInterval();	189	resolveFirstInterval();
190	}	190	}
191		191
192	void SVGSMILElement::insertedIntoDocument()	192	Node::InsertionNotificationRequest SVGSMILElement::insertedInto(Node* rootParent)
193	{	193	{
194	SVGElement::insertedIntoDocument();	194	SVGElement::insertedInto(rootParent);
		195	if (!rootParent->inDocument())
		196	return InsertionDone;
195		197
196	// Verify we are not in <use> instance tree.	198	// Verify we are not in <use> instance tree.
197	ASSERT(!isInShadowTree());	199	ASSERT(!isInShadowTree());
Lines 199-205 void SVGSMILElement::insertedIntoDocument() a/Source/WebCore/svg/animation/SVGSMILElement.cpp_sec2
199	m_attributeName = constructQualifiedName(this, fastGetAttribute(SVGNames::attributeNameAttr));	201	m_attributeName = constructQualifiedName(this, fastGetAttribute(SVGNames::attributeNameAttr));
200	SVGSVGElement* owner = ownerSVGElement();	202	SVGSVGElement* owner = ownerSVGElement();
201	if (!owner)	203	if (!owner)
202	return;	204	return InsertionDone;
203	m_timeContainer = owner->timeContainer();	205	m_timeContainer = owner->timeContainer();
204	ASSERT(m_timeContainer);	206	ASSERT(m_timeContainer);
205	m_timeContainer->setDocumentOrderIndexesDirty();	207	m_timeContainer->setDocumentOrderIndexesDirty();
Lines 212-239 void SVGSMILElement::insertedIntoDocument() a/Source/WebCore/svg/animation/SVGSMILElement.cpp_sec3
212	resolveFirstInterval();	214	resolveFirstInterval();
213	reschedule();	215	reschedule();
214	}	216	}
		217
		218	return InsertionDone;
215	}	219	}
216		220
217	void SVGSMILElement::removedFromDocument()	221	void SVGSMILElement::removedFrom(Node* rootParent)
218	{	222	{
219	if (m_timeContainer) {	223	if (rootParent->inDocument()) {
220	m_timeContainer->unschedule(this);	224	if (m_timeContainer) {
221	m_timeContainer = 0;	225	m_timeContainer->unschedule(this);
222	}	226	m_timeContainer = 0;
223	// Calling disconnectConditions() may kill us if there are syncbase conditions.	227	}
224	// OK, but we don't want to die inside the call.	228	// Calling disconnectConditions() may kill us if there are syncbase conditions.
225	RefPtr<SVGSMILElement> keepAlive(this);	229	// OK, but we don't want to die inside the call.
226	disconnectConditions();	230	RefPtr<SVGSMILElement> keepAlive(this);
		231	disconnectConditions();
227		232
228	// Clear target now, because disconnectConditions calls targetElement() which will recreate the target if we removed it sooner.	233	// Clear target now, because disconnectConditions calls targetElement() which will recreate the target if we removed it sooner.
229	if (m_targetElement) {	234	if (m_targetElement) {
230	document()->accessSVGExtensions()->removeAnimationElementFromTarget(this, m_targetElement);	235	document()->accessSVGExtensions()->removeAnimationElementFromTarget(this, m_targetElement);
231	targetElementWillChange(m_targetElement, 0);	236	targetElementWillChange(m_targetElement, 0);
232	m_targetElement = 0;	237	m_targetElement = 0;
		238	}
		239
		240	m_attributeName = anyQName();
233	}	241	}
234		242
235	m_attributeName = anyQName();	243	SVGElement::removedFrom(rootParent);
236	SVGElement::removedFromDocument();
237	}	244	}
238		245
239	SMILTime SVGSMILElement::parseOffsetValue(const String& data)	246	SMILTime SVGSMILElement::parseOffsetValue(const String& data)



    bool isSupportedAttribute(const QualifiedName&);
    virtual void parseAttribute(Attribute*) OVERRIDE;
    virtual void svgAttributeChanged(const QualifiedName&) OVERRIDE;
    virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
    virtual void removedFrom(Node*) OVERRIDE;
    
    virtual bool hasValidAttributeType() = 0;
    virtual void animationAttributeChanged() = 0;

Return to Bug 82701

Lines 1454-1471 void HTMLInputElement::didChangeForm() a/Source/WebCore/html/HTMLInputElement.cpp_sec1
- a/Source/WebCore/html/HTMLInputElement.cpp -6 / +9 lines
1454	addToRadioButtonGroup();	1454	addToRadioButtonGroup();
1455	}	1455	}
1456		1456
1457	void HTMLInputElement::insertedIntoDocument()	1457	Node::InsertionNotificationRequest HTMLInputElement::insertedInto(Node* insertionPoint)
1458	{	1458	{
1459	HTMLTextFormControlElement::insertedIntoDocument();	1459	HTMLTextFormControlElement::insertedInto(insertionPoint);
		1460	if (!insertionPoint->inDocument())
		1461	return InsertionDone;
1460	ASSERT(inDocument());	1462	ASSERT(inDocument());
1461	addToRadioButtonGroup();	1463	addToRadioButtonGroup();
		1464	return InsertionDone;
1462	}	1465	}
1463		1466
1464	void HTMLInputElement::removedFromDocument()	1467	void HTMLInputElement::removedFrom(Node* insertionPoint)
1465	{	1468	{
1466	ASSERT(inDocument());	1469	if (insertionPoint->inDocument())
1467	removeFromRadioButtonGroup();	1470	removeFromRadioButtonGroup();
1468	HTMLTextFormControlElement::removedFromDocument();	1471	HTMLTextFormControlElement::removedFrom(insertionPoint);
1469	}	1472	}
1470		1473
1471	void HTMLInputElement::didMoveToNewDocument(Document* oldDocument)	1474	void HTMLInputElement::didMoveToNewDocument(Document* oldDocument)

Lines 1-3 a/Source/WebCore/ChangeLog_sec1
- a/Source/WebCore/ChangeLog +315 lines
		1	2012-04-16 Hajime Morrita <morrita@chromium.org>
		2
		3	insertedIntoDocument and insertedIntoTree should be unitifed.
		4	https://bugs.webkit.org/show_bug.cgi?id=82701
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	Both Node::insertedIntoTree() and Node::insertedIntoDocument() are
		9	served as lifecycle callbacks which are invoked when a node is
		10	inserted into its new parent. There are also removedFromTree()
		11	and removedFromDocument() respectively. Considering that this pair
		12	of virtual functions are laid onto the hot path, it's worth
		13	merging them into one, to gain some speedup. Such
		14	unification could clarify the semantics as well.
		15
		16	This change makes following change to merge these functions.
		17
		18	- pulling the tree traversal out from ContainerNode to ChildNodeInsertionNotifier.
		19	- letting new Node::insertInto() do the job for its own, but not
		20	for its children and
		21	- Pass the parent of each insertion root as a parameter of insertedInto().
		22	This root node can tell inserted node where it is inserted,
		23	specifically whetehr the insertion is to the document or not.
		24
		25	Same pattern is also applied to Node::removedFromDocument() and
		26	Node::removedFromTree(), which are factored to Node::removedFrom()
		27	and ChildNodeRemovalNotifier respectively.
		28
		29	Speed up on Dromaeo/dom-modify.html is about 2%.
		30	Further speed-up by de-virtulization would be possible.
		31
		32	Caveat:
		33
		34	There is possible situation where a node need to invoke
		35	insertedInto() after its children is nofitied, instead of before
		36	that. It was represented naturally with previous
		37	traversal-by-ContainerNode pattern, but is no longer simple with
		38	this new external traversal. To support this scenario, we
		39	introduced the InsertionNotificationRequest as a return value of insertedInto()
		40	and a supplemental hook Node::didNotifyDescendantInseretions(). See for
		41	example HTMLFormElement.cpp to learn how it works.
		42
		43	No new tests. Covered by existing tests.
		44
		45	* CMakeLists.txt:
		46	* GNUmakefile.list.am:
		47	* Target.pri:
		48	* WebCore.gypi:
		49	* WebCore.xcodeproj/project.pbxproj:
		50	* dom/ContainerNode.cpp:
		51	(WebCore::ContainerNode::parserInsertBefore):
		52	(WebCore::ContainerNode::removeChild):
		53	(WebCore::ContainerNode::parserRemoveChild):
		54	(WebCore::ContainerNode::removeChildren):
		55	(WebCore::ContainerNode::parserAddChild):
		56	(WebCore::updateTreeAfterInsertion):
		57	* dom/ContainerNode.h:
		58	(ContainerNode):
		59	(WebCore::Node::highestAncestor):
		60	(WebCore):
		61	* dom/ContainerNodeAlgorithms.cpp: Added.
		62	(WebCore):
		63	(WebCore::ChildNodeInsertionNotifier::notifyDescendantInsertedIntoDocument):
		64	(WebCore::ChildNodeInsertionNotifier::notifyDescendantInsertedIntoTree):
65	(WebCore::ChildNodeRemovalNotifier::notifyDescendantRemovedFromDocument):
66	(WebCore::ChildNodeRemovalNotifier::notifyDescendantRemovedFromTree):
67	* dom/ContainerNodeAlgorithms.h:
68	(ChildNodeInsertionNotifier):
69	(WebCore::ChildNodeInsertionNotifier::ChildNodeInsertionNotifier):
70	(WebCore):
71	(ChildNodeRemovalNotifier):
72	(WebCore::ChildNodeRemovalNotifier::ChildNodeRemovalNotifier):
73	(WebCore::removeAllChildrenInContainer):
74	(WebCore::appendChildToContainer):
75	(Private):
76	(WebCore::ChildNodeInsertionNotifier::notifyNodeInsertedIntoDocument):
77	(WebCore::ChildNodeInsertionNotifier::notifyNodeInsertedIntoTree):
78	(WebCore::ChildNodeInsertionNotifier::notifyInsertedIntoDocument):
79	(WebCore::ChildNodeInsertionNotifier::notify):
80	(WebCore::ChildNodeRemovalNotifier::notifyNodeRemovedFromDocument):
81	(WebCore::ChildNodeRemovalNotifier::notifyNodeRemovedFromTree):
82	(WebCore::ChildNodeRemovalNotifier::notify):
83	* dom/DOMAllInOne.cpp:
84	* dom/DocumentType.cpp:
85	(WebCore::DocumentType::insertedInto):
86	(WebCore::DocumentType::removedFrom):
87	* dom/DocumentType.h:
88	(DocumentType):
89	* dom/Element.cpp:
90	(WebCore::Element::insertedInto):
91	(WebCore::Element::removedFrom):
92	* dom/Element.h:
93	(Element):
94	* dom/Node.cpp:
95	(WebCore::Node::insertedInto):
96	(WebCore::Node::removedFrom):
97	* dom/Node.h:
98	(Node):
99	(WebCore::Node::didNotifyDescendantInseretions):
100	* dom/ProcessingInstruction.cpp:
101	(WebCore::ProcessingInstruction::insertedInto):
102	(WebCore::ProcessingInstruction::removedFrom):
103	* dom/ProcessingInstruction.h:
104	(ProcessingInstruction):
105	* dom/ScriptElement.cpp:
106	(WebCore::ScriptElement::insertedInto):
107	* dom/ScriptElement.h:
108	(WebCore):
109	(ScriptElement):
110	* dom/ShadowTree.cpp:
111	(WebCore::ShadowTree::addShadowRoot):
112	(WebCore::ShadowTree::removeAllShadowRoots):
113	* dom/ShadowTree.h:
114	(ShadowTree):
115	(ShadowRootVector):
116	(WebCore::ShadowRootVector::ShadowRootVector):
117	(WebCore):
118	* html/FormAssociatedElement.cpp:
119	(WebCore::FormAssociatedElement::insertedInto):
120	(WebCore::FormAssociatedElement::removedFrom):
121	(WebCore::FormAssociatedElement::formRemovedFromTree):
122	* html/FormAssociatedElement.h:
123	(FormAssociatedElement):
124	* html/HTMLBaseElement.cpp:
125	(WebCore::HTMLBaseElement::insertedInto):
126	(WebCore::HTMLBaseElement::removedFrom):
127	* html/HTMLBaseElement.h:
128	(HTMLBaseElement):
129	* html/HTMLBodyElement.cpp:
130	(WebCore::HTMLBodyElement::insertedInto):
131	(WebCore::HTMLBodyElement::didNotifyDescendantInseretions):
132	* html/HTMLBodyElement.h:
133	(HTMLBodyElement):
134	* html/HTMLFormControlElement.cpp:
135	(WebCore::HTMLFormControlElement::insertedInto):
136	(WebCore::HTMLFormControlElement::removedFrom):
137	* html/HTMLFormControlElement.h:
138	(HTMLFormControlElement):
139	* html/HTMLFormElement.cpp:
140	(WebCore::HTMLFormElement::insertedInto):
141	(WebCore::HTMLFormElement::didNotifyDescendantInseretions):
142	(WebCore::HTMLFormElement::removedFrom):
143	* html/HTMLFormElement.h:
144	(HTMLFormElement):
145	* html/HTMLFrameElementBase.cpp:
146	(WebCore::HTMLFrameElementBase::insertedInto):
147	(WebCore):
148	(WebCore::HTMLFrameElementBase::didNotifyDescendantInseretions):
149	* html/HTMLFrameElementBase.h:
150	(HTMLFrameElementBase):
151	* html/HTMLFrameSetElement.cpp:
152	(WebCore::HTMLFrameSetElement::insertedInto):
153	(WebCore::HTMLFrameSetElement::removedFrom):
154	* html/HTMLFrameSetElement.h:
155	(HTMLFrameSetElement):
156	* html/HTMLIFrameElement.cpp:
157	(WebCore::HTMLIFrameElement::insertedInto):
158	(WebCore::HTMLIFrameElement::removedFrom):
159	* html/HTMLIFrameElement.h:
160	(HTMLIFrameElement):
161	* html/HTMLImageElement.cpp:
162	(WebCore::HTMLImageElement::insertedInto):
163	(WebCore::HTMLImageElement::removedFrom):
164	* html/HTMLImageElement.h:
165	(HTMLImageElement):
166	* html/HTMLInputElement.cpp:
167	(WebCore::HTMLInputElement::insertedInto):
168	(WebCore::HTMLInputElement::removedFrom):
169	* html/HTMLInputElement.h:
170	* html/HTMLLinkElement.cpp:
171	(WebCore::HTMLLinkElement::insertedInto):
172	(WebCore::HTMLLinkElement::removedFrom):
173	* html/HTMLLinkElement.h:
174	(HTMLLinkElement):
175	* html/HTMLMapElement.cpp:
176	(WebCore::HTMLMapElement::insertedInto):
177	(WebCore::HTMLMapElement::removedFrom):
178	* html/HTMLMapElement.h:
179	(HTMLMapElement):
180	* html/HTMLMediaElement.cpp:
181	(WebCore::HTMLMediaElement::insertedInto):
182	(WebCore::HTMLMediaElement::removedFrom):
183	* html/HTMLMediaElement.h:
184	(HTMLMediaElement):
185	* html/HTMLMetaElement.cpp:
186	(WebCore::HTMLMetaElement::insertedInto):
187	* html/HTMLMetaElement.h:
188	(HTMLMetaElement):
189	* html/HTMLObjectElement.cpp:
190	(WebCore::HTMLObjectElement::insertedInto):
191	(WebCore::HTMLObjectElement::removedFrom):
192	* html/HTMLObjectElement.h:
193	(HTMLObjectElement):
194	* html/HTMLOptionElement.cpp:
195	(WebCore::HTMLOptionElement::insertedInto):
196	* html/HTMLOptionElement.h:
197	(HTMLOptionElement):
198	* html/HTMLQuoteElement.cpp:
199	(WebCore::HTMLQuoteElement::insertedInto):
200	* html/HTMLQuoteElement.h:
201	(HTMLQuoteElement):
202	* html/HTMLScriptElement.cpp:
203	(WebCore::HTMLScriptElement::insertedInto):
204	* html/HTMLScriptElement.h:
205	(HTMLScriptElement):
206	* html/HTMLSelectElement.cpp:
207	(WebCore::HTMLSelectElement::insertedInto):
208	* html/HTMLSelectElement.h:
209	* html/HTMLSourceElement.cpp:
210	(WebCore::HTMLSourceElement::insertedInto):
211	* html/HTMLSourceElement.h:
212	(HTMLSourceElement):
213	* html/HTMLStyleElement.cpp:
214	(WebCore::HTMLStyleElement::insertedInto):
215	(WebCore::HTMLStyleElement::removedFrom):
216	* html/HTMLStyleElement.h:
217	(HTMLStyleElement):
218	* html/HTMLTextFormControlElement.cpp:
219	(WebCore::HTMLTextFormControlElement::insertedInto):
220	* html/HTMLTextFormControlElement.h:
221	* html/HTMLTitleElement.cpp:
222	(WebCore::HTMLTitleElement::insertedInto):
223	(WebCore::HTMLTitleElement::removedFrom):
224	* html/HTMLTitleElement.h:
225	(HTMLTitleElement):
226	* html/HTMLTrackElement.cpp:
227	(WebCore::HTMLTrackElement::insertedInto):
228	* html/HTMLTrackElement.h:
229	(HTMLTrackElement):
230	* mathml/MathMLMathElement.cpp:
231	(WebCore::MathMLMathElement::insertedInto):
232	* mathml/MathMLMathElement.h:
233	(MathMLMathElement):
234	* svg/SVGElement.cpp:
235	(WebCore::SVGElement::removedFrom):
236	* svg/SVGElement.h:
237	(SVGElement):
238	* svg/SVGFEImageElement.cpp:
239	(WebCore::SVGFEImageElement::insertedInto):
240	(WebCore::SVGFEImageElement::removedFrom):
241	* svg/SVGFEImageElement.h:
242	(SVGFEImageElement):
243	* svg/SVGFontFaceElement.cpp:
244	(WebCore::SVGFontFaceElement::insertedInto):
245	(WebCore::SVGFontFaceElement::removedFrom):
246	* svg/SVGFontFaceElement.h:
247	(SVGFontFaceElement):
248	* svg/SVGFontFaceUriElement.cpp:
249	(WebCore::SVGFontFaceUriElement::insertedInto):
250	* svg/SVGFontFaceUriElement.h:
251	(SVGFontFaceUriElement):
252	* svg/SVGGlyphElement.cpp:
253	(WebCore::SVGGlyphElement::insertedInto):
254	(WebCore::SVGGlyphElement::removedFrom):
255	* svg/SVGGlyphElement.h:
256	(SVGGlyphElement):
257	* svg/SVGHKernElement.cpp:
258	(WebCore::SVGHKernElement::insertedInto):
259	(WebCore::SVGHKernElement::removedFrom):
260	* svg/SVGHKernElement.h:
261	(SVGHKernElement):
262	* svg/SVGImageElement.cpp:
263	(WebCore::SVGImageElement::insertedInto):
264	* svg/SVGImageElement.h:
265	(SVGImageElement):
266	* svg/SVGSVGElement.cpp:
267	(WebCore::SVGSVGElement::insertedInto):
268	(WebCore::SVGSVGElement::removedFrom):
269	* svg/SVGSVGElement.h:
270	(SVGSVGElement):
271	* svg/SVGScriptElement.cpp:
272	(WebCore::SVGScriptElement::insertedInto):
273	* svg/SVGScriptElement.h:
274	(SVGScriptElement):
275	* svg/SVGStyleElement.cpp:
276	(WebCore::SVGStyleElement::insertedInto):
277	(WebCore::SVGStyleElement::removedFrom):
278	* svg/SVGStyleElement.h:
279	(SVGStyleElement):
280	* svg/SVGStyledElement.cpp:
281	(WebCore::SVGStyledElement::insertedInto):
282	(WebCore::SVGStyledElement::removedFrom):
283	(WebCore::SVGStyledElement::updateRelativeLengthsInformation):
284	* svg/SVGStyledElement.h:
285	(SVGStyledElement):
286	* svg/SVGTRefElement.cpp:
287	(WebCore::SVGTRefElement::buildPendingResource):
288	(WebCore::SVGTRefElement::insertedInto):
289	(WebCore::SVGTRefElement::removedFrom):
290	* svg/SVGTRefElement.h:
291	(SVGTRefElement):
292	* svg/SVGTextPathElement.cpp:
293	(WebCore::SVGTextPathElement::insertedInto):
294	* svg/SVGTextPathElement.h:
295	* svg/SVGTitleElement.cpp:
296	(WebCore::SVGTitleElement::insertedInto):
297	(WebCore::SVGTitleElement::removedFrom):
298	* svg/SVGTitleElement.h:
299	(SVGTitleElement):
300	* svg/SVGUseElement.cpp:
301	(WebCore::SVGUseElement::insertedInto):
302	(WebCore::SVGUseElement::removedFrom):
303	* svg/SVGUseElement.h:
304	(SVGUseElement):
305	* svg/SVGVKernElement.cpp:
306	(WebCore::SVGVKernElement::insertedInto):
307	(WebCore::SVGVKernElement::removedFrom):
308	* svg/SVGVKernElement.h:
309	(SVGVKernElement):
310	* svg/animation/SVGSMILElement.cpp:
311	(WebCore::SVGSMILElement::insertedInto):
312	(WebCore::SVGSMILElement::removedFrom):
313	* svg/animation/SVGSMILElement.h:
314	(SVGSMILElement):
315
1	2012-04-14 Emil A Eklund <eae@chromium.org>	316	2012-04-14 Emil A Eklund <eae@chromium.org>
2		317
3	Fix pixelSnapping for CalendarPicker, MediaControl and ScrollbarPart	318	Fix pixelSnapping for CalendarPicker, MediaControl and ScrollbarPart

Lines 518-523 SOURCES += \ a/Source/WebCore/Target.pri_sec1
- a/Source/WebCore/Target.pri +2 lines
518	dom/ComposedShadowTreeWalker.cpp \	518	dom/ComposedShadowTreeWalker.cpp \
519	dom/CompositionEvent.cpp \	519	dom/CompositionEvent.cpp \
520	dom/ContainerNode.cpp \	520	dom/ContainerNode.cpp \
		521	dom/ContainerNodeAlgorithms.cpp \
521	dom/ContextDestructionObserver.cpp \	522	dom/ContextDestructionObserver.cpp \
522	dom/CustomEvent.cpp \	523	dom/CustomEvent.cpp \
523	dom/DecodedDataDocumentParser.cpp \	524	dom/DecodedDataDocumentParser.cpp \
Lines 1666-1671 HEADERS += \ a/Source/WebCore/Target.pri_sec2
1666	dom/Comment.h \	1667	dom/Comment.h \
1667	dom/ComposedShadowTreeWalker.h \	1668	dom/ComposedShadowTreeWalker.h \
1668	dom/ContainerNode.h \	1669	dom/ContainerNode.h \
		1670	dom/ContainerNodeAlgorithms.h \
1669	dom/CustomEvent.h \	1671	dom/CustomEvent.h \
1670	dom/default/PlatformMessagePortChannel.h \	1672	dom/default/PlatformMessagePortChannel.h \
1671	dom/DeviceMotionClient.h \	1673	dom/DeviceMotionClient.h \

Lines 3748-3753 a/Source/WebCore/WebCore.xcodeproj/project.pbxproj_sec1
- a/Source/WebCore/WebCore.xcodeproj/project.pbxproj +4 lines
3748	A78FE13C12366B1000ACE8D0 /* SpellChecker.h in Headers / = {isa = PBXBuildFile; fileRef = A78FE13A12366B1000ACE8D0 / SpellChecker.h */; settings = {ATTRIBUTES = (Private, ); }; };	3748	A78FE13C12366B1000ACE8D0 /* SpellChecker.h in Headers / = {isa = PBXBuildFile; fileRef = A78FE13A12366B1000ACE8D0 / SpellChecker.h */; settings = {ATTRIBUTES = (Private, ); }; };
3749	A795463E0B5C4C80007B438F /* DragDataMac.mm in Sources / = {isa = PBXBuildFile; fileRef = A795463D0B5C4C80007B438F / DragDataMac.mm */; };	3749	A795463E0B5C4C80007B438F /* DragDataMac.mm in Sources / = {isa = PBXBuildFile; fileRef = A795463D0B5C4C80007B438F / DragDataMac.mm */; };
3750	A79546430B5C4CB4007B438F /* DragData.cpp in Sources / = {isa = PBXBuildFile; fileRef = A79546420B5C4CB4007B438F / DragData.cpp */; };	3750	A79546430B5C4CB4007B438F /* DragData.cpp in Sources / = {isa = PBXBuildFile; fileRef = A79546420B5C4CB4007B438F / DragData.cpp */; };
		3751	A7A78CD51532BA62006C21E4 /* ContainerNodeAlgorithms.cpp in Sources / = {isa = PBXBuildFile; fileRef = A7A78CD41532BA62006C21E4 / ContainerNodeAlgorithms.cpp */; };
3751	A7AD2F870EC89D07008AB002 /* LinkHash.cpp in Sources / = {isa = PBXBuildFile; fileRef = A7AD2F850EC89D07008AB002 / LinkHash.cpp */; };	3752	A7AD2F870EC89D07008AB002 /* LinkHash.cpp in Sources / = {isa = PBXBuildFile; fileRef = A7AD2F850EC89D07008AB002 / LinkHash.cpp */; };
3752	A7AD2F880EC89D07008AB002 /* LinkHash.h in Headers / = {isa = PBXBuildFile; fileRef = A7AD2F860EC89D07008AB002 / LinkHash.h */; settings = {ATTRIBUTES = (Private, ); }; };	3753	A7AD2F880EC89D07008AB002 /* LinkHash.h in Headers / = {isa = PBXBuildFile; fileRef = A7AD2F860EC89D07008AB002 / LinkHash.h */; settings = {ATTRIBUTES = (Private, ); }; };
3753	A7B070D2130A409C00A3763C /* FrameActionScheduler.cpp in Sources / = {isa = PBXBuildFile; fileRef = A7B070D0130A409C00A3763C / FrameActionScheduler.cpp */; };	3754	A7B070D2130A409C00A3763C /* FrameActionScheduler.cpp in Sources / = {isa = PBXBuildFile; fileRef = A7B070D0130A409C00A3763C / FrameActionScheduler.cpp */; };
Lines 10772-10777 a/Source/WebCore/WebCore.xcodeproj/project.pbxproj_sec2
10772	A78FE13A12366B1000ACE8D0 /* SpellChecker.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; path = SpellChecker.h; sourceTree = "<group>"; };	10773	A78FE13A12366B1000ACE8D0 /* SpellChecker.h */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; fileEncoding = 4; path = SpellChecker.h; sourceTree = "<group>"; };
10773	A795463D0B5C4C80007B438F /* DragDataMac.mm */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.objcpp; path = DragDataMac.mm; sourceTree = "<group>"; };	10774	A795463D0B5C4C80007B438F /* DragDataMac.mm */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.objcpp; path = DragDataMac.mm; sourceTree = "<group>"; };
10774	A79546420B5C4CB4007B438F /* DragData.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = DragData.cpp; sourceTree = "<group>"; };	10775	A79546420B5C4CB4007B438F /* DragData.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = DragData.cpp; sourceTree = "<group>"; };
		10776	A7A78CD41532BA62006C21E4 /* ContainerNodeAlgorithms.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ContainerNodeAlgorithms.cpp; sourceTree = "<group>"; };
10775	A7AD2F850EC89D07008AB002 /* LinkHash.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = LinkHash.cpp; sourceTree = "<group>"; };	10777	A7AD2F850EC89D07008AB002 /* LinkHash.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = LinkHash.cpp; sourceTree = "<group>"; };
10776	A7AD2F860EC89D07008AB002 /* LinkHash.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LinkHash.h; sourceTree = "<group>"; };	10778	A7AD2F860EC89D07008AB002 /* LinkHash.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LinkHash.h; sourceTree = "<group>"; };
10777	A7B070D0130A409C00A3763C /* FrameActionScheduler.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = FrameActionScheduler.cpp; sourceTree = "<group>"; };	10779	A7B070D0130A409C00A3763C /* FrameActionScheduler.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = FrameActionScheduler.cpp; sourceTree = "<group>"; };
Lines 20958-20963 a/Source/WebCore/WebCore.xcodeproj/project.pbxproj_sec3
20958	79F2F5A01091939A000D87CB /* CompositionEvent.idl */,	20960	79F2F5A01091939A000D87CB /* CompositionEvent.idl */,
20959	A81872140977D3C0005826D9 /* ContainerNode.cpp */,	20961	A81872140977D3C0005826D9 /* ContainerNode.cpp */,
20960	A81872110977D3C0005826D9 /* ContainerNode.h */,	20962	A81872110977D3C0005826D9 /* ContainerNode.h */,
		20963	A7A78CD41532BA62006C21E4 /* ContainerNodeAlgorithms.cpp */,
20961	E1A1470711102B1500EEC0F3 /* ContainerNodeAlgorithms.h */,	20964	E1A1470711102B1500EEC0F3 /* ContainerNodeAlgorithms.h */,
20962	97627B8B14FB3CEE002CDCA1 /* ContextDestructionObserver.cpp */,	20965	97627B8B14FB3CEE002CDCA1 /* ContextDestructionObserver.cpp */,
20963	97627B8C14FB3CEE002CDCA1 /* ContextDestructionObserver.h */,	20966	97627B8C14FB3CEE002CDCA1 /* ContextDestructionObserver.h */,
Lines 25285-25290 a/Source/WebCore/WebCore.xcodeproj/project.pbxproj_sec4
25285	BC0B36A40CD3C67C00AC7EB5 /* Console.cpp in Sources */,	25288	BC0B36A40CD3C67C00AC7EB5 /* Console.cpp in Sources */,
25286	41F0618F0F5F069800A07EAC /* ConsoleMessage.cpp in Sources */,	25289	41F0618F0F5F069800A07EAC /* ConsoleMessage.cpp in Sources */,
25287	A818721F0977D3C0005826D9 /* ContainerNode.cpp in Sources */,	25290	A818721F0977D3C0005826D9 /* ContainerNode.cpp in Sources */,
		25291	A7A78CD51532BA62006C21E4 /* ContainerNodeAlgorithms.cpp in Sources */,
25288	BC5EB9800E82072500B25965 /* ContentData.cpp in Sources */,	25292	BC5EB9800E82072500B25965 /* ContentData.cpp in Sources */,
25289	59102FBB14327D3B003C9D04 /* ContentSearchUtils.cpp in Sources */,	25293	59102FBB14327D3B003C9D04 /* ContentSearchUtils.cpp in Sources */,
25290	97C471DB12F925BD0086354B /* ContentSecurityPolicy.cpp in Sources */,	25294	97C471DB12F925BD0086354B /* ContentSecurityPolicy.cpp in Sources */,

Lines 47-53 using namespace std; a/Source/WebCore/dom/ContainerNode.cpp_sec1
- a/Source/WebCore/dom/ContainerNode.cpp -104 / +8 lines
47		47
48	namespace WebCore {	48	namespace WebCore {
49		49
50	static void notifyChildInserted(Node*);
51	static void dispatchChildInsertionEvents(Node*);	50	static void dispatchChildInsertionEvents(Node*);
52	static void dispatchChildRemovalEvents(Node*);	51	static void dispatchChildRemovalEvents(Node*);
53	static void updateTreeAfterInsertion(ContainerNode, Node, bool shouldLazyAttach);	52	static void updateTreeAfterInsertion(ContainerNode, Node, bool shouldLazyAttach);
Lines 230-236 void ContainerNode::parserInsertBefore(PassRefPtr<Node> newChild, Node* nextChil a/Source/WebCore/dom/ContainerNode.cpp_sec2
230	insertBeforeCommon(next.get(), child);	229	insertBeforeCommon(next.get(), child);
231		230
232	childrenChanged(true, nextChildPreviousSibling.get(), nextChild, 1);	231	childrenChanged(true, nextChildPreviousSibling.get(), nextChild, 1);
233	notifyChildInserted(child);	232	ChildNodeInsertionNotifier(this).notify(child);
234	}	233	}
235	}	234	}
236		235
Lines 406-416 bool ContainerNode::removeChild(Node* oldChild, ExceptionCode& ec) a/Source/WebCore/dom/ContainerNode.cpp_sec3
406		405
407	childrenChanged(false, prev, next, -1);	406	childrenChanged(false, prev, next, -1);
408		407
409	if (child->inDocument())	408	ChildNodeRemovalNotifier(this).notify(child.get());
410	child->removedFromDocument();
411	else if (child->isContainerNode())
412	toContainerNode(child.get())->removedFromTree(true);
413
414	dispatchSubtreeModifiedEvent();	409	dispatchSubtreeModifiedEvent();
415		410
416	return child;	411	return child;
Lines 456-465 void ContainerNode::parserRemoveChild(Node* oldChild) a/Source/WebCore/dom/ContainerNode.cpp_sec4
456	removeBetween(prev, next, oldChild);	451	removeBetween(prev, next, oldChild);
457		452
458	childrenChanged(true, prev, next, -1);	453	childrenChanged(true, prev, next, -1);
459	if (oldChild->inDocument())	454	ChildNodeRemovalNotifier(this).notify(oldChild);
460	oldChild->removedFromDocument();
461	else if (oldChild->isContainerNode())
462	toContainerNode(oldChild)->removedFromTree(true);
463	}	455	}
464		456
465	// this differs from other remove functions because it forcibly removes all the children,	457	// this differs from other remove functions because it forcibly removes all the children,
Lines 520-532 void ContainerNode::removeChildren() a/Source/WebCore/dom/ContainerNode.cpp_sec5
520		512
521	childrenChanged(false, 0, 0, -static_cast<int>(removedChildrenCount));	513	childrenChanged(false, 0, 0, -static_cast<int>(removedChildrenCount));
522		514
523	for (i = 0; i < removedChildrenCount; ++i) {	515	for (i = 0; i < removedChildrenCount; ++i)
524	Node* removedChild = removedChildren[i].get();	516	ChildNodeRemovalNotifier(this).notify(removedChildren[i].get());
525	if (removedChild->inDocument())
526	removedChild->removedFromDocument();
527	else if (removedChild->isContainerNode())
528	toContainerNode(removedChild)->removedFromTree(true);
529	}
530		517
531	allowEventDispatch();	518	allowEventDispatch();
532	dispatchSubtreeModifiedEvent();	519	dispatchSubtreeModifiedEvent();
Lines 603-611 void ContainerNode::parserAddChild(PassRefPtr<Node> newChild) a/Source/WebCore/dom/ContainerNode.cpp_sec6
603		590
604	allowEventDispatch();	591	allowEventDispatch();
605		592
606	// FIXME: Why doesn't this use notifyChildInserted(newChild) instead?	593	// FIXME: Why doesn't this use notify(newChild.get()) instead?
607	if (inDocument())	594	if (inDocument())
608	newChild->insertedIntoDocument();	595	ChildNodeInsertionNotifier(this).notifyInsertedIntoDocument(newChild.get());
609	childrenChanged(true, last, 0, 1);	596	childrenChanged(true, last, 0, 1);
610	}	597	}
611		598
Lines 696-767 void ContainerNode::detach() a/Source/WebCore/dom/ContainerNode.cpp_sec7
696	Node::detach();	683	Node::detach();
697	}	684	}
698		685
699	void ContainerNode::insertedIntoDocument()
700	{
701	RefPtr<Node> protect(this);
702
703	Node::insertedIntoDocument();
704	insertedIntoTree(false);
705
706	NodeVector children;
707	getChildNodes(this, children);
708	for (size_t i = 0; i < children.size(); ++i) {
709	// If we have been removed from the document during this loop, then
710	// we don't want to tell the rest of our children that they've been
711	// inserted into the document because they haven't.
712	if (!inDocument())
713	break;
714	if (children[i]->parentNode() != this)
715	continue;
716	children[i]->insertedIntoDocument();
717	}
718	}
719
720	void ContainerNode::removedFromDocument()
721	{
722	Node::removedFromDocument();
723	if (document()->cssTarget() == this)
724	document()->setCSSTarget(0);
725	removedFromTree(false);
726
727	NodeVector children;
728	getChildNodes(this, children);
729	for (size_t i = 0; i < children.size(); ++i) {
730	// If we have been added to the document during this loop, then we
731	// don't want to tell the rest of our children that they've been
732	// removed from the document because they haven't.
733	if (inDocument())
734	break;
735	if (children[i]->parentNode() != this)
736	continue;
737	children[i]->removedFromDocument();
738	}
739	}
740
741	void ContainerNode::insertedIntoTree(bool deep)
742	{
743	if (!deep)
744	return;
745	forbidEventDispatch();
746	for (Node* child = m_firstChild; child; child = child->nextSibling()) {
747	if (child->isContainerNode())
748	toContainerNode(child)->insertedIntoTree(true);
749	}
750	allowEventDispatch();
751	}
752
753	void ContainerNode::removedFromTree(bool deep)
754	{
755	if (!deep)
756	return;
757	forbidEventDispatch();
758	for (Node* child = m_firstChild; child; child = child->nextSibling()) {
759	if (child->isContainerNode())
760	toContainerNode(child)->removedFromTree(true);
761	}
762	allowEventDispatch();
763	}
764
765	void ContainerNode::childrenChanged(bool changedByParser, Node, Node, int childCountDelta)	686	void ContainerNode::childrenChanged(bool changedByParser, Node, Node, int childCountDelta)
766	{	687	{
767	document()->incDOMTreeVersion();	688	document()->incDOMTreeVersion();
Lines 1007-1029 Node *ContainerNode::childNode(unsigned index) const a/Source/WebCore/dom/ContainerNode.cpp_sec8
1007	return n;	928	return n;
1008	}	929	}
1009		930
1010	static void notifyChildInserted(Node* child)
1011	{
1012	ASSERT(!eventDispatchForbidden());
1013
1014	#if ENABLE(INSPECTOR)
1015	InspectorInstrumentation::didInsertDOMNode(child->document(), child);
1016	#endif
1017
1018	RefPtr<Node> c = child;
1019	RefPtr<Document> document = child->document();
1020
1021	Node* parentOrHostNode = c->parentOrHostNode();
1022	if (parentOrHostNode && parentOrHostNode->inDocument())
1023	c->insertedIntoDocument();
1024	else if (c->isContainerNode())
1025	toContainerNode(c.get())->insertedIntoTree(true);
1026	}
1027		931
1028	static void dispatchChildInsertionEvents(Node* child)	932	static void dispatchChildInsertionEvents(Node* child)
1029	{	933	{
Lines 1092-1098 static void updateTreeAfterInsertion(ContainerNode* parent, Node* child, bool sh a/Source/WebCore/dom/ContainerNode.cpp_sec9
1092		996
1093	parent->childrenChanged(false, child->previousSibling(), child->nextSibling(), 1);	997	parent->childrenChanged(false, child->previousSibling(), child->nextSibling(), 1);
1094		998
1095	notifyChildInserted(child);	999	ChildNodeInsertionNotifier(parent).notify(child);
1096		1000
1097	// FIXME: Attachment should be the first operation in this function, but some code	1001	// FIXME: Attachment should be the first operation in this function, but some code
1098	// (for example, HTMLFormControlElement's autofocus support) requires this ordering.	1002	// (for example, HTMLFormControlElement's autofocus support) requires this ordering.

Lines 77-95 public: a/Source/WebCore/dom/ContainerNode.h_sec1
- a/Source/WebCore/dom/ContainerNode.h -8 / +9 lines
77	virtual void setFocus(bool = true) OVERRIDE;	77	virtual void setFocus(bool = true) OVERRIDE;
78	virtual void setActive(bool active = true, bool pause = false) OVERRIDE;	78	virtual void setActive(bool active = true, bool pause = false) OVERRIDE;
79	virtual void setHovered(bool = true) OVERRIDE;	79	virtual void setHovered(bool = true) OVERRIDE;
80	virtual void insertedIntoDocument() OVERRIDE;
81	virtual void removedFromDocument() OVERRIDE;
82	virtual void scheduleSetNeedsStyleRecalc(StyleChangeType = FullStyleChange) OVERRIDE;	80	virtual void scheduleSetNeedsStyleRecalc(StyleChangeType = FullStyleChange) OVERRIDE;
83		81
84	// -----------------------------------------------------------------------------	82	// -----------------------------------------------------------------------------
85	// Notification of document structure changes (see Node.h for more notification methods)	83	// Notification of document structure changes (see Node.h for more notification methods)
86		84
87	// These functions are called whenever you are connected or disconnected from a tree. That tree may be the main
88	// document tree, or it could be another disconnected tree. Override these functions to do any work that depends
89	// on connectedness to some ancestor (e.g., an ancestor <form>).
90	virtual void insertedIntoTree(bool deep);
91	virtual void removedFromTree(bool deep);
92
93	// Notifies the node that it's list of children have changed (either by adding or removing child nodes), or a child	85	// Notifies the node that it's list of children have changed (either by adding or removing child nodes), or a child
94	// node that is of the type CDATA_SECTION_NODE, TEXT_NODE or COMMENT_NODE has changed its value.	86	// node that is of the type CDATA_SECTION_NODE, TEXT_NODE or COMMENT_NODE has changed its value.
95	virtual void childrenChanged(bool createdByParser = false, Node* beforeChange = 0, Node* afterChange = 0, int childCountDelta = 0);	87	virtual void childrenChanged(bool createdByParser = false, Node* beforeChange = 0, Node* afterChange = 0, int childCountDelta = 0);
Lines 227-232 inline Node* Node::lastChild() const a/Source/WebCore/dom/ContainerNode.h_sec2
227	return toContainerNode(this)->lastChild();	219	return toContainerNode(this)->lastChild();
228	}	220	}
229		221
		222	inline Node* Node::highestAncestor() const
		223	{
		224	Node* node = const_cast<Node*>(this);
		225	Node* highest = node;
		226	for (; node; node = node->parentNode())
		227	highest = node;
		228	return highest;
		229	}
		230
230	typedef Vector<RefPtr<Node>, 11> NodeVector;	231	typedef Vector<RefPtr<Node>, 11> NodeVector;
231		232
232	inline void getChildNodes(Node* node, NodeVector& nodes)	233	inline void getChildNodes(Node* node, NodeVector& nodes)

Line 0 a/Source/WebCore/dom/ContainerNodeAlgorithms.cpp_sec1
- a/Source/WebCore/dom/ContainerNodeAlgorithms.cpp +114 lines
		1	/*
		2	* Copyright (C) 1999 Lars Knoll (knoll@kde.org)
		3	* (C) 1999 Antti Koivisto (koivisto@kde.org)
		4	* (C) 2001 Dirk Mueller (mueller@kde.org)
		5	* Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
		6	* Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
		7	* Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
		8	* Copyright (C) 2012 Google Inc. All rights reserved.
		9	*
		10	* This library is free software; you can redistribute it and/or
		11	* modify it under the terms of the GNU Library General Public
		12	* License as published by the Free Software Foundation; either
		13	* version 2 of the License, or (at your option) any later version.
		14	*
		15	* This library is distributed in the hope that it will be useful,
		16	* but WITHOUT ANY WARRANTY; without even the implied warranty of
		17	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
		18	* Library General Public License for more details.
		19	*
		20	* You should have received a copy of the GNU Library General Public License
		21	* along with this library; see the file COPYING.LIB. If not, write to
		22	* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
		23	* Boston, MA 02110-1301, USA.
		24	*/
		25
		26	#include "config.h"
		27	#include "ContainerNodeAlgorithms.h"
		28
		29	#include "Element.h"
		30	#include "ShadowTree.h"
		31
		32	namespace WebCore {
		33
		34	void ChildNodeInsertionNotifier::notifyDescendantInsertedIntoDocument(ContainerNode* node)
		35	{
		36	NodeVector children;
		37	getChildNodes(node, children);
		38	for (size_t i = 0; i < children.size(); ++i) {
		39	// If we have been removed from the document during this loop, then
		40	// we don't want to tell the rest of our children that they've been
		41	// inserted into the document because they haven't.
		42	if (node->inDocument() && children[i]->parentNode() == node)
		43	notifyNodeInsertedIntoDocument(children[i].get());
		44	}
		45
		46	if (!node->isElementNode())
		47	return;
		48
		49	if (ShadowTree* tree = toElement(node)->shadowTree()) {
		50	ShadowRootVector roots(tree);
		51	for (size_t i = 0; i < roots.size(); ++i)
		52	notifyNodeInsertedIntoDocument(roots[i].get());
		53	}
		54	}
		55
		56	void ChildNodeInsertionNotifier::notifyDescendantInsertedIntoTree(ContainerNode* node)
		57	{
		58	for (Node* child = node->firstChild(); child; child = child->nextSibling()) {
		59	if (child->isContainerNode())
		60	notifyNodeInsertedIntoTree(toContainerNode(child));
		61	}
		62
		63	if (!node->isElementNode())
		64	return;
65
66	if (ShadowTree* tree = toElement(node)->shadowTree()) {
67	for (ShadowRoot* root = tree->youngestShadowRoot(); root; root = root->olderShadowRoot())
68	notifyNodeInsertedIntoTree(root);
69	}
70	}
71
72	void ChildNodeRemovalNotifier::notifyDescendantRemovedFromDocument(ContainerNode* node)
73	{
74	NodeVector children;
75	getChildNodes(node, children);
76	for (size_t i = 0; i < children.size(); ++i) {
77	// If we have been added to the document during this loop, then we
78	// don't want to tell the rest of our children that they've been
79	// removed from the document because they haven't.
80	if (!node->inDocument() && children[i]->parentNode() == node)
81	notifyNodeRemovedFromDocument(children[i].get());
82	}
83
84	if (!node->isElementNode())
85	return;
86
87	if (node->document()->cssTarget() == node)
88	node->document()->setCSSTarget(0);
89
90	if (ShadowTree* tree = toElement(node)->shadowTree()) {
91	ShadowRootVector roots(tree);
92	for (size_t i = 0; i < roots.size(); ++i)
93	notifyNodeRemovedFromDocument(roots[i].get());
94	}
95	}
96
97	void ChildNodeRemovalNotifier::notifyDescendantRemovedFromTree(ContainerNode* node)
98	{
99	for (Node* child = node->firstChild(); child; child = child->nextSibling()) {
100	if (child->isContainerNode())
101	notifyNodeRemovedFromTree(toContainerNode(child));
102	}
103
104	if (!node->isElementNode())
105	return;
106
107	if (ShadowTree* tree = toElement(node)->shadowTree()) {
108	ShadowRootVector roots(tree);
109	for (size_t i = 0; i < roots.size(); ++i)
110	notifyNodeRemovedFromTree(roots[i].get());
111	}
112	}
113
114	}

Lines 22-34 a/Source/WebCore/dom/ContainerNodeAlgorithms.h_sec1
- a/Source/WebCore/dom/ContainerNodeAlgorithms.h -5 / +111 lines
22	#ifndef ContainerNodeAlgorithms_h	22	#ifndef ContainerNodeAlgorithms_h
23	#define ContainerNodeAlgorithms_h	23	#define ContainerNodeAlgorithms_h
24		24
25	#include <Document.h>	25	#include "Document.h"
		26	#include "InspectorInstrumentation.h"
26	#include <wtf/Assertions.h>	27	#include <wtf/Assertions.h>
27		28
28	namespace WebCore {	29	namespace WebCore {
29		30
30	class Node;	31	class Node;
31		32
		33	class ChildNodeInsertionNotifier {
		34	public:
		35	explicit ChildNodeInsertionNotifier(Node* insertionPoint)
		36	: m_insertionPoint(insertionPoint)
		37	{ }
		38
		39	void notifyInsertedIntoDocument(Node*);
		40	void notify(Node*);
		41
		42	private:
		43	void notifyDescendantInsertedIntoDocument(ContainerNode*);
		44	void notifyDescendantInsertedIntoTree(ContainerNode*);
		45	void notifyNodeInsertedIntoDocument(Node*);
		46	void notifyNodeInsertedIntoTree(ContainerNode*);
		47
		48	Node* m_insertionPoint;
		49	};
		50
		51	class ChildNodeRemovalNotifier {
		52	public:
		53	explicit ChildNodeRemovalNotifier(Node* insertionPoint)
		54	: m_insertionPoint(insertionPoint)
		55	{ }
		56
		57	void notify(Node*);
		58
		59	private:
		60	void notifyDescendantRemovedFromDocument(ContainerNode*);
		61	void notifyDescendantRemovedFromTree(ContainerNode*);
		62	void notifyNodeRemovedFromDocument(Node*);
		63	void notifyNodeRemovedFromTree(ContainerNode*);
		64
		65	Node* m_insertionPoint;
		66	};
		67
32	namespace Private {	68	namespace Private {
33		69
34	template<class GenericNode, class GenericNodeContainer>	70	template<class GenericNode, class GenericNodeContainer>
Lines 39-45 namespace Private { a/Source/WebCore/dom/ContainerNodeAlgorithms.h_sec2
39	// Helper functions for TreeShared-derived classes, which have a 'Node' style interface	75	// Helper functions for TreeShared-derived classes, which have a 'Node' style interface
40	// This applies to 'ContainerNode' and 'SVGElementInstance'	76	// This applies to 'ContainerNode' and 'SVGElementInstance'
41	template<class GenericNode, class GenericNodeContainer>	77	template<class GenericNode, class GenericNodeContainer>
42	void removeAllChildrenInContainer(GenericNodeContainer* container)	78	inline void removeAllChildrenInContainer(GenericNodeContainer* container)
43	{	79	{
44	// List of nodes to be deleted.	80	// List of nodes to be deleted.
45	GenericNode* head = 0;	81	GenericNode* head = 0;
Lines 67-73 void removeAllChildrenInContainer(GenericNodeContainer* container) a/Source/WebCore/dom/ContainerNodeAlgorithms.h_sec3
67	}	103	}
68		104
69	template<class GenericNode, class GenericNodeContainer>	105	template<class GenericNode, class GenericNodeContainer>
70	void appendChildToContainer(GenericNode* child, GenericNodeContainer* container)	106	inline void appendChildToContainer(GenericNode* child, GenericNodeContainer* container)
71	{	107	{
72	child->setParent(container);	108	child->setParent(container);
73		109
Lines 100-106 namespace Private { a/Source/WebCore/dom/ContainerNodeAlgorithms.h_sec4
100	if (Document* containerDocument = container->ownerDocument())	136	if (Document* containerDocument = container->ownerDocument())
101	containerDocument->adoptIfNeeded(node);	137	containerDocument->adoptIfNeeded(node);
102	if (node->inDocument())	138	if (node->inDocument())
103	node->removedFromDocument();	139	ChildNodeRemovalNotifier(container).notify(node);
104	}	140	}
105	};	141	};
106		142
Lines 148-154 namespace Private { a/Source/WebCore/dom/ContainerNodeAlgorithms.h_sec5
148	container->setFirstChild(0);	184	container->setFirstChild(0);
149	container->setLastChild(0);	185	container->setLastChild(0);
150	}	186	}
151	};	187
		188	} // namespace Private
		189
		190	inline void ChildNodeInsertionNotifier::notifyNodeInsertedIntoDocument(Node* node)
		191	{
		192	ASSERT(m_insertionPoint->inDocument());
		193	RefPtr<Node> protect(node);
		194	Node::InsertionNotificationRequest request = node->insertedInto(m_insertionPoint);
		195	if (node->isContainerNode())
		196	notifyDescendantInsertedIntoDocument(toContainerNode(node));
		197	if (request == Node::InsertionShouldCallDidNotifyDescendantInseretions)
		198	node->didNotifyDescendantInseretions(m_insertionPoint);
		199	}
		200
		201	inline void ChildNodeInsertionNotifier::notifyNodeInsertedIntoTree(ContainerNode* node)
		202	{
		203	ASSERT(!m_insertionPoint->inDocument());
		204	forbidEventDispatch();
		205	Node::InsertionNotificationRequest request = node->insertedInto(m_insertionPoint);
		206	notifyDescendantInsertedIntoTree(node);
		207	if (request == Node::InsertionShouldCallDidNotifyDescendantInseretions)
		208	node->didNotifyDescendantInseretions(m_insertionPoint);
		209	allowEventDispatch();
		210	}
		211
		212	inline void ChildNodeInsertionNotifier::notifyInsertedIntoDocument(Node* node)
		213	{
		214	notifyNodeInsertedIntoDocument(node);
		215	}
		216
		217	inline void ChildNodeInsertionNotifier::notify(Node* node)
		218	{
		219	ASSERT(!eventDispatchForbidden());
		220
		221	#if ENABLE(INSPECTOR)
		222	InspectorInstrumentation::didInsertDOMNode(node->document(), node);
		223	#endif
		224
		225	RefPtr<Document> protectDocument(node->document());
		226	RefPtr<Node> protectNode(node);
		227	if (m_insertionPoint->inDocument())
		228	notifyNodeInsertedIntoDocument(node);
		229	else if (node->isContainerNode())
		230	notifyNodeInsertedIntoTree(toContainerNode(node));
		231	}
		232
		233
		234	inline void ChildNodeRemovalNotifier::notifyNodeRemovedFromDocument(Node* node)
		235	{
		236	ASSERT(m_insertionPoint->inDocument());
		237	node->removedFrom(m_insertionPoint);
		238	if (node->isContainerNode())
		239	notifyDescendantRemovedFromDocument(toContainerNode(node));
		240	}
		241
		242	inline void ChildNodeRemovalNotifier::notifyNodeRemovedFromTree(ContainerNode* node)
		243	{
		244	ASSERT(!m_insertionPoint->inDocument());
		245	forbidEventDispatch();
		246	node->removedFrom(m_insertionPoint);
		247	notifyDescendantRemovedFromTree(node);
		248	allowEventDispatch();
		249	}
		250
		251	inline void ChildNodeRemovalNotifier::notify(Node* node)
252	{
253	if (node->inDocument())
254	notifyNodeRemovedFromDocument(node);
255	else if (node->isContainerNode())
256	notifyNodeRemovedFromTree(toContainerNode(node));
257	}
152		258
153	} // namespace WebCore	259	} // namespace WebCore
154		260

Lines 56-63 PassRefPtr<Node> DocumentType::cloneNode(bool /deep/) a/Source/WebCore/dom/DocumentType.cpp_sec1
- a/Source/WebCore/dom/DocumentType.cpp -5 / +10 lines
56	return create(document(), m_name, m_publicId, m_systemId);	56	return create(document(), m_name, m_publicId, m_systemId);
57	}	57	}
58		58
59	void DocumentType::insertedIntoDocument()	59	Node::InsertionNotificationRequest DocumentType::insertedInto(Node* insertionPoint)
60	{	60	{
		61	Node::insertedInto(insertionPoint);
		62	if (!insertionPoint->inDocument())
		63	return InsertionDone;
		64
61	// Our document node can be null if we were created by a DOMImplementation. We use the parent() instead.	65	// Our document node can be null if we were created by a DOMImplementation. We use the parent() instead.
62	ASSERT(parentNode() && parentNode()->isDocumentNode());	66	ASSERT(parentNode() && parentNode()->isDocumentNode());
63	if (parentNode() && parentNode()->isDocumentNode()) {	67	if (parentNode() && parentNode()->isDocumentNode()) {
Lines 65-78 void DocumentType::insertedIntoDocument() a/Source/WebCore/dom/DocumentType.cpp_sec2
65	if (!doc->doctype())	69	if (!doc->doctype())
66	doc->setDocType(this);	70	doc->setDocType(this);
67	}	71	}
68	Node::insertedIntoDocument();	72
		73	return InsertionDone;
69	}	74	}
70		75
71	void DocumentType::removedFromDocument()	76	void DocumentType::removedFrom(Node* insertionPoint)
72	{	77	{
73	if (document() && document()->doctype() == this)	78	if (insertionPoint->inDocument() && document() && document()->doctype() == this)
74	document()->setDocType(0);	79	document()->setDocType(0);
75	Node::removedFromDocument();	80	Node::removedFrom(insertionPoint);
76	}	81	}
77		82
78	}	83	}

Lines 54-61 private: a/Source/WebCore/dom/DocumentType.h_sec1
- a/Source/WebCore/dom/DocumentType.h -2 / +2 lines
54	virtual NodeType nodeType() const;	54	virtual NodeType nodeType() const;
55	virtual PassRefPtr<Node> cloneNode(bool deep);	55	virtual PassRefPtr<Node> cloneNode(bool deep);
56		56
57	virtual void insertedIntoDocument();	57	virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
58	virtual void removedFromDocument();	58	virtual void removedFrom(Node*) OVERRIDE;
59		59
60	OwnPtr<NamedNodeMap> m_entities;	60	OwnPtr<NamedNodeMap> m_entities;
61	OwnPtr<NamedNodeMap> m_notations;	61	OwnPtr<NamedNodeMap> m_notations;

Lines 413-422 protected: a/Source/WebCore/dom/Element.h_sec1
- a/Source/WebCore/dom/Element.h -4 / +2 lines
413	}	413	}
414		414
415	virtual void willRemove();	415	virtual void willRemove();
416	virtual void insertedIntoDocument();	416	virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
417	virtual void removedFromDocument();	417	virtual void removedFrom(Node*) OVERRIDE;
418	virtual void insertedIntoTree(bool);
419	virtual void removedFromTree(bool);
420	virtual void childrenChanged(bool changedByParser = false, Node* beforeChange = 0, Node* afterChange = 0, int childCountDelta = 0);	418	virtual void childrenChanged(bool changedByParser = false, Node* beforeChange = 0, Node* afterChange = 0, int childCountDelta = 0);
421	virtual bool willRecalcStyle(StyleChange) { return true; }	419	virtual bool willRecalcStyle(StyleChange) { return true; }
422	virtual void didRecalcStyle(StyleChange) { }	420	virtual void didRecalcStyle(StyleChange) { }

Lines 64-71 private: a/Source/WebCore/dom/ProcessingInstruction.h_sec1
- a/Source/WebCore/dom/ProcessingInstruction.h -2 / +2 lines
64	virtual bool offsetInCharacters() const;	64	virtual bool offsetInCharacters() const;
65	virtual int maxCharacterOffset() const;	65	virtual int maxCharacterOffset() const;
66		66
67	virtual void insertedIntoDocument();	67	virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
68	virtual void removedFromDocument();	68	virtual void removedFrom(Node*) OVERRIDE;
69		69
70	void checkStyleSheet();	70	void checkStyleSheet();
71	virtual void setCSSStyleSheet(const String& href, const KURL& baseURL, const String& charset, const CachedCSSStyleSheet*);	71	virtual void setCSSStyleSheet(const String& href, const KURL& baseURL, const String& charset, const CachedCSSStyleSheet*);

Lines 77-85 ScriptElement::~ScriptElement() a/Source/WebCore/dom/ScriptElement.cpp_sec1
- a/Source/WebCore/dom/ScriptElement.cpp -2 / +2 lines
77	stopLoadRequest();	77	stopLoadRequest();
78	}	78	}
79		79
80	void ScriptElement::insertedIntoDocument()	80	void ScriptElement::insertedInto(Node* insertionPoint)
81	{	81	{
82	if (!m_parserInserted)	82	if (insertionPoint->inDocument() && !m_parserInserted)
83	prepareScript(); // FIXME: Provide a real starting line number here.	83	prepareScript(); // FIXME: Provide a real starting line number here.
84	}	84	}
85		85

Lines 29-34 namespace WebCore { a/Source/WebCore/dom/ScriptElement.h_sec1
- a/Source/WebCore/dom/ScriptElement.h -1 / +2 lines
29		29
30	class CachedScript;	30	class CachedScript;
31	class Element;	31	class Element;
		32	class Node;
32	class ScriptElement;	33	class ScriptElement;
33	class ScriptSourceCode;	34	class ScriptSourceCode;
34		35
Lines 66-72 protected: a/Source/WebCore/dom/ScriptElement.h_sec2
66	bool forceAsync() const { return m_forceAsync; }	67	bool forceAsync() const { return m_forceAsync; }
67		68
68	// Helper functions used by our parent classes.	69	// Helper functions used by our parent classes.
69	void insertedIntoDocument();	70	void insertedInto(Node*);
70	void childrenChanged();	71	void childrenChanged();
71	void handleSourceAttribute(const String& sourceUrl);	72	void handleSourceAttribute(const String& sourceUrl);
72	void handleAsyncAttribute();	73	void handleAsyncAttribute();

Lines 28-33 a/Source/WebCore/dom/ShadowTree.cpp_sec1
- a/Source/WebCore/dom/ShadowTree.cpp -43 / +3 lines
28	#include "ShadowTree.h"	28	#include "ShadowTree.h"
29		29
30	#include "CSSStyleSelector.h"	30	#include "CSSStyleSelector.h"
		31	#include "ContainerNodeAlgorithms.h"
31	#include "Document.h"	32	#include "Document.h"
32	#include "Element.h"	33	#include "Element.h"
33	#include "HTMLShadowElement.h"	34	#include "HTMLShadowElement.h"
Lines 38-52 a/Source/WebCore/dom/ShadowTree.cpp_sec2
38		39
39	namespace WebCore {	40	namespace WebCore {
40		41
41	class ShadowRootVector : public Vector<RefPtr<ShadowRoot> > {
42	public:
43	explicit ShadowRootVector(ShadowTree* tree)
44	{
45	for (ShadowRoot* root = tree->youngestShadowRoot(); root; root = root->olderShadowRoot())
46	append(root);
47	}
48	};
49
50	ShadowTree::ShadowTree()	42	ShadowTree::ShadowTree()
51	: m_needsRecalculateContent(false)	43	: m_needsRecalculateContent(false)
52	{	44	{
Lines 85-93 void ShadowTree::addShadowRoot(Element* shadowHost, PassRefPtr<ShadowRoot> shado a/Source/WebCore/dom/ShadowTree.cpp_sec3
85	return;	77	return;
86		78
87	shadowRoot->setShadowHost(shadowHost);	79	shadowRoot->setShadowHost(shadowHost);
		80	ChildNodeInsertionNotifier(shadowHost).notify(shadowRoot.get());
88		81
89	if (shadowHost->inDocument())
90	shadowRoot->insertedIntoDocument();
91	if (shadowHost->attached()) {	82	if (shadowHost->attached()) {
92	shadowRoot->lazyAttach();	83	shadowRoot->lazyAttach();
93	detach();	84	detach();
Lines 117-160 void ShadowTree::removeAllShadowRoots() a/Source/WebCore/dom/ShadowTree.cpp_sec4
117	oldRoot->setPrev(0);	108	oldRoot->setPrev(0);
118	oldRoot->setNext(0);	109	oldRoot->setNext(0);
119	shadowHost->document()->adoptIfNeeded(oldRoot.get());	110	shadowHost->document()->adoptIfNeeded(oldRoot.get());
120	if (oldRoot->inDocument())	111	ChildNodeRemovalNotifier(shadowHost).notify(oldRoot.get());
121	oldRoot->removedFromDocument();
122	else
123	oldRoot->removedFromTree(true);
124	}	112	}
125		113
126	if (shadowHost->attached())	114	if (shadowHost->attached())
127	shadowHost->attachChildrenLazily();	115	shadowHost->attachChildrenLazily();
128	}	116	}
129		117
130	void ShadowTree::insertedIntoDocument()
131	{
132	ShadowRootVector roots(this);
133	for (size_t i = 0; i < roots.size(); ++i)
134	roots[i]->insertedIntoDocument();
135	}
136
137	void ShadowTree::removedFromDocument()
138	{
139	ShadowRootVector roots(this);
140	for (size_t i = 0; i < roots.size(); ++i)
141	roots[i]->removedFromDocument();
142	}
143
144	void ShadowTree::insertedIntoTree(bool deep)
145	{
146	ShadowRootVector roots(this);
147	for (size_t i = 0; i < roots.size(); ++i)
148	roots[i]->insertedIntoTree(deep);
149	}
150
151	void ShadowTree::removedFromTree(bool deep)
152	{
153	ShadowRootVector roots(this);
154	for (size_t i = 0; i < roots.size(); ++i)
155	roots[i]->removedFromTree(deep);
156	}
157
158	void ShadowTree::willRemove()	118	void ShadowTree::willRemove()
159	{	119	{
160	ShadowRootVector roots(this);	120	ShadowRootVector roots(this);

Lines 34-39 a/Source/WebCore/dom/ShadowTree.h_sec1
- a/Source/WebCore/dom/ShadowTree.h -4 / +10 lines
34	#include <wtf/Noncopyable.h>	34	#include <wtf/Noncopyable.h>
35	#include <wtf/OwnPtr.h>	35	#include <wtf/OwnPtr.h>
36	#include <wtf/PassRefPtr.h>	36	#include <wtf/PassRefPtr.h>
		37	#include <wtf/Vector.h>
37		38
38	namespace WebCore {	39	namespace WebCore {
39		40
Lines 57-66 public: a/Source/WebCore/dom/ShadowTree.h_sec2
57	void addShadowRoot(Element* shadowHost, PassRefPtr<ShadowRoot>, ExceptionCode&);	58	void addShadowRoot(Element* shadowHost, PassRefPtr<ShadowRoot>, ExceptionCode&);
58	void removeAllShadowRoots();	59	void removeAllShadowRoots();
59		60
60	void insertedIntoDocument();
61	void removedFromDocument();
62	void insertedIntoTree(bool deep);
63	void removedFromTree(bool deep);
64	void willRemove();	61	void willRemove();
65		62
66	void setParentTreeScope(TreeScope*);	63	void setParentTreeScope(TreeScope*);
Lines 130-135 inline Element* ShadowTree::host() const a/Source/WebCore/dom/ShadowTree.h_sec3
130	return youngestShadowRoot()->host();	127	return youngestShadowRoot()->host();
131	}	128	}
132		129
		130	class ShadowRootVector : public Vector<RefPtr<ShadowRoot> > {
		131	public:
		132	explicit ShadowRootVector(ShadowTree* tree)
		133	{
		134	for (ShadowRoot* root = tree->youngestShadowRoot(); root; root = root->olderShadowRoot())
		135	append(root);
		136	}
		137	};
		138
133	} // namespace	139	} // namespace
134		140
135	#endif	141	#endif

Lines 63-72 public: a/Source/WebCore/html/FormAssociatedElement.h_sec1
- a/Source/WebCore/html/FormAssociatedElement.h -4 / +2 lines
63	protected:	63	protected:
64	FormAssociatedElement();	64	FormAssociatedElement();
65		65
66	void insertedIntoTree();	66	void insertedInto(Node*);
67	void removedFromTree();	67	void removedFrom(Node*);
68	void insertedIntoDocument();
69	void removedFromDocument();
70	void didMoveToNewDocument(Document* oldDocument);	68	void didMoveToNewDocument(Document* oldDocument);
71		69
72	void setForm(HTMLFormElement*);	70	void setForm(HTMLFormElement*);

Lines 50-65 void HTMLBaseElement::parseAttribute(Attribute* attribute) a/Source/WebCore/html/HTMLBaseElement.cpp_sec1
- a/Source/WebCore/html/HTMLBaseElement.cpp -6 / +9 lines
50	HTMLElement::parseAttribute(attribute);	50	HTMLElement::parseAttribute(attribute);
51	}	51	}
52		52
53	void HTMLBaseElement::insertedIntoDocument()	53	Node::InsertionNotificationRequest HTMLBaseElement::insertedInto(Node* insertionPoint)
54	{	54	{
55	HTMLElement::insertedIntoDocument();	55	HTMLElement::insertedInto(insertionPoint);
56	document()->processBaseElement();	56	if (insertionPoint->inDocument())
		57	document()->processBaseElement();
		58	return InsertionDone;
57	}	59	}
58		60
59	void HTMLBaseElement::removedFromDocument()	61	void HTMLBaseElement::removedFrom(Node* insertionPoint)
60	{	62	{
61	HTMLElement::removedFromDocument();	63	HTMLElement::removedFrom(insertionPoint);
62	document()->processBaseElement();	64	if (insertionPoint->inDocument())
		65	document()->processBaseElement();
63	}	66	}
64		67
65	bool HTMLBaseElement::isURLAttribute(Attribute* attribute) const	68	bool HTMLBaseElement::isURLAttribute(Attribute* attribute) const

Lines 37-44 private: a/Source/WebCore/html/HTMLBaseElement.h_sec1
- a/Source/WebCore/html/HTMLBaseElement.h -2 / +2 lines
37	virtual String target() const;	37	virtual String target() const;
38	virtual bool isURLAttribute(Attribute*) const;	38	virtual bool isURLAttribute(Attribute*) const;
39	virtual void parseAttribute(Attribute*) OVERRIDE;	39	virtual void parseAttribute(Attribute*) OVERRIDE;
40	virtual void insertedIntoDocument();	40	virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
41	virtual void removedFromDocument();	41	virtual void removedFrom(Node*) OVERRIDE;
42	};	42	};
43		43
44	} // namespace	44	} // namespace

Lines 74-80 private: a/Source/WebCore/html/HTMLBodyElement.h_sec1
- a/Source/WebCore/html/HTMLBodyElement.h -1 / +2 lines
74	virtual bool isPresentationAttribute(const QualifiedName&) const OVERRIDE;	74	virtual bool isPresentationAttribute(const QualifiedName&) const OVERRIDE;
75	virtual void collectStyleForAttribute(Attribute, StylePropertySet) OVERRIDE;	75	virtual void collectStyleForAttribute(Attribute, StylePropertySet) OVERRIDE;
76		76
77	virtual void insertedIntoDocument();	77	virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
		78	virtual void didNotifyDescendantInseretions(Node*) OVERRIDE;
78		79
79	virtual bool isURLAttribute(Attribute*) const;	80	virtual bool isURLAttribute(Attribute*) const;
80		81

Lines 221-249 void HTMLFormControlElement::didMoveToNewDocument(Document* oldDocument) a/Source/WebCore/html/HTMLFormControlElement.cpp_sec1
- a/Source/WebCore/html/HTMLFormControlElement.cpp -18 / +7 lines
221	HTMLElement::didMoveToNewDocument(oldDocument);	221	HTMLElement::didMoveToNewDocument(oldDocument);
222	}	222	}
223		223
224	void HTMLFormControlElement::insertedIntoTree(bool deep)	224	Node::InsertionNotificationRequest HTMLFormControlElement::insertedInto(Node* insertionPoint)
225	{	225	{
226	FormAssociatedElement::insertedIntoTree();	226	HTMLElement::insertedInto(insertionPoint);
227	HTMLElement::insertedIntoTree(deep);	227	FormAssociatedElement::insertedInto(insertionPoint);
		228	return InsertionDone;
228	}	229	}
229		230
230	void HTMLFormControlElement::removedFromTree(bool deep)	231	void HTMLFormControlElement::removedFrom(Node* insertionPoint)
231	{	232	{
232	m_fieldSetAncestorValid = false;	233	m_fieldSetAncestorValid = false;
233	FormAssociatedElement::removedFromTree();	234	HTMLElement::removedFrom(insertionPoint);
234	HTMLElement::removedFromTree(deep);	235	FormAssociatedElement::removedFrom(insertionPoint);
235	}
236
237	void HTMLFormControlElement::insertedIntoDocument()
238	{
239	HTMLElement::insertedIntoDocument();
240	FormAssociatedElement::insertedIntoDocument();
241	}
242
243	void HTMLFormControlElement::removedFromDocument()
244	{
245	HTMLElement::removedFromDocument();
246	FormAssociatedElement::removedFromDocument();
247	}	236	}
248		237
249	const AtomicString& HTMLFormControlElement::formControlName() const	238	const AtomicString& HTMLFormControlElement::formControlName() const

Lines 120-129 protected: a/Source/WebCore/html/HTMLFormControlElement.h_sec1
- a/Source/WebCore/html/HTMLFormControlElement.h -4 / +2 lines
120	virtual void requiredAttributeChanged();	120	virtual void requiredAttributeChanged();
121	virtual void disabledAttributeChanged();	121	virtual void disabledAttributeChanged();
122	virtual void attach();	122	virtual void attach();
123	virtual void insertedIntoTree(bool deep);	123	virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
124	virtual void removedFromTree(bool deep);	124	virtual void removedFrom(Node*) OVERRIDE;
125	virtual void insertedIntoDocument();
126	virtual void removedFromDocument();
127	virtual void didMoveToNewDocument(Document* oldDocument) OVERRIDE;	125	virtual void didMoveToNewDocument(Document* oldDocument) OVERRIDE;
128		126
129	virtual bool supportsFocus() const;	127	virtual bool supportsFocus() const;

Lines 130-147 bool HTMLFormElement::rendererIsNeeded(const NodeRenderingContext& context) a/Source/WebCore/html/HTMLFormElement.cpp_sec1
- a/Source/WebCore/html/HTMLFormElement.cpp -10 / +12 lines
130	return formIsTablePart;	130	return formIsTablePart;
131	}	131	}
132		132
133	void HTMLFormElement::insertedIntoDocument()	133	Node::InsertionNotificationRequest HTMLFormElement::insertedInto(Node* insertionPoint)
134	{	134	{
135	HTMLElement::insertedIntoDocument();	135	HTMLElement::insertedInto(insertionPoint);
136		136	if (insertionPoint->inDocument())
137	if (hasID())	137	return InsertionShouldCallDidNotifyDescendantInseretions;
138	document()->resetFormElementsOwner();	138	return InsertionDone;
139	}	139	}
140		140
141	void HTMLFormElement::removedFromDocument()	141	void HTMLFormElement::didNotifyDescendantInseretions(Node* insertionPoint)
142	{	142	{
143	HTMLElement::removedFromDocument();	143	ASSERT(insertionPoint->inDocument());
144		144	HTMLElement::didNotifyDescendantInseretions(insertionPoint);
145	if (hasID())	145	if (hasID())
146	document()->resetFormElementsOwner();	146	document()->resetFormElementsOwner();
147	}	147	}
Lines 154-166 static inline Node* findRoot(Node* n) a/Source/WebCore/html/HTMLFormElement.cpp_sec2
154	return root;	154	return root;
155	}	155	}
156		156
157	void HTMLFormElement::removedFromTree(bool deep)	157	void HTMLFormElement::removedFrom(Node* insertionPoint)
158	{	158	{
159	Node* root = findRoot(this);	159	Node* root = findRoot(this);
160	Vector<FormAssociatedElement*> associatedElements(m_associatedElements);	160	Vector<FormAssociatedElement*> associatedElements(m_associatedElements);
161	for (unsigned i = 0; i < associatedElements.size(); ++i)	161	for (unsigned i = 0; i < associatedElements.size(); ++i)
162	associatedElements[i]->formRemovedFromTree(root);	162	associatedElements[i]->formRemovedFromTree(root);
163	HTMLElement::removedFromTree(deep);	163	HTMLElement::removedFrom(insertionPoint);
		164	if (insertionPoint->inDocument() && hasID())
		165	document()->resetFormElementsOwner();
164	}	166	}
165		167
166	void HTMLFormElement::handleLocalEvents(Event* event)	168	void HTMLFormElement::handleLocalEvents(Event* event)

Lines 115-123 private: a/Source/WebCore/html/HTMLFormElement.h_sec1
- a/Source/WebCore/html/HTMLFormElement.h -3 / +3 lines
115	HTMLFormElement(const QualifiedName&, Document*);	115	HTMLFormElement(const QualifiedName&, Document*);
116		116
117	virtual bool rendererIsNeeded(const NodeRenderingContext&);	117	virtual bool rendererIsNeeded(const NodeRenderingContext&);
118	virtual void insertedIntoDocument();	118	virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
119	virtual void removedFromDocument();	119	virtual void didNotifyDescendantInseretions(Node*) OVERRIDE;
120	virtual void removedFromTree(bool deep) OVERRIDE;	120	virtual void removedFrom(Node*) OVERRIDE;
121		121
122	virtual void handleLocalEvents(Event*);	122	virtual void handleLocalEvents(Event*);
123		123

Lines 153-161 void HTMLFrameElementBase::setNameAndOpenURL() a/Source/WebCore/html/HTMLFrameElementBase.cpp_sec1
- a/Source/WebCore/html/HTMLFrameElementBase.cpp -3 / +11 lines
153	openURL();	153	openURL();
154	}	154	}
155		155
156	void HTMLFrameElementBase::insertedIntoDocument()	156	Node::InsertionNotificationRequest HTMLFrameElementBase::insertedInto(Node* insertionPoint)
157	{	157	{
158	HTMLFrameOwnerElement::insertedIntoDocument();	158	HTMLFrameOwnerElement::insertedInto(insertionPoint);
		159	if (insertionPoint->inDocument())
		160	return InsertionShouldCallDidNotifyDescendantInseretions;
		161	return InsertionDone;
		162	}
		163
		164	void HTMLFrameElementBase::didNotifyDescendantInseretions(Node* insertionPoint)
		165	{
		166	ASSERT_UNUSED(insertionPoint, insertionPoint->inDocument());
159		167
160	// DocumentFragments don't kick of any loads.	168	// DocumentFragments don't kick of any loads.
161	if (!document()->frame())	169	if (!document()->frame())
Lines 165-171 void HTMLFrameElementBase::insertedIntoDocument() a/Source/WebCore/html/HTMLFrameElementBase.cpp_sec2
165	// during attribute parsing before the normal parser machinery would	173	// during attribute parsing before the normal parser machinery would
166	// attach the element. To support this, we lazyAttach here, but only	174	// attach the element. To support this, we lazyAttach here, but only
167	// if we don't already have a renderer (if we're inserted	175	// if we don't already have a renderer (if we're inserted
168	// as part of a DocumentFragment, insertedIntoDocument from an earlier element	176	// as part of a DocumentFragment, insertedInto from an earlier element
169	// could have forced a style resolve and already attached us).	177	// could have forced a style resolve and already attached us).
170	if (!renderer())	178	if (!renderer())
171	lazyAttach(DoNotSetAttached);	179	lazyAttach(DoNotSetAttached);

Lines 54-60 protected: a/Source/WebCore/html/HTMLFrameElementBase.h_sec1
- a/Source/WebCore/html/HTMLFrameElementBase.h -1 / +2 lines
54	bool isURLAllowed() const;	54	bool isURLAllowed() const;
55		55
56	virtual void parseAttribute(Attribute*) OVERRIDE;	56	virtual void parseAttribute(Attribute*) OVERRIDE;
57	virtual void insertedIntoDocument();	57	virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
		58	virtual void didNotifyDescendantInseretions(Node*) OVERRIDE;
58	virtual void attach();	59	virtual void attach();
59		60
60	private:	61	private:

Lines 100-119 RenderObject* HTMLIFrameElement::createRenderer(RenderArena* arena, RenderStyle* a/Source/WebCore/html/HTMLIFrameElement.cpp_sec1
- a/Source/WebCore/html/HTMLIFrameElement.cpp -8 / +7 lines
100	return new (arena) RenderIFrame(this);	100	return new (arena) RenderIFrame(this);
101	}	101	}
102		102
103	void HTMLIFrameElement::insertedIntoDocument()	103	Node::InsertionNotificationRequest HTMLIFrameElement::insertedInto(Node* insertionPoint)
104	{	104	{
105	if (document()->isHTMLDocument())	105	InsertionNotificationRequest result = HTMLFrameElementBase::insertedInto(insertionPoint);
		106	if (insertionPoint->inDocument() && document()->isHTMLDocument())
106	static_cast<HTMLDocument*>(document())->addExtraNamedItem(m_name);	107	static_cast<HTMLDocument*>(document())->addExtraNamedItem(m_name);
107		108	return result;
108	HTMLFrameElementBase::insertedIntoDocument();
109	}	109	}
110		110
111	void HTMLIFrameElement::removedFromDocument()	111	void HTMLIFrameElement::removedFrom(Node* insertionPoint)
112	{	112	{
113	if (document()->isHTMLDocument())	113	HTMLFrameElementBase::removedFrom(insertionPoint);
		114	if (insertionPoint->inDocument() && document()->isHTMLDocument())
114	static_cast<HTMLDocument*>(document())->removeExtraNamedItem(m_name);	115	static_cast<HTMLDocument*>(document())->removeExtraNamedItem(m_name);
115
116	HTMLFrameElementBase::removedFromDocument();
117	}	116	}
118		117
119	#if ENABLE(MICRODATA)	118	#if ENABLE(MICRODATA)

Lines 168-184 void HTMLImageElement::attach() a/Source/WebCore/html/HTMLImageElement.cpp_sec1
- a/Source/WebCore/html/HTMLImageElement.cpp -14 / +9 lines
168	}	168	}
169	}	169	}
170		170
171	void HTMLImageElement::insertedIntoDocument()	171	Node::InsertionNotificationRequest HTMLImageElement::insertedInto(Node* insertionPoint)
172	{
173	// If we have been inserted from a renderer-less document,
174	// our loader may have not fetched the image, so do it now.
175	if (!m_imageLoader.image())
176	m_imageLoader.updateFromElement();
177
178	HTMLElement::insertedIntoDocument();
179	}
180
181	void HTMLImageElement::insertedIntoTree(bool deep)
182	{	172	{
183	if (!m_form) {	173	if (!m_form) {
184	// m_form can be non-null if it was set in constructor.	174	// m_form can be non-null if it was set in constructor.
Lines 191-205 void HTMLImageElement::insertedIntoTree(bool deep) a/Source/WebCore/html/HTMLImageElement.cpp_sec2
191	}	181	}
192	}	182	}
193		183
194	HTMLElement::insertedIntoTree(deep);	184	// If we have been inserted from a renderer-less document,
		185	// our loader may have not fetched the image, so do it now.
		186	if (insertionPoint->inDocument() && !m_imageLoader.image())
		187	m_imageLoader.updateFromElement();
		188
		189	return HTMLElement::insertedInto(insertionPoint);
195	}	190	}
196		191
197	void HTMLImageElement::removedFromTree(bool deep)	192	void HTMLImageElement::removedFrom(Node* insertionPoint)
198	{	193	{
199	if (m_form)	194	if (m_form)
200	m_form->removeImgElement(this);	195	m_form->removeImgElement(this);
201	m_form = 0;	196	m_form = 0;
202	HTMLElement::removedFromTree(deep);	197	HTMLElement::removedFrom(insertionPoint);
203	}	198	}
204		199
205	int HTMLImageElement::width(bool ignorePendingStylesheets)	200	int HTMLImageElement::width(bool ignorePendingStylesheets)

Lines 99-108 private: a/Source/WebCore/html/HTMLImageElement.h_sec1
- a/Source/WebCore/html/HTMLImageElement.h -4 / +2 lines
99		99
100	virtual void addSubresourceAttributeURLs(ListHashSet<KURL>&) const;	100	virtual void addSubresourceAttributeURLs(ListHashSet<KURL>&) const;
101		101
102	virtual void insertedIntoDocument();	102	virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
103	virtual void insertedIntoTree(bool deep);	103	virtual void removedFrom(Node*) OVERRIDE;
104	virtual void removedFromTree(bool deep);
105
106	virtual bool shouldRegisterAsNamedItem() const OVERRIDE { return true; }	104	virtual bool shouldRegisterAsNamedItem() const OVERRIDE { return true; }
107	virtual bool shouldRegisterAsExtraNamedItem() const OVERRIDE { return true; }	105	virtual bool shouldRegisterAsExtraNamedItem() const OVERRIDE { return true; }
108		106

Lines 247-254 private: a/Source/WebCore/html/HTMLInputElement.h_sec1
- a/Source/WebCore/html/HTMLInputElement.h -2 / +2 lines
247		247
248	virtual void willChangeForm() OVERRIDE;	248	virtual void willChangeForm() OVERRIDE;
249	virtual void didChangeForm() OVERRIDE;	249	virtual void didChangeForm() OVERRIDE;
250	virtual void insertedIntoDocument() OVERRIDE;	250	virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
251	virtual void removedFromDocument() OVERRIDE;	251	virtual void removedFrom(Node*) OVERRIDE;
252	virtual void didMoveToNewDocument(Document* oldDocument) OVERRIDE;	252	virtual void didMoveToNewDocument(Document* oldDocument) OVERRIDE;
253		253
254	virtual bool isKeyboardFocusable(KeyboardEvent*) const;	254	virtual bool isKeyboardFocusable(KeyboardEvent*) const;

Lines 75-82 private: a/Source/WebCore/html/HTMLLinkElement.h_sec1
- a/Source/WebCore/html/HTMLLinkElement.h -2 / +2 lines
75	static void processCallback(Node*);	75	static void processCallback(Node*);
76	void clearSheet();	76	void clearSheet();
77		77
78	virtual void insertedIntoDocument();	78	virtual InsertionNotificationRequest insertedInto(Node*) OVERRIDE;
79	virtual void removedFromDocument();	79	virtual void removedFrom(Node*) OVERRIDE;
80		80
81	// from CachedResourceClient	81	// from CachedResourceClient
82	virtual void setCSSStyleSheet(const String& href, const KURL& baseURL, const String& charset, const CachedCSSStyleSheet* sheet);	82	virtual void setCSSStyleSheet(const String& href, const KURL& baseURL, const String& charset, const CachedCSSStyleSheet* sheet);