1 /*
2 * Copyright (C) 2006 Apple Computer, Inc.
3 * Copyright (C) 2006 Alexander Kellett <lypanov@kde.org>
4 * Copyright (C) 2006 Oliver Hunt <ojh16@student.canterbury.ac.nz>
5 * Copyright (C) 2007 Nikolas Zimmermann <zimmermann@kde.org>
6 * Copyright (C) 2008 Rob Buis <buis@kde.org>
7 * Copyright (C) 2009 Dirk Schulze <krit@webkit.org>
8 * Copyright (C) Research In Motion Limited 2010-2012. All rights reserved.
9 * Copyright (C) 2012 Google Inc.
10 *
11 * This library is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU Library General Public
13 * License as published by the Free Software Foundation; either
14 * version 2 of the License, or (at your option) any later version.
15 *
16 * This library is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 * Library General Public License for more details.
20 *
21 * You should have received a copy of the GNU Library General Public License
22 * along with this library; see the file COPYING.LIB. If not, write to
23 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
24 * Boston, MA 02110-1301, USA.
25 */
26
27 #include "config.h"
28
29 #include "core/rendering/svg/RenderSVGText.h"
30
31 #include "core/rendering/HitTestRequest.h"
32 #include "core/rendering/HitTestResult.h"
33 #include "core/rendering/LayoutRepainter.h"
34 #include "core/rendering/PaintInfo.h"
35 #include "core/rendering/PointerEventsHitRules.h"
36 #include "core/rendering/style/ShadowList.h"
37 #include "core/rendering/svg/RenderSVGInline.h"
38 #include "core/rendering/svg/RenderSVGInlineText.h"
39 #include "core/rendering/svg/RenderSVGResource.h"
40 #include "core/rendering/svg/RenderSVGRoot.h"
41 #include "core/rendering/svg/SVGRenderSupport.h"
42 #include "core/rendering/svg/SVGResourcesCache.h"
43 #include "core/rendering/svg/SVGRootInlineBox.h"
44 #include "core/rendering/svg/SVGTextRunRenderingContext.h"
45 #include "core/svg/SVGLengthList.h"
46 #include "core/svg/SVGTextElement.h"
47 #include "core/svg/SVGTransformList.h"
48 #include "core/svg/SVGURIReference.h"
49 #include "platform/FloatConversion.h"
50 #include "platform/fonts/FontCache.h"
51 #include "platform/fonts/SimpleFontData.h"
52 #include "platform/geometry/FloatQuad.h"
53 #include "platform/geometry/TransformState.h"
54 #include "platform/graphics/GraphicsContextStateSaver.h"
55
56 namespace WebCore {
57
RenderSVGText(SVGTextElement * node)58 RenderSVGText::RenderSVGText(SVGTextElement* node)
59 : RenderSVGBlock(node)
60 , m_needsReordering(false)
61 , m_needsPositioningValuesUpdate(false)
62 , m_needsTransformUpdate(true)
63 , m_needsTextMetricsUpdate(false)
64 {
65 }
66
~RenderSVGText()67 RenderSVGText::~RenderSVGText()
68 {
69 ASSERT(m_layoutAttributes.isEmpty());
70 }
71
isChildAllowed(RenderObject * child,RenderStyle *) const72 bool RenderSVGText::isChildAllowed(RenderObject* child, RenderStyle*) const
73 {
74 return child->isSVGInline() || (child->isText() && SVGRenderSupport::isRenderableTextNode(child));
75 }
76
locateRenderSVGTextAncestor(RenderObject * start)77 RenderSVGText* RenderSVGText::locateRenderSVGTextAncestor(RenderObject* start)
78 {
79 ASSERT(start);
80 while (start && !start->isSVGText())
81 start = start->parent();
82 if (!start || !start->isSVGText())
83 return 0;
84 return toRenderSVGText(start);
85 }
86
locateRenderSVGTextAncestor(const RenderObject * start)87 const RenderSVGText* RenderSVGText::locateRenderSVGTextAncestor(const RenderObject* start)
88 {
89 ASSERT(start);
90 while (start && !start->isSVGText())
91 start = start->parent();
92 if (!start || !start->isSVGText())
93 return 0;
94 return toRenderSVGText(start);
95 }
96
mapRectToPaintInvalidationBacking(const RenderLayerModelObject * paintInvalidationContainer,LayoutRect & rect,bool fixed) const97 void RenderSVGText::mapRectToPaintInvalidationBacking(const RenderLayerModelObject* paintInvalidationContainer, LayoutRect& rect, bool fixed) const
98 {
99 FloatRect repaintRect = rect;
100 computeFloatRectForPaintInvalidation(paintInvalidationContainer, repaintRect, fixed);
101 rect = enclosingLayoutRect(repaintRect);
102 }
103
collectLayoutAttributes(RenderObject * text,Vector<SVGTextLayoutAttributes * > & attributes)104 static inline void collectLayoutAttributes(RenderObject* text, Vector<SVGTextLayoutAttributes*>& attributes)
105 {
106 for (RenderObject* descendant = text; descendant; descendant = descendant->nextInPreOrder(text)) {
107 if (descendant->isSVGInlineText())
108 attributes.append(toRenderSVGInlineText(descendant)->layoutAttributes());
109 }
110 }
111
findPreviousAndNextAttributes(RenderSVGText * root,RenderSVGInlineText * locateElement,SVGTextLayoutAttributes * & previous,SVGTextLayoutAttributes * & next)112 static inline bool findPreviousAndNextAttributes(RenderSVGText* root, RenderSVGInlineText* locateElement, SVGTextLayoutAttributes*& previous, SVGTextLayoutAttributes*& next)
113 {
114 ASSERT(root);
115 ASSERT(locateElement);
116 bool stopAfterNext = false;
117 RenderObject* current = root->firstChild();
118 while (current) {
119 if (current->isSVGInlineText()) {
120 RenderSVGInlineText* text = toRenderSVGInlineText(current);
121 if (locateElement != text) {
122 if (stopAfterNext) {
123 next = text->layoutAttributes();
124 return true;
125 }
126
127 previous = text->layoutAttributes();
128 } else {
129 stopAfterNext = true;
130 }
131 } else if (current->isSVGInline()) {
132 // Descend into text content (if possible).
133 if (RenderObject* child = toRenderSVGInline(current)->firstChild()) {
134 current = child;
135 continue;
136 }
137 }
138
139 current = current->nextInPreOrderAfterChildren(root);
140 }
141 return false;
142 }
143
shouldHandleSubtreeMutations() const144 inline bool RenderSVGText::shouldHandleSubtreeMutations() const
145 {
146 if (beingDestroyed() || !everHadLayout()) {
147 ASSERT(m_layoutAttributes.isEmpty());
148 ASSERT(!m_layoutAttributesBuilder.numberOfTextPositioningElements());
149 return false;
150 }
151 return true;
152 }
153
subtreeChildWasAdded(RenderObject * child)154 void RenderSVGText::subtreeChildWasAdded(RenderObject* child)
155 {
156 ASSERT(child);
157 if (!shouldHandleSubtreeMutations() || documentBeingDestroyed())
158 return;
159
160 // Always protect the cache before clearing text positioning elements when the cache will subsequently be rebuilt.
161 FontCachePurgePreventer fontCachePurgePreventer;
162
163 // The positioning elements cache doesn't include the new 'child' yet. Clear the
164 // cache, as the next buildLayoutAttributesForTextRenderer() call rebuilds it.
165 m_layoutAttributesBuilder.clearTextPositioningElements();
166
167 if (!child->isSVGInlineText() && !child->isSVGInline())
168 return;
169
170 // Detect changes in layout attributes and only measure those text parts that have changed!
171 Vector<SVGTextLayoutAttributes*> newLayoutAttributes;
172 collectLayoutAttributes(this, newLayoutAttributes);
173 if (newLayoutAttributes.isEmpty()) {
174 ASSERT(m_layoutAttributes.isEmpty());
175 return;
176 }
177
178 // Compare m_layoutAttributes with newLayoutAttributes to figure out which attribute got added.
179 size_t size = newLayoutAttributes.size();
180 SVGTextLayoutAttributes* attributes = 0;
181 for (size_t i = 0; i < size; ++i) {
182 attributes = newLayoutAttributes[i];
183 if (m_layoutAttributes.find(attributes) == kNotFound) {
184 // Every time this is invoked, there's only a single new entry in the newLayoutAttributes list, compared to the old in m_layoutAttributes.
185 SVGTextLayoutAttributes* previous = 0;
186 SVGTextLayoutAttributes* next = 0;
187 ASSERT_UNUSED(child, attributes->context() == child);
188 findPreviousAndNextAttributes(this, attributes->context(), previous, next);
189
190 if (previous)
191 m_layoutAttributesBuilder.buildLayoutAttributesForTextRenderer(previous->context());
192 m_layoutAttributesBuilder.buildLayoutAttributesForTextRenderer(attributes->context());
193 if (next)
194 m_layoutAttributesBuilder.buildLayoutAttributesForTextRenderer(next->context());
195 break;
196 }
197 }
198
199 #ifndef NDEBUG
200 // Verify that m_layoutAttributes only differs by a maximum of one entry.
201 for (size_t i = 0; i < size; ++i)
202 ASSERT(m_layoutAttributes.find(newLayoutAttributes[i]) != kNotFound || newLayoutAttributes[i] == attributes);
203 #endif
204
205 m_layoutAttributes = newLayoutAttributes;
206 }
207
checkLayoutAttributesConsistency(RenderSVGText * text,Vector<SVGTextLayoutAttributes * > & expectedLayoutAttributes)208 static inline void checkLayoutAttributesConsistency(RenderSVGText* text, Vector<SVGTextLayoutAttributes*>& expectedLayoutAttributes)
209 {
210 #ifndef NDEBUG
211 Vector<SVGTextLayoutAttributes*> newLayoutAttributes;
212 collectLayoutAttributes(text, newLayoutAttributes);
213 ASSERT(newLayoutAttributes == expectedLayoutAttributes);
214 #endif
215 }
216
willBeDestroyed()217 void RenderSVGText::willBeDestroyed()
218 {
219 m_layoutAttributes.clear();
220 m_layoutAttributesBuilder.clearTextPositioningElements();
221
222 RenderSVGBlock::willBeDestroyed();
223 }
224
subtreeChildWillBeRemoved(RenderObject * child,Vector<SVGTextLayoutAttributes *,2> & affectedAttributes)225 void RenderSVGText::subtreeChildWillBeRemoved(RenderObject* child, Vector<SVGTextLayoutAttributes*, 2>& affectedAttributes)
226 {
227 ASSERT(child);
228 if (!shouldHandleSubtreeMutations())
229 return;
230
231 checkLayoutAttributesConsistency(this, m_layoutAttributes);
232
233 // The positioning elements cache depends on the size of each text renderer in the
234 // subtree. If this changes, clear the cache. It's going to be rebuilt below.
235 m_layoutAttributesBuilder.clearTextPositioningElements();
236 if (m_layoutAttributes.isEmpty() || !child->isSVGInlineText())
237 return;
238
239 // This logic requires that the 'text' child is still inserted in the tree.
240 RenderSVGInlineText* text = toRenderSVGInlineText(child);
241 SVGTextLayoutAttributes* previous = 0;
242 SVGTextLayoutAttributes* next = 0;
243 if (!documentBeingDestroyed())
244 findPreviousAndNextAttributes(this, text, previous, next);
245
246 if (previous)
247 affectedAttributes.append(previous);
248 if (next)
249 affectedAttributes.append(next);
250
251 size_t position = m_layoutAttributes.find(text->layoutAttributes());
252 ASSERT(position != kNotFound);
253 m_layoutAttributes.remove(position);
254 }
255
subtreeChildWasRemoved(const Vector<SVGTextLayoutAttributes *,2> & affectedAttributes)256 void RenderSVGText::subtreeChildWasRemoved(const Vector<SVGTextLayoutAttributes*, 2>& affectedAttributes)
257 {
258 if (!shouldHandleSubtreeMutations() || documentBeingDestroyed()) {
259 ASSERT(affectedAttributes.isEmpty());
260 return;
261 }
262
263 // This is called immediately after subtreeChildWillBeDestroyed, once the RenderSVGInlineText::willBeDestroyed() method
264 // passes on to the base class, which removes us from the render tree. At this point we can update the layout attributes.
265 unsigned size = affectedAttributes.size();
266 for (unsigned i = 0; i < size; ++i)
267 m_layoutAttributesBuilder.buildLayoutAttributesForTextRenderer(affectedAttributes[i]->context());
268 }
269
subtreeStyleDidChange()270 void RenderSVGText::subtreeStyleDidChange()
271 {
272 if (!shouldHandleSubtreeMutations() || documentBeingDestroyed())
273 return;
274
275 checkLayoutAttributesConsistency(this, m_layoutAttributes);
276
277 // Only update the metrics cache, but not the text positioning element cache
278 // nor the layout attributes cached in the leaf #text renderers.
279 FontCachePurgePreventer fontCachePurgePreventer;
280 for (RenderObject* descendant = firstChild(); descendant; descendant = descendant->nextInPreOrder(this)) {
281 if (descendant->isSVGInlineText())
282 m_layoutAttributesBuilder.rebuildMetricsForTextRenderer(toRenderSVGInlineText(descendant));
283 }
284 }
285
subtreeTextDidChange(RenderSVGInlineText * text)286 void RenderSVGText::subtreeTextDidChange(RenderSVGInlineText* text)
287 {
288 ASSERT(text);
289 ASSERT(!beingDestroyed());
290 if (!everHadLayout()) {
291 ASSERT(m_layoutAttributes.isEmpty());
292 ASSERT(!m_layoutAttributesBuilder.numberOfTextPositioningElements());
293 return;
294 }
295
296 // Always protect the cache before clearing text positioning elements when the cache will subsequently be rebuilt.
297 FontCachePurgePreventer fontCachePurgePreventer;
298
299 // The positioning elements cache depends on the size of each text renderer in the
300 // subtree. If this changes, clear the cache. It's going to be rebuilt below.
301 m_layoutAttributesBuilder.clearTextPositioningElements();
302
303 checkLayoutAttributesConsistency(this, m_layoutAttributes);
304 for (RenderObject* descendant = text; descendant; descendant = descendant->nextInPreOrder(text)) {
305 if (descendant->isSVGInlineText())
306 m_layoutAttributesBuilder.buildLayoutAttributesForTextRenderer(toRenderSVGInlineText(descendant));
307 }
308 }
309
updateFontInAllDescendants(RenderObject * start,SVGTextLayoutAttributesBuilder * builder=0)310 static inline void updateFontInAllDescendants(RenderObject* start, SVGTextLayoutAttributesBuilder* builder = 0)
311 {
312 for (RenderObject* descendant = start; descendant; descendant = descendant->nextInPreOrder(start)) {
313 if (!descendant->isSVGInlineText())
314 continue;
315 RenderSVGInlineText* text = toRenderSVGInlineText(descendant);
316 text->updateScaledFont();
317 if (builder)
318 builder->rebuildMetricsForTextRenderer(text);
319 }
320 }
321
layout()322 void RenderSVGText::layout()
323 {
324 ASSERT(needsLayout());
325
326 subtreeStyleDidChange();
327
328 LayoutRepainter repainter(*this, SVGRenderSupport::checkForSVGRepaintDuringLayout(this));
329
330 bool updateCachedBoundariesInParents = false;
331 if (m_needsTransformUpdate) {
332 m_localTransform = toSVGTextElement(node())->animatedLocalTransform();
333 m_needsTransformUpdate = false;
334 updateCachedBoundariesInParents = true;
335 }
336
337 if (!everHadLayout()) {
338 // When laying out initially, collect all layout attributes, build the character data map,
339 // and propogate resulting SVGLayoutAttributes to all RenderSVGInlineText children in the subtree.
340 ASSERT(m_layoutAttributes.isEmpty());
341 collectLayoutAttributes(this, m_layoutAttributes);
342 updateFontInAllDescendants(this);
343 m_layoutAttributesBuilder.buildLayoutAttributesForForSubtree(this);
344
345 m_needsReordering = true;
346 m_needsTextMetricsUpdate = false;
347 m_needsPositioningValuesUpdate = false;
348 updateCachedBoundariesInParents = true;
349 } else if (m_needsPositioningValuesUpdate) {
350 // When the x/y/dx/dy/rotate lists change, recompute the layout attributes, and eventually
351 // update the on-screen font objects as well in all descendants.
352 if (m_needsTextMetricsUpdate) {
353 updateFontInAllDescendants(this);
354 m_needsTextMetricsUpdate = false;
355 }
356
357 m_layoutAttributesBuilder.buildLayoutAttributesForForSubtree(this);
358 m_needsReordering = true;
359 m_needsPositioningValuesUpdate = false;
360 updateCachedBoundariesInParents = true;
361 } else if (m_needsTextMetricsUpdate || SVGRenderSupport::findTreeRootObject(this)->isLayoutSizeChanged()) {
362 // If the root layout size changed (eg. window size changes) or the transform to the root
363 // context has changed then recompute the on-screen font size.
364 updateFontInAllDescendants(this, &m_layoutAttributesBuilder);
365
366 ASSERT(!m_needsReordering);
367 ASSERT(!m_needsPositioningValuesUpdate);
368 m_needsTextMetricsUpdate = false;
369 updateCachedBoundariesInParents = true;
370 }
371
372 checkLayoutAttributesConsistency(this, m_layoutAttributes);
373
374 // Reduced version of RenderBlock::layoutBlock(), which only takes care of SVG text.
375 // All if branches that could cause early exit in RenderBlocks layoutBlock() method are turned into assertions.
376 ASSERT(!isInline());
377 ASSERT(!simplifiedLayout());
378 ASSERT(!scrollsOverflow());
379 ASSERT(!hasControlClip());
380 ASSERT(!hasColumns());
381 ASSERT(!positionedObjects());
382 ASSERT(!m_overflow);
383 ASSERT(!isAnonymousBlock());
384
385 if (!firstChild())
386 setChildrenInline(true);
387
388 // FIXME: We need to find a way to only layout the child boxes, if needed.
389 FloatRect oldBoundaries = objectBoundingBox();
390 ASSERT(childrenInline());
391
392 rebuildFloatsFromIntruding();
393
394 LayoutUnit beforeEdge = borderBefore() + paddingBefore();
395 LayoutUnit afterEdge = borderAfter() + paddingAfter() + scrollbarLogicalHeight();
396 setLogicalHeight(beforeEdge);
397
398 LayoutUnit repaintLogicalTop = 0;
399 LayoutUnit repaintLogicalBottom = 0;
400 layoutInlineChildren(true, repaintLogicalTop, repaintLogicalBottom, afterEdge);
401
402 if (m_needsReordering)
403 m_needsReordering = false;
404
405 if (!updateCachedBoundariesInParents)
406 updateCachedBoundariesInParents = oldBoundaries != objectBoundingBox();
407
408 // Invalidate all resources of this client if our layout changed.
409 if (everHadLayout() && selfNeedsLayout())
410 SVGResourcesCache::clientLayoutChanged(this);
411
412 // If our bounds changed, notify the parents.
413 if (updateCachedBoundariesInParents)
414 RenderSVGBlock::setNeedsBoundariesUpdate();
415
416 repainter.repaintAfterLayout();
417 clearNeedsLayout();
418 }
419
createRootInlineBox()420 RootInlineBox* RenderSVGText::createRootInlineBox()
421 {
422 RootInlineBox* box = new SVGRootInlineBox(*this);
423 box->setHasVirtualLogicalHeight();
424 return box;
425 }
426
nodeAtFloatPoint(const HitTestRequest & request,HitTestResult & result,const FloatPoint & pointInParent,HitTestAction hitTestAction)427 bool RenderSVGText::nodeAtFloatPoint(const HitTestRequest& request, HitTestResult& result, const FloatPoint& pointInParent, HitTestAction hitTestAction)
428 {
429 PointerEventsHitRules hitRules(PointerEventsHitRules::SVG_TEXT_HITTESTING, request, style()->pointerEvents());
430 bool isVisible = (style()->visibility() == VISIBLE);
431 if (isVisible || !hitRules.requireVisible) {
432 if ((hitRules.canHitBoundingBox && !objectBoundingBox().isEmpty())
433 || (hitRules.canHitStroke && (style()->svgStyle()->hasStroke() || !hitRules.requireStroke))
434 || (hitRules.canHitFill && (style()->svgStyle()->hasFill() || !hitRules.requireFill))) {
435 FloatPoint localPoint = localToParentTransform().inverse().mapPoint(pointInParent);
436
437 if (!SVGRenderSupport::pointInClippingArea(this, localPoint))
438 return false;
439 if (hitRules.canHitBoundingBox && !objectBoundingBox().contains(localPoint))
440 return false;
441
442 HitTestLocation hitTestLocation(LayoutPoint(flooredIntPoint(localPoint)));
443 return RenderBlock::nodeAtPoint(request, result, hitTestLocation, LayoutPoint(), hitTestAction);
444 }
445 }
446
447 return false;
448 }
449
positionForPoint(const LayoutPoint & pointInContents)450 PositionWithAffinity RenderSVGText::positionForPoint(const LayoutPoint& pointInContents)
451 {
452 RootInlineBox* rootBox = firstRootBox();
453 if (!rootBox)
454 return createPositionWithAffinity(0, DOWNSTREAM);
455
456 ASSERT(!rootBox->nextRootBox());
457 ASSERT(childrenInline());
458
459 InlineBox* closestBox = toSVGRootInlineBox(rootBox)->closestLeafChildForPosition(pointInContents);
460 if (!closestBox)
461 return createPositionWithAffinity(0, DOWNSTREAM);
462
463 return closestBox->renderer().positionForPoint(LayoutPoint(pointInContents.x(), closestBox->y()));
464 }
465
absoluteQuads(Vector<FloatQuad> & quads,bool * wasFixed) const466 void RenderSVGText::absoluteQuads(Vector<FloatQuad>& quads, bool* wasFixed) const
467 {
468 quads.append(localToAbsoluteQuad(strokeBoundingBox(), 0 /* mode */, wasFixed));
469 }
470
paint(PaintInfo & paintInfo,const LayoutPoint &)471 void RenderSVGText::paint(PaintInfo& paintInfo, const LayoutPoint&)
472 {
473 if (paintInfo.context->paintingDisabled())
474 return;
475
476 if (paintInfo.phase != PaintPhaseForeground
477 && paintInfo.phase != PaintPhaseSelection)
478 return;
479
480 PaintInfo blockInfo(paintInfo);
481 GraphicsContextStateSaver stateSaver(*blockInfo.context, false);
482 const AffineTransform& localTransform = localToParentTransform();
483 if (!localTransform.isIdentity()) {
484 stateSaver.save();
485 blockInfo.applyTransform(localTransform, false);
486 }
487 RenderBlock::paint(blockInfo, LayoutPoint());
488
489 // Paint the outlines, if any
490 if (paintInfo.phase == PaintPhaseForeground) {
491 blockInfo.phase = PaintPhaseSelfOutline;
492 RenderBlock::paint(blockInfo, LayoutPoint());
493 }
494 }
495
strokeBoundingBox() const496 FloatRect RenderSVGText::strokeBoundingBox() const
497 {
498 FloatRect strokeBoundaries = objectBoundingBox();
499 const SVGRenderStyle* svgStyle = style()->svgStyle();
500 if (!svgStyle->hasStroke())
501 return strokeBoundaries;
502
503 ASSERT(node());
504 ASSERT(node()->isSVGElement());
505 SVGLengthContext lengthContext(toSVGElement(node()));
506 strokeBoundaries.inflate(svgStyle->strokeWidth()->value(lengthContext));
507 return strokeBoundaries;
508 }
509
paintInvalidationRectInLocalCoordinates() const510 FloatRect RenderSVGText::paintInvalidationRectInLocalCoordinates() const
511 {
512 FloatRect repaintRect = strokeBoundingBox();
513 SVGRenderSupport::intersectRepaintRectWithResources(this, repaintRect);
514
515 if (const ShadowList* textShadow = style()->textShadow())
516 textShadow->adjustRectForShadow(repaintRect);
517
518 return repaintRect;
519 }
520
addChild(RenderObject * child,RenderObject * beforeChild)521 void RenderSVGText::addChild(RenderObject* child, RenderObject* beforeChild)
522 {
523 RenderSVGBlock::addChild(child, beforeChild);
524
525 SVGResourcesCache::clientWasAddedToTree(child, child->style());
526 subtreeChildWasAdded(child);
527 }
528
removeChild(RenderObject * child)529 void RenderSVGText::removeChild(RenderObject* child)
530 {
531 SVGResourcesCache::clientWillBeRemovedFromTree(child);
532
533 Vector<SVGTextLayoutAttributes*, 2> affectedAttributes;
534 FontCachePurgePreventer fontCachePurgePreventer;
535 subtreeChildWillBeRemoved(child, affectedAttributes);
536 RenderSVGBlock::removeChild(child);
537 subtreeChildWasRemoved(affectedAttributes);
538 }
539
540 // Fix for <rdar://problem/8048875>. We should not render :first-line CSS Style
541 // in a SVG text element context.
firstLineBlock() const542 RenderBlock* RenderSVGText::firstLineBlock() const
543 {
544 return 0;
545 }
546
547 // Fix for <rdar://problem/8048875>. We should not render :first-letter CSS Style
548 // in a SVG text element context.
updateFirstLetter()549 void RenderSVGText::updateFirstLetter()
550 {
551 }
552
553 }
554