e84c5e41598c4da8c116e26b1d1b5e7374d60385
[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() const
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     return m_renderingParent ? m_renderingParent->renderer() : 0;
174 }
175
176 bool NodeRenderingContext::shouldCreateRenderer() const
177 {
178     if (!m_node->document()->shouldCreateRenderers())
179         return false;
180     if (!m_renderingParent)
181         return false;
182     RenderObject* parentRenderer = this->parentRenderer();
183     if (!parentRenderer)
184         return false;
185     if (!parentRenderer->canHaveChildren())
186         return false;
187     if (!m_renderingParent->childShouldCreateRenderer(*this))
188         return false;
189     return true;
190 }
191
192 void NodeRenderingContext::moveToFlowThreadIfNeeded()
193 {
194     ASSERT(m_node->isElementNode());
195     ASSERT(m_style);
196     if (!m_node->document()->cssRegionsEnabled())
197         return;
198
199     if (m_style->flowThread().isEmpty())
200         return;
201
202     // As per http://dev.w3.org/csswg/css3-regions/#flow-into, pseudo-elements such as ::first-line, ::first-letter, ::before or ::after
203     // cannot be directly collected into a named flow.
204     if (m_node->isPseudoElement())
205         return;
206
207     // FIXME: Do not collect elements if they are in shadow tree.
208     if (m_node->isInShadowTree())
209         return;
210
211 #if ENABLE(FULLSCREEN_API)
212     Document* document = m_node->document();
213     if (document->webkitIsFullScreen() && document->webkitCurrentFullScreenElement() == m_node)
214         return;
215 #endif
216
217 #if ENABLE(SVG)
218     // Allow only svg root elements to be directly collected by a render flow thread.
219     if (m_node->isSVGElement()
220         && (!(m_node->hasTagName(SVGNames::svgTag) && m_node->parentNode() && !m_node->parentNode()->isSVGElement())))
221         return;
222 #endif
223
224     m_flowThread = m_style->flowThread();
225     ASSERT(m_node->document()->renderView());
226     FlowThreadController* flowThreadController = m_node->document()->renderView()->flowThreadController();
227     m_parentFlowRenderer = flowThreadController->ensureRenderFlowThreadWithName(m_flowThread);
228     flowThreadController->registerNamedFlowContentNode(m_node, m_parentFlowRenderer);
229 }
230
231 bool NodeRenderingContext::isOnEncapsulationBoundary() const
232 {
233     return isOnUpperEncapsulationBoundary() || isLowerEncapsulationBoundary(m_parentDetails.insertionPoint()) || isLowerEncapsulationBoundary(m_node->parentNode());
234 }
235
236 bool NodeRenderingContext::isOnUpperEncapsulationBoundary() const
237 {
238     return m_node->parentNode() && m_node->parentNode()->isShadowRoot();
239 }
240
241 void NodeRenderingContext::createRendererForElementIfNeeded()
242 {
243     ASSERT(!m_node->renderer());
244
245     Element* element = toElement(m_node);
246
247     if (!shouldCreateRenderer())
248         return;
249     m_style = element->styleForRenderer();
250     ASSERT(m_style);
251
252     moveToFlowThreadIfNeeded();
253
254     if (!element->rendererIsNeeded(*this))
255         return;
256
257     RenderObject* parentRenderer = this->parentRenderer();
258     RenderObject* nextRenderer = this->nextRenderer();
259
260     Document* document = element->document();
261     RenderObject* newRenderer = element->createRenderer(document->renderArena(), m_style.get());
262     if (!newRenderer)
263         return;
264     if (!parentRenderer->isChildAllowed(newRenderer, m_style.get())) {
265         newRenderer->destroy();
266         return;
267     }
268
269     // Make sure the RenderObject already knows it is going to be added to a RenderFlowThread before we set the style
270     // for the first time. Otherwise code using inRenderFlowThread() in the styleWillChange and styleDidChange will fail.
271     newRenderer->setFlowThreadState(parentRenderer->flowThreadState());
272
273     element->setRenderer(newRenderer);
274     newRenderer->setAnimatableStyle(m_style.release()); // setAnimatableStyle() can depend on renderer() already being set.
275
276 #if ENABLE(FULLSCREEN_API)
277     if (document->webkitIsFullScreen() && document->webkitCurrentFullScreenElement() == element) {
278         newRenderer = RenderFullScreen::wrapRenderer(newRenderer, parentRenderer, document);
279         if (!newRenderer)
280             return;
281     }
282 #endif
283     // Note: Adding newRenderer instead of renderer(). renderer() may be a child of newRenderer.
284     parentRenderer->addChild(newRenderer, nextRenderer);
285 }
286
287 void NodeRenderingContext::createRendererForTextIfNeeded()
288 {
289     ASSERT(!m_node->renderer());
290
291     Text* textNode = toText(m_node);
292
293     if (!shouldCreateRenderer())
294         return;
295
296     RenderObject* parentRenderer = this->parentRenderer();
297     ASSERT(parentRenderer);
298     Document* document = textNode->document();
299
300     if (resetStyleInheritance())
301         m_style = document->styleResolver()->defaultStyleForElement();
302     else
303         m_style = parentRenderer->style();
304
305     if (!textNode->textRendererIsNeeded(*this))
306         return;
307     RenderText* newRenderer = textNode->createTextRenderer(document->renderArena(), m_style.get());
308     if (!newRenderer)
309         return;
310     if (!parentRenderer->isChildAllowed(newRenderer, m_style.get())) {
311         newRenderer->destroy();
312         return;
313     }
314
315     // Make sure the RenderObject already knows it is going to be added to a RenderFlowThread before we set the style
316     // for the first time. Otherwise code using inRenderFlowThread() in the styleWillChange and styleDidChange will fail.
317     newRenderer->setFlowThreadState(parentRenderer->flowThreadState());
318
319     RenderObject* nextRenderer = this->nextRenderer();
320     textNode->setRenderer(newRenderer);
321     // Parent takes care of the animations, no need to call setAnimatableStyle.
322     newRenderer->setStyle(m_style.release());
323     parentRenderer->addChild(newRenderer, nextRenderer);
324 }
325
326 }