Add WTF::move()
[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, WTF::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 RenderObject* 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         return RenderInline::removeChild(child);
197     }
198     // If the child's parent is an anoymous block (must be generated :before/:after content)
199     // just use the block's remove method.
200     if (isAnonymousRubyInlineBlock(child.parent())) {
201         ASSERT(child.isBeforeContent() || child.isAfterContent());
202         RenderObject* next = child.parent()->removeChild(child);
203         removeChild(*child.parent());
204         return next;
205     }
206
207     // Otherwise find the containing run and remove it from there.
208     RenderRubyRun& run = findRubyRunParent(child);
209     return run.removeChild(child);
210 }
211
212 //=== ruby as block object ===
213
214 RenderRubyAsBlock::RenderRubyAsBlock(Element& element, PassRef<RenderStyle> style)
215     : RenderBlockFlow(element, WTF::move(style))
216 {
217 }
218
219 RenderRubyAsBlock::~RenderRubyAsBlock()
220 {
221 }
222
223 void RenderRubyAsBlock::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle)
224 {
225     RenderBlockFlow::styleDidChange(diff, oldStyle);
226     propagateStyleToAnonymousChildren(PropagateToAllChildren);
227 }
228
229 void RenderRubyAsBlock::addChild(RenderObject* child, RenderObject* beforeChild)
230 {
231     // Insert :before and :after content before/after the RenderRubyRun(s)
232     if (child->isBeforeContent()) {
233         if (child->isInline()) {
234             // Add generated inline content normally
235             RenderBlockFlow::addChild(child, firstChild());
236         } else {
237             // Wrap non-inline content with an anonymous inline-block.
238             RenderBlock* beforeBlock = rubyBeforeBlock(this);
239             if (!beforeBlock) {
240                 beforeBlock = createAnonymousRubyInlineBlock(*this);
241                 RenderBlockFlow::addChild(beforeBlock, firstChild());
242             }
243             beforeBlock->addChild(child);
244         }
245         return;
246     }
247     if (child->isAfterContent()) {
248         if (child->isInline()) {
249             // Add generated inline content normally
250             RenderBlockFlow::addChild(child);
251         } else {
252             // Wrap non-inline content with an anonymous inline-block.
253             RenderBlock* afterBlock = rubyAfterBlock(this);
254             if (!afterBlock) {
255                 afterBlock = createAnonymousRubyInlineBlock(*this);
256                 RenderBlockFlow::addChild(afterBlock);
257             }
258             afterBlock->addChild(child);
259         }
260         return;
261     }
262
263     // If the child is a ruby run, just add it normally.
264     if (child->isRubyRun()) {
265         RenderBlockFlow::addChild(child, beforeChild);
266         return;
267     }
268
269     if (beforeChild && !isAfterContent(beforeChild)) {
270         // insert child into run
271         ASSERT(!beforeChild->isRubyRun());
272         RenderElement* run = beforeChild->parent();
273         while (run && !run->isRubyRun())
274             run = run->parent();
275         if (run) {
276             run->addChild(child, beforeChild);
277             return;
278         }
279         ASSERT_NOT_REACHED(); // beforeChild should always have a run as parent!
280         // Emergency fallback: fall through and just append.
281     }
282
283     // If the new child would be appended, try to add the child to the previous run
284     // if possible, or create a new run otherwise.
285     // (The RenderRubyRun object will handle the details)
286     RenderRubyRun* lastRun = lastRubyRun(this);
287     if (!lastRun || lastRun->hasRubyText()) {
288         lastRun = RenderRubyRun::staticCreateRubyRun(this);
289         RenderBlockFlow::addChild(lastRun, beforeChild);
290     }
291     lastRun->addChild(child);
292 }
293
294 RenderObject* RenderRubyAsBlock::removeChild(RenderObject& child)
295 {
296     // If the child's parent is *this (must be a ruby run or generated content or anonymous block),
297     // just use the normal remove method.
298     if (child.parent() == this) {
299         ASSERT(child.isRubyRun() || child.isBeforeContent() || child.isAfterContent() || isAnonymousRubyInlineBlock(&child));
300         return RenderBlockFlow::removeChild(child);
301     }
302     // If the child's parent is an anoymous block (must be generated :before/:after content)
303     // just use the block's remove method.
304     if (isAnonymousRubyInlineBlock(child.parent())) {
305         ASSERT(child.isBeforeContent() || child.isAfterContent());
306         RenderObject* next = child.parent()->removeChild(child);
307         removeChild(*child.parent());
308         return next;
309     }
310
311     // Otherwise find the containing run and remove it from there.
312     RenderRubyRun& run = findRubyRunParent(child);
313     return run.removeChild(child);
314 }
315
316 } // namespace WebCore