Introduce RenderTreeBuilder
[WebKit-https.git] / Source / WebCore / rendering / RenderRuby.cpp
1 /*
2  * Copyright (C) 2009 Google Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions are
6  * met:
7  *
8  *     * Redistributions of source code must retain the above copyright
9  * notice, this list of conditions and the following disclaimer.
10  *     * Redistributions in binary form must reproduce the above
11  * copyright notice, this list of conditions and the following disclaimer
12  * in the documentation and/or other materials provided with the
13  * distribution.
14  *     * Neither the name of Google Inc. nor the names of its
15  * contributors may be used to endorse or promote products derived from
16  * this software without specific prior written permission.
17  *
18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29  */
30
31 #include "config.h"
32
33 #include "RenderRuby.h"
34
35 #include "RenderIterator.h"
36 #include "RenderRubyRun.h"
37 #include "RenderStyle.h"
38 #include "RenderTreeBuilder.h"
39 #include "StyleInheritedData.h"
40 #include <wtf/IsoMallocInlines.h>
41 #include <wtf/RefPtr.h>
42
43 namespace WebCore {
44
45 WTF_MAKE_ISO_ALLOCATED_IMPL(RenderRubyAsInline);
46 WTF_MAKE_ISO_ALLOCATED_IMPL(RenderRubyAsBlock);
47
48 //=== generic helper functions to avoid excessive code duplication ===
49
50 static inline bool isAnonymousRubyInlineBlock(const RenderObject* object)
51 {
52     ASSERT(!object
53         || !isRuby(object->parent())
54         || is<RenderRubyRun>(*object)
55         || (object->isInline() && (object->isBeforeContent() || object->isAfterContent()))
56         || (object->isAnonymous() && is<RenderBlock>(*object) && object->style().display() == INLINE_BLOCK));
57
58     return object
59         && isRuby(object->parent())
60         && is<RenderBlock>(*object)
61         && !is<RenderRubyRun>(*object);
62 }
63
64 static inline bool isRubyBeforeBlock(const RenderObject* object)
65 {
66     return isAnonymousRubyInlineBlock(object)
67         && !object->previousSibling()
68         && downcast<RenderBlock>(*object).firstChild()
69         && downcast<RenderBlock>(*object).firstChild()->style().styleType() == BEFORE;
70 }
71
72 static inline bool isRubyAfterBlock(const RenderObject* object)
73 {
74     return isAnonymousRubyInlineBlock(object)
75         && !object->nextSibling()
76         && downcast<RenderBlock>(*object).firstChild()
77         && downcast<RenderBlock>(*object).firstChild()->style().styleType() == AFTER;
78 }
79
80 #ifndef ASSERT_DISABLED
81 static inline bool isRubyChildForNormalRemoval(const RenderObject& object)
82 {
83     return object.isRubyRun()
84     || object.isBeforeContent()
85     || object.isAfterContent()
86     || object.isRenderMultiColumnFlow()
87     || object.isRenderMultiColumnSet()
88     || isAnonymousRubyInlineBlock(&object);
89 }
90 #endif
91
92 static inline RenderBlock* rubyBeforeBlock(const RenderElement* ruby)
93 {
94     RenderObject* child = ruby->firstChild();
95     return isRubyBeforeBlock(child) ? downcast<RenderBlock>(child) : nullptr;
96 }
97
98 static inline RenderBlock* rubyAfterBlock(const RenderElement* ruby)
99 {
100     RenderObject* child = ruby->lastChild();
101     return isRubyAfterBlock(child) ? downcast<RenderBlock>(child) : nullptr;
102 }
103
104 static auto createAnonymousRubyInlineBlock(RenderObject& ruby)
105 {
106     auto newBlock = createRenderer<RenderBlockFlow>(ruby.document(), RenderStyle::createAnonymousStyleWithDisplay(ruby.style(), INLINE_BLOCK));
107     newBlock->initializeStyle();
108     return newBlock;
109 }
110
111 static RenderRubyRun* lastRubyRun(const RenderElement* ruby)
112 {
113     RenderObject* child = ruby->lastChild();
114     if (child && !is<RenderRubyRun>(*child))
115         child = child->previousSibling();
116     if (!is<RenderRubyRun>(child)) {
117         ASSERT(!child || child->isBeforeContent() || child == rubyBeforeBlock(ruby));
118         return nullptr;
119     }
120     return downcast<RenderRubyRun>(child);
121 }
122
123 static inline RenderRubyRun& findRubyRunParent(RenderObject& child)
124 {
125     return *lineageOfType<RenderRubyRun>(child).first();
126 }
127
128 //=== ruby as inline object ===
129
130 RenderRubyAsInline::RenderRubyAsInline(Element& element, RenderStyle&& style)
131     : RenderInline(element, WTFMove(style))
132 {
133 }
134
135 RenderRubyAsInline::~RenderRubyAsInline() = default;
136
137 void RenderRubyAsInline::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle)
138 {
139     RenderInline::styleDidChange(diff, oldStyle);
140     propagateStyleToAnonymousChildren(PropagateToAllChildren);
141 }
142
143 void RenderRubyAsInline::addChild(RenderTreeBuilder& builder, RenderPtr<RenderObject> child, RenderObject* beforeChild)
144 {
145     // Insert :before and :after content before/after the RenderRubyRun(s)
146     if (child->isBeforeContent()) {
147         if (child->isInline()) {
148             // Add generated inline content normally
149             RenderInline::addChild(builder, WTFMove(child), firstChild());
150         } else {
151             // Wrap non-inline content with an anonymous inline-block.
152             RenderBlock* beforeBlock = rubyBeforeBlock(this);
153             if (!beforeBlock) {
154                 auto newBlock = createAnonymousRubyInlineBlock(*this);
155                 beforeBlock = newBlock.get();
156                 RenderInline::addChild(builder, WTFMove(newBlock), firstChild());
157             }
158             builder.insertChild(*beforeBlock, WTFMove(child));
159         }
160         return;
161     }
162     if (child->isAfterContent()) {
163         if (child->isInline()) {
164             // Add generated inline content normally
165             RenderInline::addChild(builder, WTFMove(child));
166         } else {
167             // Wrap non-inline content with an anonymous inline-block.
168             RenderBlock* afterBlock = rubyAfterBlock(this);
169             if (!afterBlock) {
170                 auto newBlock = createAnonymousRubyInlineBlock(*this);
171                 afterBlock = newBlock.get();
172                 RenderInline::addChild(builder, WTFMove(newBlock));
173             }
174             builder.insertChild(*afterBlock, WTFMove(child));
175         }
176         return;
177     }
178
179     // If the child is a ruby run, just add it normally.
180     if (child->isRubyRun()) {
181         RenderInline::addChild(builder, WTFMove(child), beforeChild);
182         return;
183     }
184
185     if (beforeChild && !isAfterContent(beforeChild)) {
186         // insert child into run
187         ASSERT(!beforeChild->isRubyRun());
188         RenderElement* run = beforeChild->parent();
189         while (run && !run->isRubyRun())
190             run = run->parent();
191         if (run) {
192             builder.insertChild(*run, WTFMove(child), beforeChild);
193             return;
194         }
195         ASSERT_NOT_REACHED(); // beforeChild should always have a run as parent!
196         // Emergency fallback: fall through and just append.
197     }
198
199     // If the new child would be appended, try to add the child to the previous run
200     // if possible, or create a new run otherwise.
201     // (The RenderRubyRun object will handle the details)
202     RenderRubyRun* lastRun = lastRubyRun(this);
203     if (!lastRun || lastRun->hasRubyText()) {
204         auto newRun = RenderRubyRun::staticCreateRubyRun(this);
205         lastRun = newRun.get();
206         RenderInline::addChild(builder, WTFMove(newRun), beforeChild);
207     }
208     builder.insertChild(*lastRun, WTFMove(child));
209 }
210
211 RenderPtr<RenderObject> RenderRubyAsInline::takeChild(RenderObject& child)
212 {
213     // If the child's parent is *this (must be a ruby run or generated content or anonymous block),
214     // just use the normal remove method.
215     if (child.parent() == this) {
216 #ifndef ASSERT_DISABLED
217         ASSERT(isRubyChildForNormalRemoval(child));
218 #endif
219         return RenderInline::takeChild(child);
220     }
221     // If the child's parent is an anoymous block (must be generated :before/:after content)
222     // just use the block's remove method.
223     if (isAnonymousRubyInlineBlock(child.parent())) {
224         ASSERT(child.isBeforeContent() || child.isAfterContent());
225         auto& parent = *child.parent();
226         auto takenChild = parent.takeChild(child);
227         parent.removeFromParentAndDestroy();
228         return takenChild;
229     }
230
231     // Otherwise find the containing run and remove it from there.
232     return findRubyRunParent(child).takeChild(child);
233 }
234
235 //=== ruby as block object ===
236
237 RenderRubyAsBlock::RenderRubyAsBlock(Element& element, RenderStyle&& style)
238     : RenderBlockFlow(element, WTFMove(style))
239 {
240 }
241
242 RenderRubyAsBlock::~RenderRubyAsBlock() = default;
243
244 void RenderRubyAsBlock::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle)
245 {
246     RenderBlockFlow::styleDidChange(diff, oldStyle);
247     propagateStyleToAnonymousChildren(PropagateToAllChildren);
248 }
249
250 void RenderRubyAsBlock::addChild(RenderTreeBuilder& builder, RenderPtr<RenderObject> child, RenderObject* beforeChild)
251 {
252     // Insert :before and :after content before/after the RenderRubyRun(s)
253     if (child->isBeforeContent()) {
254         if (child->isInline()) {
255             // Add generated inline content normally
256             RenderBlockFlow::addChild(builder, WTFMove(child), firstChild());
257         } else {
258             // Wrap non-inline content with an anonymous inline-block.
259             RenderBlock* beforeBlock = rubyBeforeBlock(this);
260             if (!beforeBlock) {
261                 auto newBlock = createAnonymousRubyInlineBlock(*this);
262                 beforeBlock = newBlock.get();
263                 RenderBlockFlow::addChild(builder, WTFMove(newBlock), firstChild());
264             }
265             builder.insertChild(*beforeBlock, WTFMove(child));
266         }
267         return;
268     }
269     if (child->isAfterContent()) {
270         if (child->isInline()) {
271             // Add generated inline content normally
272             RenderBlockFlow::addChild(builder, WTFMove(child));
273         } else {
274             // Wrap non-inline content with an anonymous inline-block.
275             RenderBlock* afterBlock = rubyAfterBlock(this);
276             if (!afterBlock) {
277                 auto newBlock = createAnonymousRubyInlineBlock(*this);
278                 afterBlock = newBlock.get();
279                 RenderBlockFlow::addChild(builder, WTFMove(newBlock));
280             }
281             builder.insertChild(*afterBlock, WTFMove(child));
282         }
283         return;
284     }
285
286     // If the child is a ruby run, just add it normally.
287     if (child->isRubyRun()) {
288         RenderBlockFlow::addChild(builder, WTFMove(child), beforeChild);
289         return;
290     }
291
292     if (beforeChild && !isAfterContent(beforeChild)) {
293         // insert child into run
294         ASSERT(!beforeChild->isRubyRun());
295         RenderElement* run = beforeChild->parent();
296         while (run && !run->isRubyRun())
297             run = run->parent();
298         if (run) {
299             builder.insertChild(*run, WTFMove(child), beforeChild);
300             return;
301         }
302         ASSERT_NOT_REACHED(); // beforeChild should always have a run as parent!
303         // Emergency fallback: fall through and just append.
304     }
305
306     // If the new child would be appended, try to add the child to the previous run
307     // if possible, or create a new run otherwise.
308     // (The RenderRubyRun object will handle the details)
309     RenderRubyRun* lastRun = lastRubyRun(this);
310     if (!lastRun || lastRun->hasRubyText()) {
311         auto newRun = RenderRubyRun::staticCreateRubyRun(this);
312         lastRun = newRun.get();
313         RenderBlockFlow::addChild(builder, WTFMove(newRun), beforeChild);
314     }
315     builder.insertChild(*lastRun, WTFMove(child));
316 }
317
318 RenderPtr<RenderObject> RenderRubyAsBlock::takeChild(RenderObject& child)
319 {
320     // If the child's parent is *this (must be a ruby run or generated content or anonymous block),
321     // just use the normal remove method.
322     if (child.parent() == this) {
323 #ifndef ASSERT_DISABLED
324         ASSERT(isRubyChildForNormalRemoval(child));
325 #endif
326         return RenderBlockFlow::takeChild(child);
327     }
328     // If the child's parent is an anoymous block (must be generated :before/:after content)
329     // just use the block's remove method.
330     if (isAnonymousRubyInlineBlock(child.parent())) {
331         ASSERT(child.isBeforeContent() || child.isAfterContent());
332         auto& parent = *child.parent();
333         auto takenChild = parent.takeChild(child);
334         parent.removeFromParentAndDestroy();
335         return takenChild;
336     }
337
338     // Otherwise find the containing run and remove it from there.
339     return findRubyRunParent(child).takeChild(child);
340 }
341
342 } // namespace WebCore