Changeset 172730 in webkit
- Timestamp:
- Aug 18, 2014 3:16:47 PM (10 years ago)
- Location:
- trunk/Source/WebCore
- Files:
-
- 9 edited
Legend:
- Unmodified
- Added
- Removed
-
trunk/Source/WebCore/ChangeLog
r172729 r172730 1 2014-08-18 Antti Koivisto <antti@apple.com> 2 3 Tighten RenderCounter typing 4 https://bugs.webkit.org/show_bug.cgi?id=136049 5 6 Reviewed by Andreas Kling. 7 8 RenderObject* -> RenderElement& 9 10 * rendering/CounterNode.cpp: 11 (WebCore::CounterNode::CounterNode): 12 (WebCore::CounterNode::create): 13 (WebCore::showTreeAndMark): 14 * rendering/CounterNode.h: 15 (WebCore::CounterNode::owner): 16 * rendering/RenderCounter.cpp: 17 (WebCore::previousInPreOrder): 18 (WebCore::parentOrPseudoHostElement): 19 (WebCore::previousSiblingOrParent): 20 (WebCore::areRenderersElementsSiblings): 21 (WebCore::nextInPreOrder): 22 (WebCore::planCounter): 23 (WebCore::findPlaceForCounter): 24 (WebCore::makeCounterNode): 25 (WebCore::RenderCounter::originalText): 26 (WebCore::destroyCounterNodeWithoutMapRemoval): 27 (WebCore::RenderCounter::destroyCounterNodes): 28 (WebCore::RenderCounter::destroyCounterNode): 29 (WebCore::RenderCounter::rendererRemovedFromTree): 30 (WebCore::updateCounters): 31 (WebCore::RenderCounter::rendererSubtreeAttached): 32 (WebCore::RenderCounter::rendererStyleChanged): 33 (showCounterRendererTree): 34 * rendering/RenderCounter.h: 35 * rendering/RenderElement.cpp: 36 (WebCore::RenderElement::RenderElement): 37 (WebCore::RenderElement::insertChildInternal): 38 (WebCore::RenderElement::removeChildInternal): 39 (WebCore::RenderElement::styleDidChange): 40 (WebCore::RenderElement::willBeDestroyed): 41 * rendering/RenderElement.h: 42 (WebCore::RenderElement::hasCounterNodeMap): 43 (WebCore::RenderElement::setHasCounterNodeMap): 44 45 Move CounterNodeMap to RenderElement from RenderObject. 46 47 * rendering/RenderObject.cpp: 48 (WebCore::RenderObject::willBeDestroyed): 49 * rendering/RenderObject.h: 50 (WebCore::RenderObject::RenderObjectBitfields::RenderObjectBitfields): 51 (WebCore::RenderObject::hasCounterNodeMap): Deleted. 52 (WebCore::RenderObject::setHasCounterNodeMap): Deleted. 53 1 54 2014-08-18 Peyton Randolph <prandolph@apple.com> 2 55 -
trunk/Source/WebCore/rendering/CounterNode.cpp
r156622 r172730 29 29 namespace WebCore { 30 30 31 CounterNode::CounterNode(RenderElement * o, bool hasResetType, int value)31 CounterNode::CounterNode(RenderElement& owner, bool hasResetType, int value) 32 32 : m_hasResetType(hasResetType) 33 33 , m_value(value) 34 34 , m_countInParent(0) 35 , m_owner(o )35 , m_owner(owner) 36 36 , m_rootRenderer(0) 37 37 , m_parent(0) … … 91 91 } 92 92 93 PassRefPtr<CounterNode> CounterNode::create(RenderElement *owner, bool hasResetType, int value)93 PassRefPtr<CounterNode> CounterNode::create(RenderElement& owner, bool hasResetType, int value) 94 94 { 95 95 return adoptRef(new CounterNode(owner, hasResetType, value)); … … 366 366 current, current->actsAsReset() ? "reset____" : "increment", current->value(), 367 367 current->countInParent(), current->parent(), current->previousSibling(), 368 current->nextSibling(), current->owner());368 current->nextSibling(), ¤t->owner()); 369 369 } 370 370 fflush(stderr); -
trunk/Source/WebCore/rendering/CounterNode.h
r156622 r172730 43 43 class CounterNode : public RefCounted<CounterNode> { 44 44 public: 45 static PassRefPtr<CounterNode> create(RenderElement *, bool isReset, int value);45 static PassRefPtr<CounterNode> create(RenderElement&, bool isReset, int value); 46 46 ~CounterNode(); 47 47 bool actsAsReset() const { return m_hasResetType || !m_parent; } … … 49 49 int value() const { return m_value; } 50 50 int countInParent() const { return m_countInParent; } 51 RenderElement *owner() const { return m_owner; }51 RenderElement& owner() const { return m_owner; } 52 52 void addRenderer(RenderCounter*); 53 53 void removeRenderer(RenderCounter*); … … 72 72 73 73 private: 74 CounterNode(RenderElement *, bool isReset, int value);74 CounterNode(RenderElement&, bool isReset, int value); 75 75 int computeCountInParent() const; 76 76 // Invalidates the text in the renderer of this counter, if any, … … 82 82 int m_value; 83 83 int m_countInParent; 84 RenderElement *m_owner;84 RenderElement& m_owner; 85 85 RenderCounter* m_rootRenderer; 86 86 -
trunk/Source/WebCore/rendering/RenderCounter.cpp
r169011 r172730 45 45 46 46 typedef HashMap<AtomicString, RefPtr<CounterNode>> CounterMap; 47 typedef HashMap<const Render Object*, std::unique_ptr<CounterMap>> CounterMaps;48 49 static CounterNode* makeCounterNode(Render Object*, const AtomicString& identifier, bool alwaysCreateCounter);47 typedef HashMap<const RenderElement*, std::unique_ptr<CounterMap>> CounterMaps; 48 49 static CounterNode* makeCounterNode(RenderElement&, const AtomicString& identifier, bool alwaysCreateCounter); 50 50 51 51 static CounterMaps& counterMaps() … … 57 57 // This function processes the renderer tree in the order of the DOM tree 58 58 // including pseudo elements as defined in CSS 2.1. 59 static RenderObject* previousInPreOrder(const RenderObject* object) 60 { 61 Element* self = toElement(object->node()); 62 Element* previous = ElementTraversal::previousIncludingPseudo(self); 59 static RenderElement* previousInPreOrder(const RenderElement& renderer) 60 { 61 Element* previous = ElementTraversal::previousIncludingPseudo(renderer.element()); 63 62 while (previous && !previous->renderer()) 64 63 previous = ElementTraversal::previousIncludingPseudo(previous); … … 66 65 } 67 66 68 static inline Element* parentOrPseudoHostElement(const Render Object* object)69 { 70 if ( object->node()->isPseudoElement())71 return toPseudoElement(object->node())->hostElement();72 return toElement(object->node())->parentElement();67 static inline Element* parentOrPseudoHostElement(const RenderElement& renderer) 68 { 69 if (renderer.isPseudoElement()) 70 return renderer.generatingElement(); 71 return renderer.element() ? renderer.element()->parentElement() : nullptr; 73 72 } 74 73 75 74 // This function processes the renderer tree in the order of the DOM tree 76 75 // including pseudo elements as defined in CSS 2.1. 77 static RenderObject* previousSiblingOrParent(const RenderObject* object) 78 { 79 Element* self = toElement(object->node()); 80 Element* previous = ElementTraversal::pseudoAwarePreviousSibling(self); 76 static RenderElement* previousSiblingOrParent(const RenderElement& renderer) 77 { 78 Element* previous = ElementTraversal::pseudoAwarePreviousSibling(renderer.element()); 81 79 while (previous && !previous->renderer()) 82 80 previous = ElementTraversal::pseudoAwarePreviousSibling(previous); 83 81 if (previous) 84 82 return previous->renderer(); 85 previous = parentOrPseudoHostElement( object);86 return previous ? previous->renderer() : 0;87 } 88 89 static inline bool areRenderersElementsSiblings( RenderObject* first, RenderObject*second)83 previous = parentOrPseudoHostElement(renderer); 84 return previous ? previous->renderer() : nullptr; 85 } 86 87 static inline bool areRenderersElementsSiblings(const RenderElement& first, const RenderElement& second) 90 88 { 91 89 return parentOrPseudoHostElement(first) == parentOrPseudoHostElement(second); … … 94 92 // This function processes the renderer tree in the order of the DOM tree 95 93 // including pseudo elements as defined in CSS 2.1. 96 static RenderElement* nextInPreOrder(const RenderElement * element, const Element* stayWithin, bool skipDescendants = false)97 { 98 Element* self = element->element();94 static RenderElement* nextInPreOrder(const RenderElement& renderer, const Element* stayWithin, bool skipDescendants = false) 95 { 96 Element* self = renderer.element(); 99 97 Element* next = skipDescendants ? ElementTraversal::nextIncludingPseudoSkippingChildren(self, stayWithin) : ElementTraversal::nextIncludingPseudo(self, stayWithin); 100 98 while (next && !next->renderer()) … … 103 101 } 104 102 105 static bool planCounter(RenderElement* object, const AtomicString& identifier, bool& isReset, int& value) 106 { 107 ASSERT(object); 108 103 static bool planCounter(RenderElement& renderer, const AtomicString& identifier, bool& isReset, int& value) 104 { 109 105 // We must have a generating node or else we cannot have a counter. 110 Element* generatingElement = object->generatingElement();106 Element* generatingElement = renderer.generatingElement(); 111 107 if (!generatingElement) 112 108 return false; 113 109 114 const RenderStyle& style = object->style();110 const RenderStyle& style = renderer.style(); 115 111 116 112 switch (style.styleType()) { … … 118 114 // Sometimes elements have more then one renderer. Only the first one gets the counter 119 115 // LayoutTests/http/tests/css/counter-crash.html 120 if (generatingElement->renderer() != object)116 if (generatingElement->renderer() != &renderer) 121 117 return false; 122 118 break; … … 136 132 137 133 if (identifier == "list-item") { 138 if ( object->isListItem()) {139 if (toRenderListItem( object)->hasExplicitValue()) {140 value = toRenderListItem( object)->explicitValue();134 if (renderer.isListItem()) { 135 if (toRenderListItem(renderer).hasExplicitValue()) { 136 value = toRenderListItem(renderer).explicitValue(); 141 137 isReset = true; 142 138 return true; … … 146 142 return true; 147 143 } 148 if (Element* e = object->element()) {149 if (e ->hasTagName(olTag)) {150 value = toHTMLOListElement(e )->start();144 if (Element* element = renderer.element()) { 145 if (element->hasTagName(olTag)) { 146 value = toHTMLOListElement(element)->start(); 151 147 isReset = true; 152 148 return true; 153 149 } 154 if (e ->hasTagName(ulTag) || e->hasTagName(menuTag) || e->hasTagName(dirTag)) {150 if (element->hasTagName(ulTag) || element->hasTagName(menuTag) || element->hasTagName(dirTag)) { 155 151 value = 0; 156 152 isReset = true; … … 179 175 // - Non-reset CounterNodes cannot have descendants. 180 176 181 static bool findPlaceForCounter(Render Object*counterOwner, const AtomicString& identifier, bool isReset, RefPtr<CounterNode>& parent, RefPtr<CounterNode>& previousSibling)177 static bool findPlaceForCounter(RenderElement& counterOwner, const AtomicString& identifier, bool isReset, RefPtr<CounterNode>& parent, RefPtr<CounterNode>& previousSibling) 182 178 { 183 179 // We cannot stop searching for counters with the same identifier before we also 184 180 // check this renderer, because it may affect the positioning in the tree of our counter. 185 Render Object* searchEndRenderer = previousSiblingOrParent(counterOwner);181 RenderElement* searchEndRenderer = previousSiblingOrParent(counterOwner); 186 182 // We check renderers in preOrder from the renderer that our counter is attached to 187 183 // towards the begining of the document for counters with the same identifier as the one 188 184 // we are trying to find a place for. This is the next renderer to be checked. 189 Render Object* currentRenderer = previousInPreOrder(counterOwner);185 RenderElement* currentRenderer = previousInPreOrder(counterOwner); 190 186 previousSibling = 0; 191 187 RefPtr<CounterNode> previousSiblingProtector = 0; 192 188 193 189 while (currentRenderer) { 194 CounterNode* currentCounter = makeCounterNode( currentRenderer, identifier, false);190 CounterNode* currentCounter = makeCounterNode(*currentRenderer, identifier, false); 195 191 if (searchEndRenderer == currentRenderer) { 196 192 // We may be at the end of our search. … … 200 196 if (currentCounter->actsAsReset()) { 201 197 // We found a reset counter that is on a renderer that is a sibling of ours or a parent. 202 if (isReset && areRenderersElementsSiblings( currentRenderer, counterOwner)) {198 if (isReset && areRenderersElementsSiblings(*currentRenderer, counterOwner)) { 203 199 // We are also a reset counter and the previous reset was on a sibling renderer 204 200 // hence we are the next sibling of that counter if that reset is not a root or … … 221 217 } 222 218 // CurrentCounter, the counter at the EndSearchRenderer, is not reset. 223 if (!isReset || !areRenderersElementsSiblings( currentRenderer, counterOwner)) {219 if (!isReset || !areRenderersElementsSiblings(*currentRenderer, counterOwner)) { 224 220 // If the node we are placing is not reset or we have found a counter that is attached 225 221 // to an ancestor of the placed counter's owner renderer we know we are a sibling of that node. … … 237 233 // to currentCounter. 238 234 if (currentCounter->actsAsReset()) { 239 if (isReset && areRenderersElementsSiblings( currentRenderer, counterOwner)) {235 if (isReset && areRenderersElementsSiblings(*currentRenderer, counterOwner)) { 240 236 parent = currentCounter->parent(); 241 237 previousSibling = currentCounter; … … 246 242 return true; 247 243 } 248 if (!isReset || !areRenderersElementsSiblings( currentRenderer, counterOwner)) {244 if (!isReset || !areRenderersElementsSiblings(*currentRenderer, counterOwner)) { 249 245 parent = currentCounter->parent(); 250 246 previousSibling = currentCounter; … … 258 254 // of our owner renderer was not a reset counter. 259 255 // Set a new goal for the end of the search. 260 searchEndRenderer = previousSiblingOrParent( currentRenderer);256 searchEndRenderer = previousSiblingOrParent(*currentRenderer); 261 257 } else { 262 258 // We are searching descendants of a previous sibling of the renderer that the … … 271 267 // We are no longer interested in previous siblings of the currentRenderer or their children 272 268 // as counters they may have attached cannot be the previous sibling of the counter we are placing. 273 currentRenderer = parentOrPseudoHostElement( currentRenderer)->renderer();269 currentRenderer = parentOrPseudoHostElement(*currentRenderer)->renderer(); 274 270 continue; 275 271 } 276 272 } else 277 273 previousSiblingProtector = currentCounter; 278 currentRenderer = previousSiblingOrParent( currentRenderer);274 currentRenderer = previousSiblingOrParent(*currentRenderer); 279 275 continue; 280 276 } … … 285 281 // impede the readability of this already complex algorithm. 286 282 if (previousSiblingProtector) 287 currentRenderer = previousSiblingOrParent( currentRenderer);283 currentRenderer = previousSiblingOrParent(*currentRenderer); 288 284 else 289 currentRenderer = previousInPreOrder( currentRenderer);285 currentRenderer = previousInPreOrder(*currentRenderer); 290 286 } 291 287 return false; 292 288 } 293 289 294 static CounterNode* makeCounterNode(RenderObject* object, const AtomicString& identifier, bool alwaysCreateCounter) 295 { 296 ASSERT(object); 297 298 // Real text nodes don't have their own style so they can't have counters. 299 // We can't even look at their styles or we'll see extra resets and increments! 300 if (object->isText()) 301 return nullptr; 302 303 RenderElement* element = toRenderElement(object); 304 305 if (element->hasCounterNodeMap()) { 306 if (CounterMap* nodeMap = counterMaps().get(element)) { 290 static CounterNode* makeCounterNode(RenderElement& renderer, const AtomicString& identifier, bool alwaysCreateCounter) 291 { 292 if (renderer.hasCounterNodeMap()) { 293 if (CounterMap* nodeMap = counterMaps().get(&renderer)) { 307 294 if (CounterNode* node = nodeMap->get(identifier)) 308 295 return node; … … 312 299 bool isReset = false; 313 300 int value = 0; 314 if (!planCounter( element, identifier, isReset, value) && !alwaysCreateCounter)301 if (!planCounter(renderer, identifier, isReset, value) && !alwaysCreateCounter) 315 302 return nullptr; 316 303 317 304 RefPtr<CounterNode> newParent = 0; 318 305 RefPtr<CounterNode> newPreviousSibling = 0; 319 RefPtr<CounterNode> newNode = CounterNode::create( element, isReset, value);320 if (findPlaceForCounter( element, identifier, isReset, newParent, newPreviousSibling))306 RefPtr<CounterNode> newNode = CounterNode::create(renderer, isReset, value); 307 if (findPlaceForCounter(renderer, identifier, isReset, newParent, newPreviousSibling)) 321 308 newParent->insertAfter(newNode.get(), newPreviousSibling.get(), identifier); 322 309 CounterMap* nodeMap; 323 if ( element->hasCounterNodeMap())324 nodeMap = counterMaps().get( element);310 if (renderer.hasCounterNodeMap()) 311 nodeMap = counterMaps().get(&renderer); 325 312 else { 326 313 nodeMap = new CounterMap; 327 counterMaps().set( element, std::unique_ptr<CounterMap>(nodeMap));328 element->setHasCounterNodeMap(true);314 counterMaps().set(&renderer, std::unique_ptr<CounterMap>(nodeMap)); 315 renderer.setHasCounterNodeMap(true); 329 316 } 330 317 nodeMap->set(identifier, newNode); … … 334 321 // should become children of this node now. 335 322 CounterMaps& maps = counterMaps(); 336 Element* stayWithin = parentOrPseudoHostElement( element);323 Element* stayWithin = parentOrPseudoHostElement(renderer); 337 324 bool skipDescendants; 338 for (RenderElement* currentRenderer = nextInPreOrder( element, stayWithin); currentRenderer; currentRenderer = nextInPreOrder(currentRenderer, stayWithin, skipDescendants)) {325 for (RenderElement* currentRenderer = nextInPreOrder(renderer, stayWithin); currentRenderer; currentRenderer = nextInPreOrder(*currentRenderer, stayWithin, skipDescendants)) { 339 326 skipDescendants = false; 340 327 if (!currentRenderer->hasCounterNodeMap()) … … 346 333 if (currentCounter->parent()) 347 334 continue; 348 if (stayWithin == parentOrPseudoHostElement( currentRenderer) && currentCounter->hasResetType())335 if (stayWithin == parentOrPseudoHostElement(*currentRenderer) && currentCounter->hasResetType()) 349 336 break; 350 337 newNode->insertAfter(currentCounter, newNode->lastChild(), identifier); … … 400 387 beforeAfterContainer = beforeAfterContainer->parent(); 401 388 } 402 makeCounterNode( beforeAfterContainer, m_counter.identifier(), true)->addRenderer(const_cast<RenderCounter*>(this));389 makeCounterNode(*beforeAfterContainer, m_counter.identifier(), true)->addRenderer(const_cast<RenderCounter*>(this)); 403 390 ASSERT(m_counterNode); 404 391 } … … 457 444 previous = child->previousInPreOrder(); 458 445 child->parent()->removeChild(child.get()); 459 ASSERT(counterMaps().get( child->owner())->get(identifier) == child);460 counterMaps().get( child->owner())->remove(identifier);446 ASSERT(counterMaps().get(&child->owner())->get(identifier) == child); 447 counterMaps().get(&child->owner())->remove(identifier); 461 448 } 462 449 if (CounterNode* parent = node->parent()) … … 464 451 } 465 452 466 void RenderCounter::destroyCounterNodes(Render Object*owner)453 void RenderCounter::destroyCounterNodes(RenderElement& owner) 467 454 { 468 455 CounterMaps& maps = counterMaps(); 469 CounterMaps::iterator mapsIterator = maps.find( owner);456 CounterMaps::iterator mapsIterator = maps.find(&owner); 470 457 if (mapsIterator == maps.end()) 471 458 return; … … 476 463 } 477 464 maps.remove(mapsIterator); 478 owner ->setHasCounterNodeMap(false);479 } 480 481 void RenderCounter::destroyCounterNode(Render Object*owner, const AtomicString& identifier)482 { 483 CounterMap* map = counterMaps().get( owner);465 owner.setHasCounterNodeMap(false); 466 } 467 468 void RenderCounter::destroyCounterNode(RenderElement& owner, const AtomicString& identifier) 469 { 470 CounterMap* map = counterMaps().get(&owner); 484 471 if (!map) 485 472 return; … … 502 489 } 503 490 504 void RenderCounter::rendererRemovedFromTree(Render Object& renderer)491 void RenderCounter::rendererRemovedFromTree(RenderElement& renderer) 505 492 { 506 493 if (!renderer.view().hasRenderCounters()) … … 510 497 currentRenderer = &renderer; 511 498 while (true) { 512 destroyCounterNodes(currentRenderer); 499 if (currentRenderer->isRenderElement()) 500 destroyCounterNodes(toRenderElement(*currentRenderer)); 513 501 if (currentRenderer == &renderer) 514 502 break; … … 517 505 } 518 506 519 static void updateCounters(Render Object*renderer)520 { 521 const CounterDirectiveMap* directiveMap = renderer ->style().counterDirectives();507 static void updateCounters(RenderElement& renderer) 508 { 509 const CounterDirectiveMap* directiveMap = renderer.style().counterDirectives(); 522 510 if (!directiveMap) 523 511 return; 524 512 CounterDirectiveMap::const_iterator end = directiveMap->end(); 525 if (!renderer ->hasCounterNodeMap()) {513 if (!renderer.hasCounterNodeMap()) { 526 514 for (CounterDirectiveMap::const_iterator it = directiveMap->begin(); it != end; ++it) 527 515 makeCounterNode(renderer, it->key, false); 528 516 return; 529 517 } 530 CounterMap* counterMap = counterMaps().get( renderer);518 CounterMap* counterMap = counterMaps().get(&renderer); 531 519 ASSERT(counterMap); 532 520 for (CounterDirectiveMap::const_iterator it = directiveMap->begin(); it != end; ++it) { … … 552 540 } 553 541 554 void RenderCounter::rendererSubtreeAttached(Render Object*renderer)555 { 556 if (!renderer ->view().hasRenderCounters())557 return; 558 Node* node = renderer->node();559 if ( node && !node->isPseudoElement())560 node = node->parentNode();542 void RenderCounter::rendererSubtreeAttached(RenderElement& renderer) 543 { 544 if (!renderer.view().hasRenderCounters()) 545 return; 546 Element* element = renderer.element(); 547 if (element && !element->isPseudoElement()) 548 element = element->parentElement(); 561 549 else 562 node = renderer->generatingNode();563 if ( node && !node->renderer())550 element = renderer.generatingElement(); 551 if (element && !element->renderer()) 564 552 return; // No need to update if the parent is not attached yet 565 for (RenderObject* descendant = renderer; descendant; descendant = descendant->nextInPreOrder(renderer)) 566 updateCounters(descendant); 567 } 568 569 void RenderCounter::rendererStyleChanged(RenderObject* renderer, const RenderStyle* oldStyle, const RenderStyle* newStyle) 570 { 571 Node* node = renderer->generatingNode(); 572 if (!node || !node->renderer()) 553 for (RenderObject* descendant = &renderer; descendant; descendant = descendant->nextInPreOrder(&renderer)) { 554 if (descendant->isRenderElement()) 555 updateCounters(toRenderElement(*descendant)); 556 } 557 } 558 559 void RenderCounter::rendererStyleChanged(RenderElement& renderer, const RenderStyle* oldStyle, const RenderStyle* newStyle) 560 { 561 Element* element = renderer.generatingElement(); 562 if (!element || !element->renderer()) 573 563 return; // cannot have generated content or if it can have, it will be handled during attaching 574 564 const CounterDirectiveMap* newCounterDirectives; … … 596 586 } 597 587 } else { 598 if (renderer ->hasCounterNodeMap())588 if (renderer.hasCounterNodeMap()) 599 589 RenderCounter::destroyCounterNodes(renderer); 600 590 } … … 624 614 AtomicString identifier(counterName); 625 615 for (const WebCore::RenderObject* current = root; current; current = current->nextInPreOrder()) { 616 if (!current->isRenderElement()) 617 continue; 626 618 fprintf(stderr, "%c", (current == renderer) ? '*' : ' '); 627 619 for (const WebCore::RenderObject* parent = current; parent && parent != root; parent = parent->parent()) … … 629 621 fprintf(stderr, "%p N:%p P:%p PS:%p NS:%p C:%p\n", 630 622 current, current->node(), current->parent(), current->previousSibling(), 631 current->nextSibling(), current->hasCounterNodeMap() ?632 counterName ? WebCore::counterMaps().get( current)->get(identifier) : (WebCore::CounterNode*)1 : (WebCore::CounterNode*)0);623 current->nextSibling(), toRenderElement(current)->hasCounterNodeMap() ? 624 counterName ? WebCore::counterMaps().get(toRenderElement(current))->get(identifier) : (WebCore::CounterNode*)1 : (WebCore::CounterNode*)0); 633 625 } 634 626 fflush(stderr); -
trunk/Source/WebCore/rendering/RenderCounter.h
r163793 r172730 35 35 virtual ~RenderCounter(); 36 36 37 static void destroyCounterNodes(Render Object*);38 static void destroyCounterNode(Render Object*, const AtomicString& identifier);39 static void rendererSubtreeAttached(Render Object*);40 static void rendererRemovedFromTree(Render Object&);41 static void rendererStyleChanged(Render Object*, const RenderStyle* oldStyle, const RenderStyle* newStyle);37 static void destroyCounterNodes(RenderElement&); 38 static void destroyCounterNode(RenderElement&, const AtomicString& identifier); 39 static void rendererSubtreeAttached(RenderElement&); 40 static void rendererRemovedFromTree(RenderElement&); 41 static void rendererStyleChanged(RenderElement&, const RenderStyle* oldStyle, const RenderStyle* newStyle); 42 42 43 43 void updateCounter(); -
trunk/Source/WebCore/rendering/RenderElement.cpp
r172656 r172730 86 86 , m_renderBoxNeedsLazyRepaint(false) 87 87 , m_hasPausedImageAnimations(false) 88 , m_hasCounterNodeMap(false) 88 89 , m_firstChild(nullptr) 89 90 , m_lastChild(nullptr) … … 569 570 if (notifyChildren == NotifyChildren) 570 571 newChild->insertedIntoTree(); 571 RenderCounter::rendererSubtreeAttached(newChild); 572 if (newChild->isRenderElement()) 573 RenderCounter::rendererSubtreeAttached(toRenderElement(*newChild)); 572 574 } 573 575 … … 637 639 // rendererRemovedFromTree walks the whole subtree. We can improve performance 638 640 // by skipping this step when destroying the entire tree. 639 if (!documentBeingDestroyed() )640 RenderCounter::rendererRemovedFromTree( oldChild);641 if (!documentBeingDestroyed() && oldChild.isRenderElement()) 642 RenderCounter::rendererRemovedFromTree(toRenderElement(oldChild)); 641 643 642 644 if (AXObjectCache* cache = document().existingAXObjectCache()) … … 921 923 922 924 if (diff == StyleDifferenceLayout || diff == StyleDifferenceSimplifiedLayout) { 923 RenderCounter::rendererStyleChanged( this, oldStyle, &m_style.get());925 RenderCounter::rendererStyleChanged(*this, oldStyle, &m_style.get()); 924 926 925 927 // If the object already needs layout, then setNeedsLayout won't do … … 1007 1009 1008 1010 destroyLeftoverChildren(); 1011 1012 if (hasCounterNodeMap()) 1013 RenderCounter::destroyCounterNodes(*this); 1009 1014 1010 1015 RenderObject::willBeDestroyed(); -
trunk/Source/WebCore/rendering/RenderElement.h
r170774 r172730 160 160 bool renderBoxNeedsLazyRepaint() const { return m_renderBoxNeedsLazyRepaint; } 161 161 162 bool hasCounterNodeMap() const { return m_hasCounterNodeMap; } 163 void setHasCounterNodeMap(bool f) { m_hasCounterNodeMap = f; } 164 162 165 protected: 163 166 enum BaseTypeFlags { … … 232 235 bool m_renderBoxNeedsLazyRepaint : 1; 233 236 bool m_hasPausedImageAnimations : 1; 237 bool m_hasCounterNodeMap : 1; 234 238 235 239 RenderObject* m_firstChild; -
trunk/Source/WebCore/rendering/RenderObject.cpp
r172326 r172730 1942 1942 cache->remove(this); 1943 1943 1944 // If this renderer had a parent, remove should have destroyed any counters1945 // attached to this renderer and marked the affected other counters for1946 // reevaluation. This apparently redundant check is here for the case when1947 // this renderer had no parent at the time remove() was called.1948 1949 if (hasCounterNodeMap())1950 RenderCounter::destroyCounterNodes(this);1951 1952 1944 // FIXME: Would like to do this in RenderBoxModelObject, but the timing is so complicated that this can't easily 1953 1945 // be moved into RenderBoxModelObject::destroy. -
trunk/Source/WebCore/rendering/RenderObject.h
r170425 r172730 391 391 static inline bool isBeforeOrAfterContent(const RenderObject* obj) { return obj && obj->isBeforeOrAfterContent(); } 392 392 393 bool hasCounterNodeMap() const { return m_bitfields.hasCounterNodeMap(); }394 void setHasCounterNodeMap(bool hasCounterNodeMap) { m_bitfields.setHasCounterNodeMap(hasCounterNodeMap); }395 393 bool everHadLayout() const { return m_bitfields.everHadLayout(); } 396 394 … … 962 960 , m_hasTransform(false) 963 961 , m_hasReflection(false) 964 , m_hasCounterNodeMap(false)965 962 , m_everHadLayout(false) 966 963 , m_childrenInline(false) … … 972 969 } 973 970 974 // 3 2 bits have been used here. There are no bitsavailable.971 // 31 bits have been used here. There is one bit available. 975 972 ADD_BOOLEAN_BITFIELD(needsLayout, NeedsLayout); 976 973 ADD_BOOLEAN_BITFIELD(needsPositionedMovementLayout, NeedsPositionedMovementLayout); … … 995 992 ADD_BOOLEAN_BITFIELD(hasReflection, HasReflection); 996 993 997 ADD_BOOLEAN_BITFIELD(hasCounterNodeMap, HasCounterNodeMap);998 994 ADD_BOOLEAN_BITFIELD(everHadLayout, EverHadLayout); 999 995
Note: See TracChangeset
for help on using the changeset viewer.