Attachment #176385 for bug #103477

View Details Raw Unified Return to Bug 103477

| Differences between



2012-11-27  Elliott Sprehn  <esprehn@chromium.org>

        Make NodeRenderingContext::parentRenderer and nextRenderer htop layer aware
        https://bugs.webkit.org/show_bug.cgi?id=103477

        Reviewed by NOBODY (OOPS!).

        Instead of using adjustInsertionPointForTopLayerElement and reassigning
        pointers passed by reference we should just make nextRenderer and parentRenderer
        handle the top layer properly. Right now they would return the wrong values
        since we only correctly handle the top layer during renderer creation.

        This makes handling of top layer elements consistent with handling of
        other special renderering systems like flow threads.

        No new tests, just refactoring.

        * dom/NodeRenderingContext.cpp:
        (WebCore::adjustInsertionPointForTopLayerElement): Removed this method.
        (WebCore::NodeRenderingContext::nextRenderer):
        (WebCore::NodeRenderingContext::previousRenderer):
        (WebCore::NodeRenderingContext::parentRenderer):
        (WebCore::NodeRenderingContext::createRendererForElementIfNeeded):

2012-11-27  Dean Jackson  <dino@apple.com>

        Attempted build fix after http://trac.webkit.org/changeset/135888.



    if (RenderObject* renderer = m_node->renderer())
        return renderer->nextSibling();

#if ENABLE(DIALOG_ELEMENT)
    Element* element = m_node->isElementNode() ? toElement(m_node) : 0;
    if (element && element->isInTopLayer()) {
        const Vector<RefPtr<Element> >& topLayerElements = element->document()->topLayerElements();
        size_t position = topLayerElements.find(element);
        ASSERT(position != notFound);
        for (size_t i = position + 1; i < topLayerElements.size(); ++i) {
            if (RenderObject* renderer = topLayerElements[i]->renderer())
                return renderer;
        }
        return 0;
    }
#endif

    if (m_parentFlowRenderer)
        return m_parentFlowRenderer->nextRendererForNode(m_node);


    if (RenderObject* renderer = m_node->renderer())
        return renderer->previousSibling();

#if ENABLE(DIALOG_ELEMENT)
    // FIXME: This doesn't work correctly for things in the top layer that are
    // display: none. We'd need to duplicate the logic in nextRenderer, but since
    // nothing needs that yet just assert.
    ASSERT(!m_node->isElementNode() || !toElement(m_node)->isInTopLayer());
#endif

    if (m_parentFlowRenderer)
        return m_parentFlowRenderer->previousRendererForNode(m_node);


{
    if (RenderObject* renderer = m_node->renderer())
        return renderer->parent();

#if ENABLE(DIALOG_ELEMENT)
    if (m_node->isElementNode() && toElement(m_node)->isInTopLayer())
        return m_node->document()->renderView();
#endif

    if (m_parentFlowRenderer)
        return m_parentFlowRenderer;


    return m_node->parentNode() && m_node->parentNode()->isShadowRoot();
}

#if ENABLE(DIALOG_ELEMENT)
static void adjustInsertionPointForTopLayerElement(Element* element, RenderObject*& parentRenderer, RenderObject*& nextRenderer)
{
    parentRenderer = parentRenderer->view();
    nextRenderer = 0;
    const Vector<RefPtr<Element> >& topLayerElements = element->document()->topLayerElements();
    size_t topLayerPosition = topLayerElements.find(element);
    ASSERT(topLayerPosition != notFound);
    // Find the next top layer renderer that's stacked above this element. Note that the immediate next element in the top layer
    // stack might not have a renderer (due to display: none, or possibly it is not attached yet).
    for (size_t i = topLayerPosition + 1; i < topLayerElements.size(); ++i) {
        nextRenderer = topLayerElements[i]->renderer();
        if (nextRenderer) {
            ASSERT(nextRenderer->parent() == parentRenderer);
            break;
        }
    }
}
#endif

