Use lineageOfType to simplify two rendering helpers.
[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 "StyleInheritedData.h"
39 #include <wtf/RefPtr.h>
40
41 namespace WebCore {
42
43 //=== generic helper functions to avoid excessive code duplication ===
44
45 static inline bool isAnonymousRubyInlineBlock(const RenderObject* object)
46 {
47     ASSERT(!object
48         || !object->parent()->isRuby()
49         || object->isRubyRun()
50         || (object->isInline() && (object->isBeforeContent() || object->isAfterContent()))
51         || (object->isAnonymous() && object->isRenderBlock() && object->style().display() == INLINE_BLOCK));
52
53     return object
54         && object->parent()->isRuby()
55         && object->isRenderBlock()
56         && !object->isRubyRun();
57 }
58
59 static inline bool isRubyBeforeBlock(const RenderObject* object)
60 {
61     return isAnonymousRubyInlineBlock(object)
62         && !object->previousSibling()
63         && object->firstChildSlow()
64         && object->firstChildSlow()->style().styleType() == BEFORE;
65 }
66
67 static inline bool isRubyAfterBlock(const RenderObject* object)
68 {
69     return isAnonymousRubyInlineBlock(object)
70         && !object->nextSibling()
71         && object->firstChildSlow()
72         && object->firstChildSlow()->style().styleType() == AFTER;
73 }
74
75 static inline RenderBlock* rubyBeforeBlock(const RenderElement* ruby)
76 {
77     RenderObject* child = ruby->firstChild();
78     return isRubyBeforeBlock(child) ? toRenderBlock(child) : 0;
79 }
80
81 static inline RenderBlock* rubyAfterBlock(const RenderElement* ruby)
82 {
83     RenderObject* child = ruby->lastChild();
84     return isRubyAfterBlock(child) ? toRenderBlock(child) : 0;
85 }
86
87 static RenderBlock* createAnonymousRubyInlineBlock(RenderObject& ruby)
88 {
89     RenderBlock* newBlock = new RenderBlockFlow(ruby.document(), RenderStyle::createAnonymousStyleWithDisplay(&ruby.style(), INLINE_BLOCK));
90     newBlock->initializeStyle();
91     return newBlock;
92 }
93
94 static RenderRubyRun* lastRubyRun(const RenderElement* ruby)
95 {
96     RenderObject* child = ruby->lastChild();
97     if (child && !child->isRubyRun())
98         child = child->previousSibling();
99     ASSERT(!child || child->isRubyRun() || child->isBeforeContent() || child == rubyBeforeBlock(ruby));
100     return child && child->isRubyRun() ? toRenderRubyRun(child) : 0;
101 }
102
103 static inline RenderRubyRun& findRubyRunParent(RenderObject& child)
104 {
105     return *lineageOfType<RenderRubyRun>(child).first();
106 }
107
108 //=== ruby as inline object ===
109
110 RenderRubyAsInline::RenderRubyAsInline(Element& element, PassRef<RenderStyle> style)
111     : RenderInline(element, std::move(style))
112 {
113 }
114
115 RenderRubyAsInline::~RenderRubyAsInline()
116 {
117 }
118
119 void RenderRubyAsInline::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle)
120 {
121     RenderInline::styleDidChange(diff, oldStyle);
122     propagateStyleToAnonymousChildren(PropagateToAllChildren);
123 }
124
125 void RenderRubyAsInline::addChild(RenderObject* child, RenderObject* beforeChild)
126 {
127     // Insert :before and :after content before/after the RenderRubyRun(s)
128     if (child->isBeforeContent()) {
129         if (child->isInline()) {
130             // Add generated inline content normally
131             RenderInline::addChild(child, firstChild());
132         } else {
133             // Wrap non-inline content with an anonymous inline-block.
134             RenderBlock* beforeBlock = rubyBeforeBlock(this);
135             if (!beforeBlock) {
136                 beforeBlock = createAnonymousRubyInlineBlock(*this);
137                 RenderInline::addChild(beforeBlock, firstChild());
138             }
139             beforeBlock->addChild(child);
140         }
141         return;
142     }
143     if (child->isAfterContent()) {
144         if (child->isInline()) {
145             // Add generated inline content normally
146             RenderInline::addChild(child);
147         } else {
148             // Wrap non-inline content with an anonymous inline-block.
149             RenderBlock* afterBlock = rubyAfterBlock(this);
150             if (!afterBlock) {
151                 afterBlock = createAnonymousRubyInlineBlock(*this);
152                 RenderInline::addChild(afterBlock);
153             }
154             afterBlock->addChild(child);
155         }
156         return;
157     }
158
159     // If the child is a ruby run, just add it normally.
160     if (child->isRubyRun()) {
161         RenderInline::addChild(child, beforeChild);
162         return;
163     }
164
165     if (beforeChild && !isAfterContent(beforeChild)) {
166         // insert child into run
167         ASSERT(!beforeChild->isRubyRun());
168         RenderElement* run = beforeChild->parent();
169         while (run && !run->isRubyRun())
170             run = run->parent();
171         if (run) {
172             run->addChild(child, beforeChild);
173             return;
174         }
175         ASSERT_NOT_REACHED(); // beforeChild should always have a run as parent!
176         // Emergency fallback: fall through and just append.
177     }
178
179     // If the new child would be appended, try to add the child to the previous run
180     // if possible, or create a new run otherwise.
181     // (The RenderRubyRun object will handle the details)
182     RenderRubyRun* lastRun = lastRubyRun(this);
183     if (!lastRun || lastRun->hasRubyText()) {
184         lastRun = RenderRubyRun::staticCreateRubyRun(this);
185         RenderInline::addChild(lastRun, beforeChild);
186     }
187     lastRun->addChild(child);
188 }
189
190 void RenderRubyAsInline::removeChild(RenderObject& child)
191 {
192     // If the child's parent is *this (must be a ruby run or generated content or anonymous block),
193     // just use the normal remove method.
194     if (child.parent() == this) {
195         ASSERT(child.isRubyRun() || child.isBeforeContent() || child.isAfterContent() || isAnonymousRubyInlineBlock(&child));
196         RenderInline::removeChild(child);
197         return;
198     }
199     // If the child's parent is an anoymous block (must be generated :before/:after content)
200     // just use the block's remove method.
201     if (isAnonymousRubyInlineBlock(child.parent())) {
202         ASSERT(child.isBeforeContent() || child.isAfterContent());
203         child.parent()->removeChild(child);
204         removeChild(*child.parent());
205         return;
206     }
207
208     // Otherwise find the containing run and remove it from there.
209     RenderRubyRun& run = findRubyRunParent(child);
210     run.removeChild(child);
211 }
212
213 //=== ruby as block object ===
214
215 RenderRubyAsBlock::RenderRubyAsBlock(Element& element, PassRef<RenderStyle> style)
216     : RenderBlockFlow(element, std::move(style))
217 {
218 }
219
220 RenderRubyAsBlock::~RenderRubyAsBlock()
221 {
222 }
223
224 void RenderRubyAsBlock::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle)
225 {
226     RenderBlockFlow::styleDidChange(diff, oldStyle);
227     propagateStyleToAnonymousChildren(PropagateToAllChildren);
228 }
229
230 void RenderRubyAsBlock::addChild(RenderObject* child, RenderObject* beforeChild)
231 {
232     // Insert :before and :after content before/after the RenderRubyRun(s)
233     if (child->isBeforeContent()) {
234         if (child->isInline()) {
235             // Add generated inline content normally
236             RenderBlockFlow::addChild(child, firstChild());
237         } else {
238             // Wrap non-inline content with an anonymous inline-block.
239             RenderBlock* beforeBlock = rubyBeforeBlock(this);
240             if (!beforeBlock) {
241                 beforeBlock = createAnonymousRubyInlineBlock(*this);
242                 RenderBlockFlow::addChild(beforeBlock, firstChild());
243             }
244             beforeBlock->addChild(child);
245         }
246         return;
247     }
248     if (child->isAfterContent()) {
249         if (child->isInline()) {
250             // Add generated inline content normally
251             RenderBlockFlow::addChild(child);
252         } else {
253             // Wrap non-inline content with an anonymous inline-block.
254             RenderBlock* afterBlock = rubyAfterBlock(this);
255             if (!afterBlock) {
256                 afterBlock = createAnonymousRubyInlineBlock(*this);
257                 RenderBlockFlow::addChild(afterBlock);
258             }
259             afterBlock->addChild(child);
260         }
261         return;
262     }
263
264     // If the child is a ruby run, just add it normally.
265     if (child->isRubyRun()) {
266         RenderBlockFlow::addChild(child, beforeChild);
267         return;
268     }
269
270     if (beforeChild && !isAfterContent(beforeChild)) {
271         // insert child into run
272         ASSERT(!beforeChild->isRubyRun());
273         RenderElement* run = beforeChild->parent();
274         while (run && !run->isRubyRun())
275             run = run->parent();
276         if (run) {
277             run->addChild(child, beforeChild);
278             return;
279         }
280         ASSERT_NOT_REACHED(); // beforeChild should always have a run as parent!
281         // Emergency fallback: fall through and just append.
282     }
283
284     // If the new child would be appended, try to add the child to the previous run
285     // if possible, or create a new run otherwise.
286     // (The RenderRubyRun object will handle the details)
287     RenderRubyRun* lastRun = lastRubyRun(this);
288     if (!lastRun || lastRun->hasRubyText()) {
289         lastRun = RenderRubyRun::staticCreateRubyRun(this);
290         RenderBlockFlow::addChild(lastRun, beforeChild);
291     }
292     lastRun->addChild(child);
293 }
294
295 void RenderRubyAsBlock::removeChild(RenderObject& child)
296 {
297     // If the child's parent is *this (must be a ruby run or generated content or anonymous block),
298     // just use the normal remove method.
299     if (child.parent() == this) {
300         ASSERT(child.isRubyRun() || child.isBeforeContent() || child.isAfterContent() || isAnonymousRubyInlineBlock(&child));
301         RenderBlockFlow::removeChild(child);
302         return;
303     }
304     // If the child's parent is an anoymous block (must be generated :before/:after content)
305     // just use the block's remove method.
306     if (isAnonymousRubyInlineBlock(child.parent())) {
307         ASSERT(child.isBeforeContent() || child.isAfterContent());
308         child.parent()->removeChild(child);
309         removeChild(*child.parent());
310         return;
311     }
312
313     // Otherwise find the containing run and remove it from there.
314     RenderRubyRun& run = findRubyRunParent(child);
315     run.removeChild(child);
316 }
317
318 } // namespace WebCore