[CSS Regions] Elements in a region should be assignable to a named flow
[WebKit-https.git] / Source / WebCore / dom / NodeRenderingContext.cpp
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, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
7  * Copyright (C) 2011 Google Inc. All rights reserved.
8  *
9  * This library is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Library General Public
11  * License as published by the Free Software Foundation; either
12  * version 2 of the License, or (at your option) any later version.
13  *
14  * This library is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17  * Library General Public License for more details.
18  *
19  * You should have received a copy of the GNU Library General Public License
20  * along with this library; see the file COPYING.LIB.  If not, write to
21  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
22  * Boston, MA 02110-1301, USA.
23  *
24  */
25
26 #include "config.h"
27 #include "NodeRenderingContext.h"
28
29 #include "ContainerNode.h"
30 #include "ContentDistributor.h"
31 #include "ElementShadow.h"
32 #include "FlowThreadController.h"
33 #include "HTMLContentElement.h"
34 #include "HTMLInputElement.h"
35 #include "HTMLNames.h"
36 #include "HTMLShadowElement.h"
37 #include "Node.h"
38 #include "PseudoElement.h"
39 #include "RenderFullScreen.h"
40 #include "RenderNamedFlowThread.h"
41 #include "RenderObject.h"
42 #include "RenderText.h"
43 #include "RenderView.h"
44 #include "ShadowRoot.h"
45 #include "StyleInheritedData.h"
46 #include "StyleResolver.h"
47 #include "Text.h"
48
49 #if ENABLE(SVG)
50 #include "SVGNames.h"
51 #endif
52
53 namespace WebCore {
54
55 using namespace HTMLNames;
56
57 NodeRenderingContext::NodeRenderingContext(Node* node)
58     : m_node(node)
59     , m_parentFlowRenderer(0)
60 {
61     m_renderingParent = NodeRenderingTraversal::parent(node, &m_parentDetails);
62 }
63
64 NodeRenderingContext::NodeRenderingContext(Node* node, RenderStyle* style)
65     : m_node(node)
66     , m_renderingParent(0)
67     , m_style(style)
68     , m_parentFlowRenderer(0)
69 {
70 }
71
72 NodeRenderingContext::~NodeRenderingContext()
73 {
74 }
75
76 static bool isRendererReparented(const RenderObject* renderer)
77 {
78     if (!renderer->node()->isElementNode())
79         return false;
80     if (renderer->style() && !renderer->style()->flowThread().isEmpty())
81         return true;
82 #if ENABLE(DIALOG_ELEMENT)
83     if (toElement(renderer->node())->isInTopLayer())
84         return true;
85 #endif
86     return false;
87 }
88
89 RenderObject* NodeRenderingContext::nextRenderer() const
90 {
91     if (RenderObject* renderer = m_node->renderer())
92         return renderer->nextSibling();
93
94 #if ENABLE(DIALOG_ELEMENT)
95     Element* element = m_node->isElementNode() ? toElement(m_node) : 0;
96     if (element && element->isInTopLayer()) {
97         const Vector<RefPtr<Element> >& topLayerElements = element->document()->topLayerElements();
98         size_t position = topLayerElements.find(element);
99         ASSERT(position != notFound);
100         for (size_t i = position + 1; i < topLayerElements.size(); ++i) {
101             if (RenderObject* renderer = topLayerElements[i]->renderer())
102                 return renderer;
103         }
104         return 0;
105     }
106 #endif
107
108     if (m_parentFlowRenderer)
109         return m_parentFlowRenderer->nextRendererForNode(m_node);
110
111     // Avoid an O(N^2) problem with this function by not checking for
112     // nextRenderer() when the parent element hasn't attached yet.
113     if (m_renderingParent && !m_renderingParent->attached())
114         return 0;
115
116     for (Node* sibling = NodeRenderingTraversal::nextSibling(m_node); sibling; sibling = NodeRenderingTraversal::nextSibling(sibling)) {
117         RenderObject* renderer = sibling->renderer();
118         if (renderer && !isRendererReparented(renderer))
119             return renderer;
120     }
121
122     return 0;
123 }
124
125 RenderObject* NodeRenderingContext::previousRenderer() const
126 {
127     if (RenderObject* renderer = m_node->renderer())
128         return renderer->previousSibling();
129
130 #if ENABLE(DIALOG_ELEMENT)
131     // FIXME: This doesn't work correctly for things in the top layer that are
132     // display: none. We'd need to duplicate the logic in nextRenderer, but since
133     // nothing needs that yet just assert.
134     ASSERT(!m_node->isElementNode() || !toElement(m_node)->isInTopLayer());
135 #endif
136
137     if (m_parentFlowRenderer)
138         return m_parentFlowRenderer->previousRendererForNode(m_node);
139
140     // FIXME: We should have the same O(N^2) avoidance as nextRenderer does
141     // however, when I tried adding it, several tests failed.
142     for (Node* sibling = NodeRenderingTraversal::previousSibling(m_node); sibling; sibling = NodeRenderingTraversal::previousSibling(sibling)) {
143         RenderObject* renderer = sibling->renderer();
144         if (renderer && !isRendererReparented(renderer))
145             return renderer;
146     }
147
148     return 0;
149 }
150
151 RenderObject* NodeRenderingContext::parentRenderer()
152 {
153     if (RenderObject* renderer = m_node->renderer())
154         return renderer->parent();
155
156 #if ENABLE(DIALOG_ELEMENT)
157     if (m_node->isElementNode() && toElement(m_node)->isInTopLayer()) {
158         // The parent renderer of top layer elements is the RenderView, but only
159         // if the normal parent would have had a renderer.
160         // FIXME: This behavior isn't quite right as the spec for top layer
161         // only talks about display: none ancestors so putting a <dialog> inside
162         // an <optgroup> seems like it should still work even though this check
163         // will prevent it.
164         if (!m_renderingParent || !m_renderingParent->renderer())
165             return 0;
166         return m_node->document()->renderView();
167     }
168 #endif
169
170     if (m_parentFlowRenderer)
171         return m_parentFlowRenderer;
172
173     if (m_node->isElementNode() && toElement(m_node)->moveToFlowThreadIsNeeded(m_style)) {
174         moveToFlowThread();
175         return m_parentFlowRenderer;
176     }
177
178     return m_renderingParent ? m_renderingParent->renderer() : 0;
179 }
180
181 bool NodeRenderingContext::shouldCreateRenderer()
182 {
183     if (!m_node->document()->shouldCreateRenderers())
184         return false;
185     if (!m_renderingParent)
186         return false;
187     RenderObject* parentRenderer = this->parentRenderer();
188     if (!parentRenderer)
189         return false;
190     if (!parentRenderer->canHaveChildren()) {
191         if (parentRenderer->canDOMChildrenHaveRenderParent()) {
192             // In a region, only the children that need to be in a flow thread should have a renderer.
193             bool shouldBeInNamedFlow = m_node->isElementNode() && toElement(m_node)->moveToFlowThreadIsNeeded(m_style);
194             if (!shouldBeInNamedFlow)
195                 return false;
196         } else
197             return false;
198     }
199
200     if (!m_renderingParent->childShouldCreateRenderer(*this))
201         return false;
202     return true;
203 }
204
205 void NodeRenderingContext::moveToFlowThreadIfNeeded()
206 {
207     ASSERT(m_node->isElementNode());
208
209     if (!toElement(m_node)->moveToFlowThreadIsNeeded(m_style))
210         return;
211
212     moveToFlowThread();
213 }
214
215 void NodeRenderingContext::moveToFlowThread()
216 {
217     ASSERT(m_node->isElementNode());
218     ASSERT(toElement(m_node)->moveToFlowThreadIsNeeded(m_style));
219
220     if (!m_style)
221         m_style = toElement(m_node)->styleForRenderer();
222     ASSERT(m_style);
223     m_flowThread = m_style->flowThread();
224     ASSERT(m_node->document()->renderView());
225     FlowThreadController* flowThreadController = m_node->document()->renderView()->flowThreadController();
226     m_parentFlowRenderer = flowThreadController->ensureRenderFlowThreadWithName(m_flowThread);
227     flowThreadController->registerNamedFlowContentNode(m_node, m_parentFlowRenderer);
228 }
229
230 bool NodeRenderingContext::isOnEncapsulationBoundary() const
231 {
232     return isOnUpperEncapsulationBoundary() || isLowerEncapsulationBoundary(m_parentDetails.insertionPoint()) || isLowerEncapsulationBoundary(m_node->parentNode());
233 }
234
235 bool NodeRenderingContext::isOnUpperEncapsulationBoundary() const
236 {
237     return m_node->parentNode() && m_node->parentNode()->isShadowRoot();
238 }
239
240 void NodeRenderingContext::createRendererForElementIfNeeded()
241 {
242     ASSERT(!m_node->renderer());
243
244     Element* element = toElement(m_node);
245
246     if (!shouldCreateRenderer())
247         return;
248     m_style = element->styleForRenderer();
249     ASSERT(m_style);
250
251     moveToFlowThreadIfNeeded();
252
253     if (!element->rendererIsNeeded(*this))
254         return;
255
256     RenderObject* parentRenderer = this->parentRenderer();
257     RenderObject* nextRenderer = this->nextRenderer();
258
259     Document* document = element->document();
260     RenderObject* newRenderer = element->createRenderer(document->renderArena(), m_style.get());
261     if (!newRenderer)
262         return;
263     if (!parentRenderer->isChildAllowed(newRenderer, m_style.get())) {
264         newRenderer->destroy();
265         return;
266     }
267
268     // Make sure the RenderObject already knows it is going to be added to a RenderFlowThread before we set the style
269     // for the first time. Otherwise code using inRenderFlowThread() in the styleWillChange and styleDidChange will fail.
270     newRenderer->setFlowThreadState(parentRenderer->flowThreadState());
271
272     element->setRenderer(newRenderer);
273     newRenderer->setAnimatableStyle(m_style.release()); // setAnimatableStyle() can depend on renderer() already being set.
274
275 #if ENABLE(FULLSCREEN_API)
276     if (document->webkitIsFullScreen() && document->webkitCurrentFullScreenElement() == element) {
277         newRenderer = RenderFullScreen::wrapRenderer(newRenderer, parentRenderer, document);
278         if (!newRenderer)
279             return;
280     }
281 #endif
282     // Note: Adding newRenderer instead of renderer(). renderer() may be a child of newRenderer.
283     parentRenderer->addChild(newRenderer, nextRenderer);
284 }
285
286 void NodeRenderingContext::createRendererForTextIfNeeded()
287 {
288     ASSERT(!m_node->renderer());
289
290     Text* textNode = toText(m_node);
291
292     if (!shouldCreateRenderer())
293         return;
294
295     RenderObject* parentRenderer = this->parentRenderer();
296     ASSERT(parentRenderer);
297     Document* document = textNode->document();
298
299     if (resetStyleInheritance())
300         m_style = document->styleResolver()->defaultStyleForElement();
301     else
302         m_style = parentRenderer->style();
303
304     if (!textNode->textRendererIsNeeded(*this))
305         return;
306     RenderText* newRenderer = textNode->createTextRenderer(document->renderArena(), m_style.get());
307     if (!newRenderer)
308         return;
309     if (!parentRenderer->isChildAllowed(newRenderer, m_style.get())) {
310         newRenderer->destroy();
311         return;
312     }
313
314     // Make sure the RenderObject already knows it is going to be added to a RenderFlowThread before we set the style
315     // for the first time. Otherwise code using inRenderFlowThread() in the styleWillChange and styleDidChange will fail.
316     newRenderer->setFlowThreadState(parentRenderer->flowThreadState());
317
318     RenderObject* nextRenderer = this->nextRenderer();
319     textNode->setRenderer(newRenderer);
320     // Parent takes care of the animations, no need to call setAnimatableStyle.
321     newRenderer->setStyle(m_style.release());
322     parentRenderer->addChild(newRenderer, nextRenderer);
323 }
324
325 }