OLD | NEW |
1 /* | 1 /* |
2 * Copyright (C) Research In Motion Limited 2010. All rights reserved. | 2 * Copyright (C) Research In Motion Limited 2010. All rights reserved. |
3 * | 3 * |
4 * This library is free software; you can redistribute it and/or | 4 * This library is free software; you can redistribute it and/or |
5 * modify it under the terms of the GNU Library General Public | 5 * modify it under the terms of the GNU Library General Public |
6 * License as published by the Free Software Foundation; either | 6 * License as published by the Free Software Foundation; either |
7 * version 2 of the License, or (at your option) any later version. | 7 * version 2 of the License, or (at your option) any later version. |
8 * | 8 * |
9 * This library is distributed in the hope that it will be useful, | 9 * This library is distributed in the hope that it will be useful, |
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of | 10 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
(...skipping 23 matching lines...) Expand all Loading... |
34 | 34 |
35 #ifndef NDEBUG | 35 #ifndef NDEBUG |
36 #include <stdio.h> | 36 #include <stdio.h> |
37 #endif | 37 #endif |
38 | 38 |
39 namespace blink { | 39 namespace blink { |
40 | 40 |
41 using namespace SVGNames; | 41 using namespace SVGNames; |
42 | 42 |
43 SVGResources::SVGResources() | 43 SVGResources::SVGResources() |
44 : m_linkedResource(0) | 44 : m_linkedResource(nullptr) |
45 { | 45 { |
46 } | 46 } |
47 | 47 |
48 static HashSet<AtomicString>& clipperFilterMaskerTags() | 48 static HashSet<AtomicString>& clipperFilterMaskerTags() |
49 { | 49 { |
50 DEFINE_STATIC_LOCAL(HashSet<AtomicString>, s_tagList, ()); | 50 DEFINE_STATIC_LOCAL(HashSet<AtomicString>, s_tagList, ()); |
51 if (s_tagList.isEmpty()) { | 51 if (s_tagList.isEmpty()) { |
52 // "container elements": http://www.w3.org/TR/SVG11/intro.html#TermConta
inerElement | 52 // "container elements": http://www.w3.org/TR/SVG11/intro.html#TermConta
inerElement |
53 // "graphics elements" : http://www.w3.org/TR/SVG11/intro.html#TermGraph
icsElement | 53 // "graphics elements" : http://www.w3.org/TR/SVG11/intro.html#TermGraph
icsElement |
54 s_tagList.add(aTag.localName()); | 54 s_tagList.add(aTag.localName()); |
(...skipping 105 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
160 return true; | 160 return true; |
161 default: | 161 default: |
162 break; | 162 break; |
163 } | 163 } |
164 return false; | 164 return false; |
165 } | 165 } |
166 | 166 |
167 static inline RenderSVGResourcePaintServer* paintingResourceFromSVGPaint(TreeSco
pe& treeScope, const SVGPaintType& paintType, const String& paintUri, AtomicStri
ng& id, bool& hasPendingResource) | 167 static inline RenderSVGResourcePaintServer* paintingResourceFromSVGPaint(TreeSco
pe& treeScope, const SVGPaintType& paintType, const String& paintUri, AtomicStri
ng& id, bool& hasPendingResource) |
168 { | 168 { |
169 if (!svgPaintTypeHasURL(paintType)) | 169 if (!svgPaintTypeHasURL(paintType)) |
170 return 0; | 170 return nullptr; |
171 | 171 |
172 id = SVGURIReference::fragmentIdentifierFromIRIString(paintUri, treeScope); | 172 id = SVGURIReference::fragmentIdentifierFromIRIString(paintUri, treeScope); |
173 RenderSVGResourceContainer* container = getRenderSVGResourceContainerById(tr
eeScope, id); | 173 RenderSVGResourceContainer* container = getRenderSVGResourceContainerById(tr
eeScope, id); |
174 if (!container) { | 174 if (!container) { |
175 hasPendingResource = true; | 175 hasPendingResource = true; |
176 return 0; | 176 return nullptr; |
177 } | 177 } |
178 | 178 |
179 if (!container->isSVGPaintServer()) | 179 if (!container->isSVGPaintServer()) |
180 return 0; | 180 return nullptr; |
181 | 181 |
182 return toRenderSVGResourcePaintServer(container); | 182 return toRenderSVGResourcePaintServer(container); |
183 } | 183 } |
184 | 184 |
185 static inline void registerPendingResource(SVGDocumentExtensions& extensions, co
nst AtomicString& id, SVGElement* element) | 185 static inline void registerPendingResource(SVGDocumentExtensions& extensions, co
nst AtomicString& id, SVGElement* element) |
186 { | 186 { |
187 ASSERT(element); | 187 ASSERT(element); |
188 extensions.addPendingResource(id, element); | 188 extensions.addPendingResource(id, element); |
189 } | 189 } |
190 | 190 |
191 bool SVGResources::hasResourceData() const | 191 bool SVGResources::hasResourceData() const |
192 { | 192 { |
193 return m_clipperFilterMaskerData | 193 return m_clipperFilterMaskerData |
194 || m_markerData | 194 || m_markerData |
195 || m_fillStrokeData | 195 || m_fillStrokeData |
196 || m_linkedResource; | 196 || m_linkedResource; |
197 } | 197 } |
198 | 198 |
199 static inline SVGResources* ensureResources(OwnPtr<SVGResources>& resources) | 199 static inline SVGResources& ensureResources(OwnPtr<SVGResources>& resources) |
200 { | 200 { |
201 if (!resources) | 201 if (!resources) |
202 resources = adoptPtr(new SVGResources); | 202 resources = adoptPtr(new SVGResources); |
203 | 203 |
204 return resources.get(); | 204 return *resources.get(); |
205 } | 205 } |
206 | 206 |
207 PassOwnPtr<SVGResources> SVGResources::buildResources(const RenderObject* object
, const SVGRenderStyle& style) | 207 PassOwnPtr<SVGResources> SVGResources::buildResources(const RenderObject* object
, const SVGRenderStyle& style) |
208 { | 208 { |
209 ASSERT(object); | 209 ASSERT(object); |
210 | 210 |
211 Node* node = object->node(); | 211 Node* node = object->node(); |
212 ASSERT(node); | 212 ASSERT(node); |
213 ASSERT_WITH_SECURITY_IMPLICATION(node->isSVGElement()); | 213 ASSERT_WITH_SECURITY_IMPLICATION(node->isSVGElement()); |
214 | 214 |
215 SVGElement* element = toSVGElement(node); | 215 SVGElement* element = toSVGElement(node); |
216 if (!element) | 216 ASSERT(element); |
217 return nullptr; | 217 |
| 218 const AtomicString& tagName = element->localName(); |
| 219 ASSERT(!tagName.isNull()); |
218 | 220 |
219 TreeScope& treeScope = element->treeScope(); | 221 TreeScope& treeScope = element->treeScope(); |
220 | 222 SVGDocumentExtensions& extensions = element->document().accessSVGExtensions(
); |
221 SVGDocumentExtensions& extensions = object->document().accessSVGExtensions()
; | |
222 | |
223 const AtomicString& tagName = element->localName(); | |
224 if (tagName.isNull()) | |
225 return nullptr; | |
226 | 223 |
227 OwnPtr<SVGResources> resources; | 224 OwnPtr<SVGResources> resources; |
228 if (clipperFilterMaskerTags().contains(tagName)) { | 225 if (clipperFilterMaskerTags().contains(tagName)) { |
229 if (style.hasClipper()) { | 226 if (style.hasClipper()) { |
230 AtomicString id = style.clipperResource(); | 227 AtomicString id = style.clipperResource(); |
231 if (!ensureResources(resources)->setClipper(getRenderSVGResourceById
<RenderSVGResourceClipper>(treeScope, id))) | 228 if (!ensureResources(resources).setClipper(getRenderSVGResourceById<
RenderSVGResourceClipper>(treeScope, id))) |
232 registerPendingResource(extensions, id, element); | 229 registerPendingResource(extensions, id, element); |
233 } | 230 } |
234 | 231 |
235 if (style.hasFilter()) { | 232 if (style.hasFilter()) { |
236 AtomicString id = style.filterResource(); | 233 AtomicString id = style.filterResource(); |
237 if (!ensureResources(resources)->setFilter(getRenderSVGResourceById<
RenderSVGResourceFilter>(treeScope, id))) | 234 if (!ensureResources(resources).setFilter(getRenderSVGResourceById<R
enderSVGResourceFilter>(treeScope, id))) |
238 registerPendingResource(extensions, id, element); | 235 registerPendingResource(extensions, id, element); |
239 } | 236 } |
240 | 237 |
241 if (style.hasMasker()) { | 238 if (style.hasMasker()) { |
242 AtomicString id = style.maskerResource(); | 239 AtomicString id = style.maskerResource(); |
243 if (!ensureResources(resources)->setMasker(getRenderSVGResourceById<
RenderSVGResourceMasker>(treeScope, id))) | 240 if (!ensureResources(resources).setMasker(getRenderSVGResourceById<R
enderSVGResourceMasker>(treeScope, id))) |
244 registerPendingResource(extensions, id, element); | 241 registerPendingResource(extensions, id, element); |
245 } | 242 } |
246 } | 243 } |
247 | 244 |
248 if (style.hasMarkers() && supportsMarkers(*element)) { | 245 if (style.hasMarkers() && supportsMarkers(*element)) { |
249 const AtomicString& markerStartId = style.markerStartResource(); | 246 const AtomicString& markerStartId = style.markerStartResource(); |
250 if (!ensureResources(resources)->setMarkerStart(getRenderSVGResourceById
<RenderSVGResourceMarker>(treeScope, markerStartId))) | 247 if (!ensureResources(resources).setMarkerStart(getRenderSVGResourceById<
RenderSVGResourceMarker>(treeScope, markerStartId))) |
251 registerPendingResource(extensions, markerStartId, element); | 248 registerPendingResource(extensions, markerStartId, element); |
252 | 249 |
253 const AtomicString& markerMidId = style.markerMidResource(); | 250 const AtomicString& markerMidId = style.markerMidResource(); |
254 if (!ensureResources(resources)->setMarkerMid(getRenderSVGResourceById<R
enderSVGResourceMarker>(treeScope, markerMidId))) | 251 if (!ensureResources(resources).setMarkerMid(getRenderSVGResourceById<Re
nderSVGResourceMarker>(treeScope, markerMidId))) |
255 registerPendingResource(extensions, markerMidId, element); | 252 registerPendingResource(extensions, markerMidId, element); |
256 | 253 |
257 const AtomicString& markerEndId = style.markerEndResource(); | 254 const AtomicString& markerEndId = style.markerEndResource(); |
258 if (!ensureResources(resources)->setMarkerEnd(getRenderSVGResourceById<R
enderSVGResourceMarker>(treeScope, style.markerEndResource()))) | 255 if (!ensureResources(resources).setMarkerEnd(getRenderSVGResourceById<Re
nderSVGResourceMarker>(treeScope, style.markerEndResource()))) |
259 registerPendingResource(extensions, markerEndId, element); | 256 registerPendingResource(extensions, markerEndId, element); |
260 } | 257 } |
261 | 258 |
262 if (fillAndStrokeTags().contains(tagName)) { | 259 if (fillAndStrokeTags().contains(tagName)) { |
263 if (style.hasFill()) { | 260 if (style.hasFill()) { |
264 bool hasPendingResource = false; | 261 bool hasPendingResource = false; |
265 AtomicString id; | 262 AtomicString id; |
266 RenderSVGResourcePaintServer* resource = paintingResourceFromSVGPain
t(treeScope, style.fillPaintType(), style.fillPaintUri(), id, hasPendingResource
); | 263 RenderSVGResourcePaintServer* resource = paintingResourceFromSVGPain
t(treeScope, style.fillPaintType(), style.fillPaintUri(), id, hasPendingResource
); |
267 if (!ensureResources(resources)->setFill(resource) && hasPendingReso
urce) { | 264 if (!ensureResources(resources).setFill(resource) && hasPendingResou
rce) { |
268 registerPendingResource(extensions, id, element); | 265 registerPendingResource(extensions, id, element); |
269 } | 266 } |
270 } | 267 } |
271 | 268 |
272 if (style.hasStroke()) { | 269 if (style.hasStroke()) { |
273 bool hasPendingResource = false; | 270 bool hasPendingResource = false; |
274 AtomicString id; | 271 AtomicString id; |
275 RenderSVGResourcePaintServer* resource = paintingResourceFromSVGPain
t(treeScope, style.strokePaintType(), style.strokePaintUri(), id, hasPendingReso
urce); | 272 RenderSVGResourcePaintServer* resource = paintingResourceFromSVGPain
t(treeScope, style.strokePaintType(), style.strokePaintUri(), id, hasPendingReso
urce); |
276 if (!ensureResources(resources)->setStroke(resource) && hasPendingRe
source) { | 273 if (!ensureResources(resources).setStroke(resource) && hasPendingRes
ource) { |
277 registerPendingResource(extensions, id, element); | 274 registerPendingResource(extensions, id, element); |
278 } | 275 } |
279 } | 276 } |
280 } | 277 } |
281 | 278 |
282 if (chainableResourceTags().contains(tagName)) { | 279 if (chainableResourceTags().contains(tagName)) { |
283 AtomicString id = targetReferenceFromResource(*element); | 280 AtomicString id = targetReferenceFromResource(*element); |
284 if (!ensureResources(resources)->setLinkedResource(getRenderSVGResourceC
ontainerById(treeScope, id))) | 281 if (!ensureResources(resources).setLinkedResource(getRenderSVGResourceCo
ntainerById(treeScope, id))) |
285 registerPendingResource(extensions, id, element); | 282 registerPendingResource(extensions, id, element); |
286 } | 283 } |
287 | 284 |
288 return (!resources || !resources->hasResourceData()) ? nullptr : resources.r
elease(); | 285 return (!resources || !resources->hasResourceData()) ? nullptr : resources.r
elease(); |
289 } | 286 } |
290 | 287 |
291 void SVGResources::layoutIfNeeded() | 288 void SVGResources::layoutIfNeeded() |
292 { | 289 { |
293 if (m_clipperFilterMaskerData) { | 290 if (m_clipperFilterMaskerData) { |
294 if (RenderSVGResourceClipper* clipper = m_clipperFilterMaskerData->clipp
er) | 291 if (RenderSVGResourceClipper* clipper = m_clipperFilterMaskerData->clipp
er) |
(...skipping 67 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
362 { | 359 { |
363 ASSERT(resource); | 360 ASSERT(resource); |
364 if (!hasResourceData()) | 361 if (!hasResourceData()) |
365 return; | 362 return; |
366 | 363 |
367 if (m_linkedResource == resource) { | 364 if (m_linkedResource == resource) { |
368 ASSERT(!m_clipperFilterMaskerData); | 365 ASSERT(!m_clipperFilterMaskerData); |
369 ASSERT(!m_markerData); | 366 ASSERT(!m_markerData); |
370 ASSERT(!m_fillStrokeData); | 367 ASSERT(!m_fillStrokeData); |
371 m_linkedResource->removeAllClientsFromCache(); | 368 m_linkedResource->removeAllClientsFromCache(); |
372 m_linkedResource = 0; | 369 m_linkedResource = nullptr; |
373 return; | 370 return; |
374 } | 371 } |
375 | 372 |
376 switch (resource->resourceType()) { | 373 switch (resource->resourceType()) { |
377 case MaskerResourceType: | 374 case MaskerResourceType: |
378 if (!m_clipperFilterMaskerData) | 375 if (!m_clipperFilterMaskerData) |
379 break; | 376 break; |
380 if (m_clipperFilterMaskerData->masker == resource) { | 377 if (m_clipperFilterMaskerData->masker == resource) { |
381 m_clipperFilterMaskerData->masker->removeAllClientsFromCache(); | 378 m_clipperFilterMaskerData->masker->removeAllClientsFromCache(); |
382 m_clipperFilterMaskerData->masker = 0; | 379 m_clipperFilterMaskerData->masker = nullptr; |
383 } | 380 } |
384 break; | 381 break; |
385 case MarkerResourceType: | 382 case MarkerResourceType: |
386 if (!m_markerData) | 383 if (!m_markerData) |
387 break; | 384 break; |
388 if (m_markerData->markerStart == resource) { | 385 if (m_markerData->markerStart == resource) { |
389 m_markerData->markerStart->removeAllClientsFromCache(); | 386 m_markerData->markerStart->removeAllClientsFromCache(); |
390 m_markerData->markerStart = 0; | 387 m_markerData->markerStart = nullptr; |
391 } | 388 } |
392 if (m_markerData->markerMid == resource) { | 389 if (m_markerData->markerMid == resource) { |
393 m_markerData->markerMid->removeAllClientsFromCache(); | 390 m_markerData->markerMid->removeAllClientsFromCache(); |
394 m_markerData->markerMid = 0; | 391 m_markerData->markerMid = nullptr; |
395 } | 392 } |
396 if (m_markerData->markerEnd == resource) { | 393 if (m_markerData->markerEnd == resource) { |
397 m_markerData->markerEnd->removeAllClientsFromCache(); | 394 m_markerData->markerEnd->removeAllClientsFromCache(); |
398 m_markerData->markerEnd = 0; | 395 m_markerData->markerEnd = nullptr; |
399 } | 396 } |
400 break; | 397 break; |
401 case PatternResourceType: | 398 case PatternResourceType: |
402 case LinearGradientResourceType: | 399 case LinearGradientResourceType: |
403 case RadialGradientResourceType: | 400 case RadialGradientResourceType: |
404 if (!m_fillStrokeData) | 401 if (!m_fillStrokeData) |
405 break; | 402 break; |
406 if (m_fillStrokeData->fill == resource) { | 403 if (m_fillStrokeData->fill == resource) { |
407 m_fillStrokeData->fill->removeAllClientsFromCache(); | 404 m_fillStrokeData->fill->removeAllClientsFromCache(); |
408 m_fillStrokeData->fill = 0; | 405 m_fillStrokeData->fill = nullptr; |
409 } | 406 } |
410 if (m_fillStrokeData->stroke == resource) { | 407 if (m_fillStrokeData->stroke == resource) { |
411 m_fillStrokeData->stroke->removeAllClientsFromCache(); | 408 m_fillStrokeData->stroke->removeAllClientsFromCache(); |
412 m_fillStrokeData->stroke = 0; | 409 m_fillStrokeData->stroke = nullptr; |
413 } | 410 } |
414 break; | 411 break; |
415 case FilterResourceType: | 412 case FilterResourceType: |
416 if (!m_clipperFilterMaskerData) | 413 if (!m_clipperFilterMaskerData) |
417 break; | 414 break; |
418 if (m_clipperFilterMaskerData->filter == resource) { | 415 if (m_clipperFilterMaskerData->filter == resource) { |
419 m_clipperFilterMaskerData->filter->removeAllClientsFromCache(); | 416 m_clipperFilterMaskerData->filter->removeAllClientsFromCache(); |
420 m_clipperFilterMaskerData->filter = 0; | 417 m_clipperFilterMaskerData->filter = nullptr; |
421 } | 418 } |
422 break; | 419 break; |
423 case ClipperResourceType: | 420 case ClipperResourceType: |
424 if (!m_clipperFilterMaskerData) | 421 if (!m_clipperFilterMaskerData) |
425 break; | 422 break; |
426 if (m_clipperFilterMaskerData->clipper == resource) { | 423 if (m_clipperFilterMaskerData->clipper == resource) { |
427 m_clipperFilterMaskerData->clipper->removeAllClientsFromCache(); | 424 m_clipperFilterMaskerData->clipper->removeAllClientsFromCache(); |
428 m_clipperFilterMaskerData->clipper = 0; | 425 m_clipperFilterMaskerData->clipper = nullptr; |
429 } | 426 } |
430 break; | 427 break; |
431 default: | 428 default: |
432 ASSERT_NOT_REACHED(); | 429 ASSERT_NOT_REACHED(); |
433 } | 430 } |
434 } | 431 } |
435 | 432 |
436 void SVGResources::buildSetOfResources(HashSet<RenderSVGResourceContainer*>& set
) | 433 void SVGResources::buildSetOfResources(HashSet<RenderSVGResourceContainer*>& set
) |
437 { | 434 { |
438 if (!hasResourceData()) | 435 if (!hasResourceData()) |
(...skipping 44 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
483 m_clipperFilterMaskerData = ClipperFilterMaskerData::create(); | 480 m_clipperFilterMaskerData = ClipperFilterMaskerData::create(); |
484 | 481 |
485 m_clipperFilterMaskerData->clipper = clipper; | 482 m_clipperFilterMaskerData->clipper = clipper; |
486 return true; | 483 return true; |
487 } | 484 } |
488 | 485 |
489 void SVGResources::resetClipper() | 486 void SVGResources::resetClipper() |
490 { | 487 { |
491 ASSERT(m_clipperFilterMaskerData); | 488 ASSERT(m_clipperFilterMaskerData); |
492 ASSERT(m_clipperFilterMaskerData->clipper); | 489 ASSERT(m_clipperFilterMaskerData->clipper); |
493 m_clipperFilterMaskerData->clipper = 0; | 490 m_clipperFilterMaskerData->clipper = nullptr; |
494 } | 491 } |
495 | 492 |
496 bool SVGResources::setFilter(RenderSVGResourceFilter* filter) | 493 bool SVGResources::setFilter(RenderSVGResourceFilter* filter) |
497 { | 494 { |
498 if (!filter) | 495 if (!filter) |
499 return false; | 496 return false; |
500 | 497 |
501 ASSERT(filter->resourceType() == FilterResourceType); | 498 ASSERT(filter->resourceType() == FilterResourceType); |
502 | 499 |
503 if (!m_clipperFilterMaskerData) | 500 if (!m_clipperFilterMaskerData) |
504 m_clipperFilterMaskerData = ClipperFilterMaskerData::create(); | 501 m_clipperFilterMaskerData = ClipperFilterMaskerData::create(); |
505 | 502 |
506 m_clipperFilterMaskerData->filter = filter; | 503 m_clipperFilterMaskerData->filter = filter; |
507 return true; | 504 return true; |
508 } | 505 } |
509 | 506 |
510 void SVGResources::resetFilter() | 507 void SVGResources::resetFilter() |
511 { | 508 { |
512 ASSERT(m_clipperFilterMaskerData); | 509 ASSERT(m_clipperFilterMaskerData); |
513 ASSERT(m_clipperFilterMaskerData->filter); | 510 ASSERT(m_clipperFilterMaskerData->filter); |
514 m_clipperFilterMaskerData->filter = 0; | 511 m_clipperFilterMaskerData->filter = nullptr; |
515 } | 512 } |
516 | 513 |
517 bool SVGResources::setMarkerStart(RenderSVGResourceMarker* markerStart) | 514 bool SVGResources::setMarkerStart(RenderSVGResourceMarker* markerStart) |
518 { | 515 { |
519 if (!markerStart) | 516 if (!markerStart) |
520 return false; | 517 return false; |
521 | 518 |
522 ASSERT(markerStart->resourceType() == MarkerResourceType); | 519 ASSERT(markerStart->resourceType() == MarkerResourceType); |
523 | 520 |
524 if (!m_markerData) | 521 if (!m_markerData) |
525 m_markerData = MarkerData::create(); | 522 m_markerData = MarkerData::create(); |
526 | 523 |
527 m_markerData->markerStart = markerStart; | 524 m_markerData->markerStart = markerStart; |
528 return true; | 525 return true; |
529 } | 526 } |
530 | 527 |
531 void SVGResources::resetMarkerStart() | 528 void SVGResources::resetMarkerStart() |
532 { | 529 { |
533 ASSERT(m_markerData); | 530 ASSERT(m_markerData); |
534 ASSERT(m_markerData->markerStart); | 531 ASSERT(m_markerData->markerStart); |
535 m_markerData->markerStart = 0; | 532 m_markerData->markerStart = nullptr; |
536 } | 533 } |
537 | 534 |
538 bool SVGResources::setMarkerMid(RenderSVGResourceMarker* markerMid) | 535 bool SVGResources::setMarkerMid(RenderSVGResourceMarker* markerMid) |
539 { | 536 { |
540 if (!markerMid) | 537 if (!markerMid) |
541 return false; | 538 return false; |
542 | 539 |
543 ASSERT(markerMid->resourceType() == MarkerResourceType); | 540 ASSERT(markerMid->resourceType() == MarkerResourceType); |
544 | 541 |
545 if (!m_markerData) | 542 if (!m_markerData) |
546 m_markerData = MarkerData::create(); | 543 m_markerData = MarkerData::create(); |
547 | 544 |
548 m_markerData->markerMid = markerMid; | 545 m_markerData->markerMid = markerMid; |
549 return true; | 546 return true; |
550 } | 547 } |
551 | 548 |
552 void SVGResources::resetMarkerMid() | 549 void SVGResources::resetMarkerMid() |
553 { | 550 { |
554 ASSERT(m_markerData); | 551 ASSERT(m_markerData); |
555 ASSERT(m_markerData->markerMid); | 552 ASSERT(m_markerData->markerMid); |
556 m_markerData->markerMid = 0; | 553 m_markerData->markerMid = nullptr; |
557 } | 554 } |
558 | 555 |
559 bool SVGResources::setMarkerEnd(RenderSVGResourceMarker* markerEnd) | 556 bool SVGResources::setMarkerEnd(RenderSVGResourceMarker* markerEnd) |
560 { | 557 { |
561 if (!markerEnd) | 558 if (!markerEnd) |
562 return false; | 559 return false; |
563 | 560 |
564 ASSERT(markerEnd->resourceType() == MarkerResourceType); | 561 ASSERT(markerEnd->resourceType() == MarkerResourceType); |
565 | 562 |
566 if (!m_markerData) | 563 if (!m_markerData) |
567 m_markerData = MarkerData::create(); | 564 m_markerData = MarkerData::create(); |
568 | 565 |
569 m_markerData->markerEnd = markerEnd; | 566 m_markerData->markerEnd = markerEnd; |
570 return true; | 567 return true; |
571 } | 568 } |
572 | 569 |
573 void SVGResources::resetMarkerEnd() | 570 void SVGResources::resetMarkerEnd() |
574 { | 571 { |
575 ASSERT(m_markerData); | 572 ASSERT(m_markerData); |
576 ASSERT(m_markerData->markerEnd); | 573 ASSERT(m_markerData->markerEnd); |
577 m_markerData->markerEnd = 0; | 574 m_markerData->markerEnd = nullptr; |
578 } | 575 } |
579 | 576 |
580 bool SVGResources::setMasker(RenderSVGResourceMasker* masker) | 577 bool SVGResources::setMasker(RenderSVGResourceMasker* masker) |
581 { | 578 { |
582 if (!masker) | 579 if (!masker) |
583 return false; | 580 return false; |
584 | 581 |
585 ASSERT(masker->resourceType() == MaskerResourceType); | 582 ASSERT(masker->resourceType() == MaskerResourceType); |
586 | 583 |
587 if (!m_clipperFilterMaskerData) | 584 if (!m_clipperFilterMaskerData) |
588 m_clipperFilterMaskerData = ClipperFilterMaskerData::create(); | 585 m_clipperFilterMaskerData = ClipperFilterMaskerData::create(); |
589 | 586 |
590 m_clipperFilterMaskerData->masker = masker; | 587 m_clipperFilterMaskerData->masker = masker; |
591 return true; | 588 return true; |
592 } | 589 } |
593 | 590 |
594 void SVGResources::resetMasker() | 591 void SVGResources::resetMasker() |
595 { | 592 { |
596 ASSERT(m_clipperFilterMaskerData); | 593 ASSERT(m_clipperFilterMaskerData); |
597 ASSERT(m_clipperFilterMaskerData->masker); | 594 ASSERT(m_clipperFilterMaskerData->masker); |
598 m_clipperFilterMaskerData->masker = 0; | 595 m_clipperFilterMaskerData->masker = nullptr; |
599 } | 596 } |
600 | 597 |
601 bool SVGResources::setFill(RenderSVGResourcePaintServer* fill) | 598 bool SVGResources::setFill(RenderSVGResourcePaintServer* fill) |
602 { | 599 { |
603 if (!fill) | 600 if (!fill) |
604 return false; | 601 return false; |
605 | 602 |
606 if (!m_fillStrokeData) | 603 if (!m_fillStrokeData) |
607 m_fillStrokeData = FillStrokeData::create(); | 604 m_fillStrokeData = FillStrokeData::create(); |
608 | 605 |
609 m_fillStrokeData->fill = fill; | 606 m_fillStrokeData->fill = fill; |
610 return true; | 607 return true; |
611 } | 608 } |
612 | 609 |
613 void SVGResources::resetFill() | 610 void SVGResources::resetFill() |
614 { | 611 { |
615 ASSERT(m_fillStrokeData); | 612 ASSERT(m_fillStrokeData); |
616 ASSERT(m_fillStrokeData->fill); | 613 ASSERT(m_fillStrokeData->fill); |
617 m_fillStrokeData->fill = 0; | 614 m_fillStrokeData->fill = nullptr; |
618 } | 615 } |
619 | 616 |
620 bool SVGResources::setStroke(RenderSVGResourcePaintServer* stroke) | 617 bool SVGResources::setStroke(RenderSVGResourcePaintServer* stroke) |
621 { | 618 { |
622 if (!stroke) | 619 if (!stroke) |
623 return false; | 620 return false; |
624 | 621 |
625 if (!m_fillStrokeData) | 622 if (!m_fillStrokeData) |
626 m_fillStrokeData = FillStrokeData::create(); | 623 m_fillStrokeData = FillStrokeData::create(); |
627 | 624 |
628 m_fillStrokeData->stroke = stroke; | 625 m_fillStrokeData->stroke = stroke; |
629 return true; | 626 return true; |
630 } | 627 } |
631 | 628 |
632 void SVGResources::resetStroke() | 629 void SVGResources::resetStroke() |
633 { | 630 { |
634 ASSERT(m_fillStrokeData); | 631 ASSERT(m_fillStrokeData); |
635 ASSERT(m_fillStrokeData->stroke); | 632 ASSERT(m_fillStrokeData->stroke); |
636 m_fillStrokeData->stroke = 0; | 633 m_fillStrokeData->stroke = nullptr; |
637 } | 634 } |
638 | 635 |
639 bool SVGResources::setLinkedResource(RenderSVGResourceContainer* linkedResource) | 636 bool SVGResources::setLinkedResource(RenderSVGResourceContainer* linkedResource) |
640 { | 637 { |
641 if (!linkedResource) | 638 if (!linkedResource) |
642 return false; | 639 return false; |
643 | 640 |
644 m_linkedResource = linkedResource; | 641 m_linkedResource = linkedResource; |
645 return true; | 642 return true; |
646 } | 643 } |
647 | 644 |
648 void SVGResources::resetLinkedResource() | 645 void SVGResources::resetLinkedResource() |
649 { | 646 { |
650 ASSERT(m_linkedResource); | 647 ASSERT(m_linkedResource); |
651 m_linkedResource = 0; | 648 m_linkedResource = nullptr; |
652 } | 649 } |
653 | 650 |
654 #ifndef NDEBUG | 651 #ifndef NDEBUG |
655 void SVGResources::dump(const RenderObject* object) | 652 void SVGResources::dump(const RenderObject* object) |
656 { | 653 { |
657 ASSERT(object); | 654 ASSERT(object); |
658 ASSERT(object->node()); | 655 ASSERT(object->node()); |
659 | 656 |
660 fprintf(stderr, "-> this=%p, SVGResources(renderer=%p, node=%p)\n", this, ob
ject, object->node()); | 657 fprintf(stderr, "-> this=%p, SVGResources(renderer=%p, node=%p)\n", this, ob
ject, object->node()); |
661 fprintf(stderr, " | DOM Tree:\n"); | 658 fprintf(stderr, " | DOM Tree:\n"); |
(...skipping 24 matching lines...) Expand all Loading... |
686 if (RenderSVGResourcePaintServer* stroke = m_fillStrokeData->stroke) | 683 if (RenderSVGResourcePaintServer* stroke = m_fillStrokeData->stroke) |
687 fprintf(stderr, " |-> Stroke : %p (node=%p)\n", stroke, stroke->
element()); | 684 fprintf(stderr, " |-> Stroke : %p (node=%p)\n", stroke, stroke->
element()); |
688 } | 685 } |
689 | 686 |
690 if (m_linkedResource) | 687 if (m_linkedResource) |
691 fprintf(stderr, " |-> xlink:href : %p (node=%p)\n", m_linkedResource, m_
linkedResource->element()); | 688 fprintf(stderr, " |-> xlink:href : %p (node=%p)\n", m_linkedResource, m_
linkedResource->element()); |
692 } | 689 } |
693 #endif | 690 #endif |
694 | 691 |
695 } | 692 } |
OLD | NEW |