void NodeRenderingContext::createRendererForElementIfNeeded()
{
    ASSERT(!m_node->renderer());

    RenderObject* parentRenderer = this->parentRenderer();
    RenderObject* nextRenderer = this->nextRenderer();

#if ENABLE(DIALOG_ELEMENT)
    if (element->isInTopLayer())
        adjustInsertionPointForTopLayerElement(element, parentRenderer, nextRenderer);
#endif

    Document* document = element->document();
    RenderObject* newRenderer = element->createRenderer(document->renderArena(), m_style.get());
    if (!newRenderer)

Return to Bug 103477

Lines 75-80 RenderObject* NodeRenderingContext::nextRenderer() const a/Source/WebCore/dom/NodeRenderingContext.cpp_sec1
- a/Source/WebCore/dom/NodeRenderingContext.cpp -25 / +27 lines
75	if (RenderObject* renderer = m_node->renderer())	75	if (RenderObject* renderer = m_node->renderer())
76	return renderer->nextSibling();	76	return renderer->nextSibling();
77		77
		78	#if ENABLE(DIALOG_ELEMENT)
		79	Element* element = m_node->isElementNode() ? toElement(m_node) : 0;
		80	if (element && element->isInTopLayer()) {
		81	const Vector<RefPtr<Element> >& topLayerElements = element->document()->topLayerElements();
		82	size_t position = topLayerElements.find(element);
		83	ASSERT(position != notFound);
		84	for (size_t i = position + 1; i < topLayerElements.size(); ++i) {
		85	if (RenderObject* renderer = topLayerElements[i]->renderer())
		86	return renderer;
		87	}
		88	return 0;
		89	}
		90	#endif
		91
78	if (m_parentFlowRenderer)	92	if (m_parentFlowRenderer)
79	return m_parentFlowRenderer->nextRendererForNode(m_node);	93	return m_parentFlowRenderer->nextRendererForNode(m_node);
80		94
Lines 101-106 RenderObject* NodeRenderingContext::previousRenderer() const a/Source/WebCore/dom/NodeRenderingContext.cpp_sec2
101	if (RenderObject* renderer = m_node->renderer())	115	if (RenderObject* renderer = m_node->renderer())
102	return renderer->previousSibling();	116	return renderer->previousSibling();
103		117
		118	#if ENABLE(DIALOG_ELEMENT)
		119	// FIXME: This doesn't work correctly for things in the top layer that are
		120	// display: none. We'd need to duplicate the logic in nextRenderer, but since
		121	// nothing needs that yet just assert.
		122	ASSERT(!m_node->isElementNode() \|\| !toElement(m_node)->isInTopLayer());
		123	#endif
		124
104	if (m_parentFlowRenderer)	125	if (m_parentFlowRenderer)
105	return m_parentFlowRenderer->previousRendererForNode(m_node);	126	return m_parentFlowRenderer->previousRendererForNode(m_node);
106		127
Lines 124-129 RenderObject* NodeRenderingContext::parentRenderer() const a/Source/WebCore/dom/NodeRenderingContext.cpp_sec3
124	{	145	{
125	if (RenderObject* renderer = m_node->renderer())	146	if (RenderObject* renderer = m_node->renderer())
126	return renderer->parent();	147	return renderer->parent();
		148
		149	#if ENABLE(DIALOG_ELEMENT)
		150	if (m_node->isElementNode() && toElement(m_node)->isInTopLayer())
		151	return m_node->document()->renderView();
		152	#endif
		153
127	if (m_parentFlowRenderer)	154	if (m_parentFlowRenderer)
128	return m_parentFlowRenderer;	155	return m_parentFlowRenderer;
129		156
Lines 184-209 bool NodeRenderingContext::isOnUpperEncapsulationBoundary() const a/Source/WebCore/dom/NodeRenderingContext.cpp_sec4
184	return m_node->parentNode() && m_node->parentNode()->isShadowRoot();	211	return m_node->parentNode() && m_node->parentNode()->isShadowRoot();
185	}	212	}
186		213
187	#if ENABLE(DIALOG_ELEMENT)
188	static void adjustInsertionPointForTopLayerElement(Element* element, RenderObject& parentRenderer, RenderObject& nextRenderer)
189	{
190	parentRenderer = parentRenderer->view();
191	nextRenderer = 0;
192	const Vector<RefPtr<Element> >& topLayerElements = element->document()->topLayerElements();
193	size_t topLayerPosition = topLayerElements.find(element);
194	ASSERT(topLayerPosition != notFound);
195	// Find the next top layer renderer that's stacked above this element. Note that the immediate next element in the top layer
196	// stack might not have a renderer (due to display: none, or possibly it is not attached yet).
197	for (size_t i = topLayerPosition + 1; i < topLayerElements.size(); ++i) {
198	nextRenderer = topLayerElements[i]->renderer();
199	if (nextRenderer) {
200	ASSERT(nextRenderer->parent() == parentRenderer);
201	break;
202	}
203	}
204	}
205	#endif
206
207	void NodeRenderingContext::createRendererForElementIfNeeded()	214	void NodeRenderingContext::createRendererForElementIfNeeded()
208	{	215	{
209	ASSERT(!m_node->renderer());	216	ASSERT(!m_node->renderer());
Lines 225-235 void NodeRenderingContext::createRendererForElementIfNeeded() a/Source/WebCore/dom/NodeRenderingContext.cpp_sec5
225	RenderObject* parentRenderer = this->parentRenderer();	232	RenderObject* parentRenderer = this->parentRenderer();
226	RenderObject* nextRenderer = this->nextRenderer();	233	RenderObject* nextRenderer = this->nextRenderer();
227		234
228	#if ENABLE(DIALOG_ELEMENT)
229	if (element->isInTopLayer())
230	adjustInsertionPointForTopLayerElement(element, parentRenderer, nextRenderer);
231	#endif
232
233	Document* document = element->document();	235	Document* document = element->document();
234	RenderObject* newRenderer = element->createRenderer(document->renderArena(), m_style.get());	236	RenderObject* newRenderer = element->createRenderer(document->renderArena(), m_style.get());
235	if (!newRenderer)	237	if (!newRenderer)

Lines 1-3 a/Source/WebCore/ChangeLog_sec1
- a/Source/WebCore/ChangeLog +24 lines
		1	2012-11-27 Elliott Sprehn <esprehn@chromium.org>
		2
		3	Make NodeRenderingContext::parentRenderer and nextRenderer htop layer aware
		4	https://bugs.webkit.org/show_bug.cgi?id=103477
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	Instead of using adjustInsertionPointForTopLayerElement and reassigning
		9	pointers passed by reference we should just make nextRenderer and parentRenderer
		10	handle the top layer properly. Right now they would return the wrong values
		11	since we only correctly handle the top layer during renderer creation.
		12
		13	This makes handling of top layer elements consistent with handling of
		14	other special renderering systems like flow threads.
		15
		16	No new tests, just refactoring.
		17
		18	* dom/NodeRenderingContext.cpp:
		19	(WebCore::adjustInsertionPointForTopLayerElement): Removed this method.
		20	(WebCore::NodeRenderingContext::nextRenderer):
		21	(WebCore::NodeRenderingContext::previousRenderer):
		22	(WebCore::NodeRenderingContext::parentRenderer):
		23	(WebCore::NodeRenderingContext::createRendererForElementIfNeeded):
		24
1	2012-11-27 Dean Jackson <dino@apple.com>	25	2012-11-27 Dean Jackson <dino@apple.com>
2		26
3	Attempted build fix after http://trac.webkit.org/changeset/135888.	27	Attempted build fix after http://trac.webkit.org/changeset/135888.